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

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

游戏引擎

开发平台：

C++ Builder

lltexturectrl.cpp：源码内容
  1. /** 
  2.  * @file lltexturectrl.cpp
  3.  * @author Richard Nelson, James Cook
  4.  * @brief LLTextureCtrl class implementation including related functions
  5.  *
  6.  * $LicenseInfo:firstyear=2002&license=viewergpl$
  7.  * 
  8.  * Copyright (c) 2002-2010, Linden Research, Inc.
  9.  * 
  10.  * Second Life Viewer Source Code
  11.  * The source code in this file ("Source Code") is provided by Linden Lab
  12.  * to you under the terms of the GNU General Public License, version 2.0
  13.  * ("GPL"), unless you have obtained a separate licensing agreement
  14.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  15.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  16.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  17.  * 
  18.  * There are special exceptions to the terms and conditions of the GPL as
  19.  * it is applied to this Source Code. View the full text of the exception
  20.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  21.  * online at
  22.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  23.  * 
  24.  * By copying, modifying or distributing this software, you acknowledge
  25.  * that you have read and understood your obligations described above,
  26.  * and agree to abide by those obligations.
  27.  * 
  28.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  29.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  30.  * COMPLETENESS OR PERFORMANCE.
  31.  * $/LicenseInfo$
  32.  */
  34. #include "llviewerprecompiledheaders.h"
  36. #include "lltexturectrl.h"
  38. #include "llrender.h"
  39. #include "llagent.h"
  40. #include "llviewertexturelist.h"
  41. #include "llcheckboxctrl.h"
  42. #include "llcombobox.h"
  43. #include "llbutton.h"
  44. #include "lldraghandle.h"
  45. #include "llfocusmgr.h"
  46. #include "llviewertexture.h"
  47. #include "llfolderview.h"
  48. #include "llfoldervieweventlistener.h"
  49. #include "llinventory.h"
  50. #include "llinventoryfunctions.h"
  51. #include "llinventoryobserver.h"
  52. #include "llinventorypanel.h"
  53. #include "llfloaterinventory.h"
  54. #include "lllineeditor.h"
  55. #include "llui.h"
  56. #include "llviewerinventory.h"
  57. #include "llpermissions.h"
  58. #include "llsaleinfo.h"
  59. #include "llassetstorage.h"
  60. #include "lltextbox.h"
  61. #include "llresizehandle.h"
  62. #include "llscrollcontainer.h"
  63. #include "lltoolmgr.h"
  64. #include "lltoolpipette.h"
  65. #include "llfiltereditor.h"
  67. #include "lltool.h"
  68. #include "llviewerwindow.h"
  69. #include "llviewerobject.h"
  70. #include "llviewercontrol.h"
  71. #include "llglheaders.h"
  72. #include "lluictrlfactory.h"
  73. #include "lltrans.h"
  76. static const S32 HPAD = 4;
  77. static const S32 VPAD = 4;
  78. static const S32 LINE = 16;
  79. static const S32 FOOTER_HEIGHT = 100;
  80. static const S32 BORDER_PAD = HPAD;
  81. static const S32 TEXTURE_INVENTORY_PADDING = 30;
  82. static const F32 CONTEXT_CONE_IN_ALPHA = 0.0f;
  83. static const F32 CONTEXT_CONE_OUT_ALPHA = 1.f;
  84. static const F32 CONTEXT_FADE_TIME = 0.08f;
  86. //static const char CURRENT_IMAGE_NAME[] = "Current Texture";
  87. //static const char WHITE_IMAGE_NAME[] = "Blank Texture";
  88. //static const char NO_IMAGE_NAME[] = "None";
  90. //////////////////////////////////////////////////////////////////////////////////////////
  91. // LLFloaterTexturePicker
  93. class LLFloaterTexturePicker : public LLFloater
  94. {
  95. public:
  96. LLFloaterTexturePicker(
  97. LLTextureCtrl* owner,
  98. const std::string& label,
  99. PermissionMask immediate_filter_perm_mask,
  100. PermissionMask non_immediate_filter_perm_mask,
  101. BOOL can_apply_immediately,
  102. const std::string& fallback_image_name);
  104. virtual ~LLFloaterTexturePicker();
  106. // LLView overrides
  107. /*virtual*/ BOOL handleDragAndDrop(S32 x, S32 y, MASK mask,
  108. BOOL drop, EDragAndDropType cargo_type, void *cargo_data, 
  109. EAcceptance *accept,
  110. std::string& tooltip_msg);
  111. /*virtual*/ void draw();
  112. /*virtual*/ BOOL handleKeyHere(KEY key, MASK mask);
  114. // LLFloater overrides
  115. /*virtual*/ BOOL    postBuild();
  116. /*virtual*/ void onClose(bool app_settings);
  118. // New functions
  119. void setImageID( const LLUUID& image_asset_id);
  120. void updateImageStats();
  121. const LLUUID& getAssetID() { return mImageAssetID; }
  122. const LLUUID& findItemID(const LLUUID& asset_id, BOOL copyable_only);
  123. void setCanApplyImmediately(BOOL b);
  125. void setActive( BOOL active );
  127. LLTextureCtrl* getOwner() const { return mOwner; }
  128. void setOwner(LLTextureCtrl* owner) { mOwner = owner; }
  130. void stopUsingPipette();
  131. PermissionMask  getFilterPermMask();
  132. void updateFilterPermMask();
  133. void commitIfImmediateSet();
  135. void onFilterEdit(const std::string& search_string );
  137. static void onBtnSetToDefault( void* userdata );
  138. static void onBtnSelect( void* userdata );
  139. static void onBtnCancel( void* userdata );
  140.    void onBtnPipette( );
  141. //static void onBtnRevert( void* userdata );
  142. static void onBtnWhite( void* userdata );
  143. static void onBtnNone( void* userdata );
  144. static void onBtnClear( void* userdata );
  145.    void onSelectionChange(const std::deque<LLFolderViewItem*> &items, BOOL user_action);
  146. static void onShowFolders(LLUICtrl* ctrl, void* userdata);
  147. static void onApplyImmediateCheck(LLUICtrl* ctrl, void* userdata);
  148.    void onTextureSelect( const LLTextureEntry& te );
  150. protected:
  151. LLPointer<LLViewerTexture> mTexturep;
  152. LLTextureCtrl* mOwner;
  154. LLUUID mImageAssetID; // Currently selected texture
  155. std::string mFallbackImageName; // What to show if currently selected texture is null.
  157. LLUUID mWhiteImageAssetID;
  158. LLUUID mSpecialCurrentImageAssetID;  // Used when the asset id has no corresponding texture in the user's inventory.
  159. LLUUID mOriginalImageAssetID;
  161. std::string mLabel;
  163. LLTextBox* mTentativeLabel;
  164. LLTextBox* mResolutionLabel;
  166. std::string mPendingName;
  167. BOOL mActive;
  169. LLFilterEditor* mFilterEdit;
  170. LLInventoryPanel* mInventoryPanel;
  171. PermissionMask mImmediateFilterPermMask;
  172. PermissionMask mNonImmediateFilterPermMask;
  173. BOOL mCanApplyImmediately;
  174. BOOL mNoCopyTextureSelected;
  175. F32 mContextConeOpacity;
  176. LLSaveFolderState mSavedFolderState;
  177. };
  179. LLFloaterTexturePicker::LLFloaterTexturePicker(
  180. LLTextureCtrl* owner,
  181. const std::string& label,
  182. PermissionMask immediate_filter_perm_mask,
  183. PermissionMask non_immediate_filter_perm_mask,
  184. BOOL can_apply_immediately,
  185. const std::string& fallback_image_name)
  186. : LLFloater(LLSD()),
  187. mOwner( owner ),
  188. mImageAssetID( owner->getImageAssetID() ),
  189. mFallbackImageName( fallback_image_name ),
  190. mWhiteImageAssetID( gSavedSettings.getString( "UIImgWhiteUUID" ) ),
  191. mOriginalImageAssetID(owner->getImageAssetID()),
  192. mLabel(label),
  193. mTentativeLabel(NULL),
  194. mResolutionLabel(NULL),
  195. mActive( TRUE ),
  196. mFilterEdit(NULL),
  197. mImmediateFilterPermMask(immediate_filter_perm_mask),
  198. mNonImmediateFilterPermMask(non_immediate_filter_perm_mask),
  199. mContextConeOpacity(0.f)
  200. {
  201. mCanApplyImmediately = can_apply_immediately;
  202. LLUICtrlFactory::getInstance()->buildFloater(this,"floater_texture_ctrl.xml",NULL);
  203. setCanMinimize(FALSE);
  204. }
  206. LLFloaterTexturePicker::~LLFloaterTexturePicker()
  207. {
  208. }
  210. void LLFloaterTexturePicker::setImageID(const LLUUID& image_id)
  211. {
  212. if( mImageAssetID != image_id && mActive)
  213. {
  214. mNoCopyTextureSelected = FALSE;
  215. mViewModel->setDirty(); // *TODO: shouldn't we be using setValue() here?
  216. mImageAssetID = image_id; 
  217. LLUUID item_id = findItemID(mImageAssetID, FALSE);
  218. if (item_id.isNull())
  219. {
  220. mInventoryPanel->clearSelection();
  221. }
  222. else
  223. {
  224. LLInventoryItem* itemp = gInventory.getItem(image_id);
  225. if (itemp && !itemp->getPermissions().allowCopyBy(gAgent.getID()))
  226. {
  227. // no copy texture
  228. childSetValue("apply_immediate_check", FALSE);
  229. mNoCopyTextureSelected = TRUE;
  230. }
  231. mInventoryPanel->setSelection(item_id, TAKE_FOCUS_NO);
  232. }
  233. }
  234. }
  236. void LLFloaterTexturePicker::setActive( BOOL active )
  237. {
  238. if (!active && childGetValue("Pipette").asBoolean())
  239. {
  240. stopUsingPipette();
  241. }
  242. mActive = active; 
  243. }
  245. void LLFloaterTexturePicker::setCanApplyImmediately(BOOL b)
  246. {
  247. mCanApplyImmediately = b;
  248. if (!mCanApplyImmediately)
  249. {
  250. childSetValue("apply_immediate_check", FALSE);
  251. }
  252. updateFilterPermMask();
  253. }
  255. void LLFloaterTexturePicker::stopUsingPipette()
  256. {
  257. if (LLToolMgr::getInstance()->getCurrentTool() == LLToolPipette::getInstance())
  258. {
  259. LLToolMgr::getInstance()->clearTransientTool();
  260. }
  261. }
  263. void LLFloaterTexturePicker::updateImageStats()
  264. {
  265. if (mTexturep.notNull())
  266. {
  267. //RN: have we received header data for this image?
  268. if (mTexturep->getFullWidth() > 0 && mTexturep->getFullHeight() > 0)
  269. {
  270. std::string formatted_dims = llformat("%d x %d", mTexturep->getFullWidth(),mTexturep->getFullHeight());
  271. mResolutionLabel->setTextArg("[DIMENSIONS]", formatted_dims);
  272. }
  273. else
  274. {
  275. mResolutionLabel->setTextArg("[DIMENSIONS]", std::string("[? x ?]"));
  276. }
  277. }
  278. else
  279. {
  280. mResolutionLabel->setTextArg("[DIMENSIONS]", std::string(""));
  281. }
  282. }
  284. // virtual
  285. BOOL LLFloaterTexturePicker::handleDragAndDrop( 
  286. S32 x, S32 y, MASK mask,
  287. BOOL drop,
  288. EDragAndDropType cargo_type, void *cargo_data, 
  289. EAcceptance *accept,
  290. std::string& tooltip_msg)
  291. {
  292. BOOL handled = FALSE;
  294. if (cargo_type == DAD_TEXTURE)
  295. {
  296. LLInventoryItem *item = (LLInventoryItem *)cargo_data;
  298. BOOL copy = item->getPermissions().allowCopyBy(gAgent.getID());
  299. BOOL mod = item->getPermissions().allowModifyBy(gAgent.getID());
  300. BOOL xfer = item->getPermissions().allowOperationBy(PERM_TRANSFER,
  301. gAgent.getID());
  303. PermissionMask item_perm_mask = 0;
  304. if (copy) item_perm_mask |= PERM_COPY;
  305. if (mod)  item_perm_mask |= PERM_MODIFY;
  306. if (xfer) item_perm_mask |= PERM_TRANSFER;
  308. //PermissionMask filter_perm_mask = getFilterPermMask();  Commented out due to no-copy texture loss.
  309. PermissionMask filter_perm_mask = mImmediateFilterPermMask;
  310. if ( (item_perm_mask & filter_perm_mask) == filter_perm_mask )
  311. {
  312. if (drop)
  313. {
  314. setImageID( item->getAssetUUID() );
  315. commitIfImmediateSet();
  316. }
  318. *accept = ACCEPT_YES_SINGLE;
  319. }
  320. else
  321. {
  322. *accept = ACCEPT_NO;
  323. }
  324. }
  325. else
  326. {
  327. *accept = ACCEPT_NO;
  328. }
  330. handled = TRUE;
  331. lldebugst(LLERR_USER_INPUT) << "dragAndDrop handled by LLFloaterTexturePicker " << getName() << llendl;
  333. return handled;
  334. }
  336. BOOL LLFloaterTexturePicker::handleKeyHere(KEY key, MASK mask)
  337. {
  338. LLFolderView* root_folder = mInventoryPanel->getRootFolder();
  340. if (root_folder && mFilterEdit)
  341. {
  342. if (mFilterEdit->hasFocus() 
  343. && (key == KEY_RETURN || key == KEY_DOWN) 
  344. && mask == MASK_NONE)
  345. {
  346. if (!root_folder->getCurSelectedItem())
  347. {
  348. LLFolderViewItem* itemp = root_folder->getItemByID(gInventory.getRootFolderID());
  349. if (itemp)
  350. {
  351. root_folder->setSelection(itemp, FALSE, FALSE);
  352. }
  353. }
  354. root_folder->scrollToShowSelection();
  356. // move focus to inventory proper
  357. mInventoryPanel->setFocus(TRUE);
  359. // treat this as a user selection of the first filtered result
  360. commitIfImmediateSet();
  362. return TRUE;
  363. }
  365. if (mInventoryPanel->hasFocus() && key == KEY_UP)
  366. {
  367. mFilterEdit->focusFirstItem(TRUE);
  368. }
  369. }
  371. return LLFloater::handleKeyHere(key, mask);
  372. }
  374. void LLFloaterTexturePicker::onClose(bool app_quitting)
  375. {
  376. if (mOwner)
  377. {
  378. mOwner->onFloaterClose();
  379. }
  380. stopUsingPipette();
  381. }
  383. // virtual
  384. BOOL LLFloaterTexturePicker::postBuild()
  385. {
  386. LLFloater::postBuild();
  388. if (!mLabel.empty())
  389. {
  390. std::string pick = getString("pick title");
  392. setTitle(pick + mLabel);
  393. }
  394. mTentativeLabel = getChild<LLTextBox>("Multiple");
  396. mResolutionLabel = getChild<LLTextBox>("unknown");
  399. childSetAction("Default",LLFloaterTexturePicker::onBtnSetToDefault,this);
  400. childSetAction("None", LLFloaterTexturePicker::onBtnNone,this);
  401. childSetAction("Blank", LLFloaterTexturePicker::onBtnWhite,this);
  404. childSetCommitCallback("show_folders_check", onShowFolders, this);
  405. childSetVisible("show_folders_check", FALSE);
  407. mFilterEdit = getChild<LLFilterEditor>("inventory search editor");
  408. mFilterEdit->setCommitCallback(boost::bind(&LLFloaterTexturePicker::onFilterEdit, this, _2));
  410. mInventoryPanel = getChild<LLInventoryPanel>("inventory panel");
  412. if(mInventoryPanel)
  413. {
  414. U32 filter_types = 0x0;
  415. filter_types |= 0x1 << LLInventoryType::IT_TEXTURE;
  416. filter_types |= 0x1 << LLInventoryType::IT_SNAPSHOT;
  418. mInventoryPanel->setFilterTypes(filter_types);
  419. //mInventoryPanel->setFilterPermMask(getFilterPermMask());  //Commented out due to no-copy texture loss.
  420. mInventoryPanel->setFilterPermMask(mImmediateFilterPermMask);
  421. mInventoryPanel->setSelectCallback(boost::bind(&LLFloaterTexturePicker::onSelectionChange, this, _1, _2));
  422. mInventoryPanel->setShowFolderState(LLInventoryFilter::SHOW_NON_EMPTY_FOLDERS);
  423. mInventoryPanel->setAllowMultiSelect(FALSE);
  425. // store this filter as the default one
  426. mInventoryPanel->getRootFolder()->getFilter()->markDefault();
  428. // Commented out to stop opening all folders with textures
  429. // mInventoryPanel->openDefaultFolderForType(LLFolderType::FT_TEXTURE);
  431. // don't put keyboard focus on selected item, because the selection callback
  432. // will assume that this was user input
  433. mInventoryPanel->setSelection(findItemID(mImageAssetID, FALSE), TAKE_FOCUS_NO);
  434. }
  437. mNoCopyTextureSelected = FALSE;
  439. childSetValue("apply_immediate_check", gSavedSettings.getBOOL("ApplyTextureImmediately"));
  440. childSetCommitCallback("apply_immediate_check", onApplyImmediateCheck, this);
  442. if (!mCanApplyImmediately)
  443. {
  444. childSetEnabled("show_folders_check", FALSE);
  445. }
  447. getChild<LLUICtrl>("Pipette")->setCommitCallback( boost::bind(&LLFloaterTexturePicker::onBtnPipette, this));
  448. childSetAction("Cancel", LLFloaterTexturePicker::onBtnCancel,this);
  449. childSetAction("Select", LLFloaterTexturePicker::onBtnSelect,this);
  451. // update permission filter once UI is fully initialized
  452. updateFilterPermMask();
  453. mSavedFolderState.setApply(FALSE);
  455. LLToolPipette::getInstance()->setToolSelectCallback(boost::bind(&LLFloaterTexturePicker::onTextureSelect, this, _1));
  457. return TRUE;
  458. }
  460. // virtual
  461. void LLFloaterTexturePicker::draw()
  462. {
  463. S32 floater_header_size = getHeaderHeight();
  464. if (mOwner)
  465. {
  466. // draw cone of context pointing back to texture swatch
  467. LLRect owner_rect;
  468. mOwner->localRectToOtherView(mOwner->getLocalRect(), &owner_rect, this);
  469. LLRect local_rect = getLocalRect();
  470. if (gFocusMgr.childHasKeyboardFocus(this) && mOwner->isInVisibleChain() && mContextConeOpacity > 0.001f)
  471. {
  472. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  473. LLGLEnable(GL_CULL_FACE);
  474. gGL.begin(LLRender::QUADS);
  475. {
  476. gGL.color4f(0.f, 0.f, 0.f, CONTEXT_CONE_IN_ALPHA * mContextConeOpacity);
  477. gGL.vertex2i(owner_rect.mLeft, owner_rect.mTop);
  478. gGL.vertex2i(owner_rect.mRight, owner_rect.mTop);
  479. gGL.color4f(0.f, 0.f, 0.f, CONTEXT_CONE_OUT_ALPHA * mContextConeOpacity);
  480. gGL.vertex2i(local_rect.mRight, local_rect.mTop);
  481. gGL.vertex2i(local_rect.mLeft, local_rect.mTop);
  483. gGL.color4f(0.f, 0.f, 0.f, CONTEXT_CONE_OUT_ALPHA * mContextConeOpacity);
  484. gGL.vertex2i(local_rect.mLeft, local_rect.mTop);
  485. gGL.vertex2i(local_rect.mLeft, local_rect.mBottom);
  486. gGL.color4f(0.f, 0.f, 0.f, CONTEXT_CONE_IN_ALPHA * mContextConeOpacity);
  487. gGL.vertex2i(owner_rect.mLeft, owner_rect.mBottom);
  488. gGL.vertex2i(owner_rect.mLeft, owner_rect.mTop);
  490. gGL.color4f(0.f, 0.f, 0.f, CONTEXT_CONE_OUT_ALPHA * mContextConeOpacity);
  491. gGL.vertex2i(local_rect.mRight, local_rect.mBottom);
  492. gGL.vertex2i(local_rect.mRight, local_rect.mTop);
  493. gGL.color4f(0.f, 0.f, 0.f, CONTEXT_CONE_IN_ALPHA * mContextConeOpacity);
  494. gGL.vertex2i(owner_rect.mRight, owner_rect.mTop);
  495. gGL.vertex2i(owner_rect.mRight, owner_rect.mBottom);
  498. gGL.color4f(0.f, 0.f, 0.f, CONTEXT_CONE_OUT_ALPHA * mContextConeOpacity);
  499. gGL.vertex2i(local_rect.mLeft, local_rect.mBottom);
  500. gGL.vertex2i(local_rect.mRight, local_rect.mBottom);
  501. gGL.color4f(0.f, 0.f, 0.f, CONTEXT_CONE_IN_ALPHA * mContextConeOpacity);
  502. gGL.vertex2i(owner_rect.mRight, owner_rect.mBottom);
  503. gGL.vertex2i(owner_rect.mLeft, owner_rect.mBottom);
  504. }
  505. gGL.end();
  506. }
  507. }
  509. if (gFocusMgr.childHasMouseCapture(getDragHandle()))
  510. {
  511. mContextConeOpacity = lerp(mContextConeOpacity, gSavedSettings.getF32("PickerContextOpacity"), LLCriticalDamp::getInterpolant(CONTEXT_FADE_TIME));
  512. }
  513. else
  514. {
  515. mContextConeOpacity = lerp(mContextConeOpacity, 0.f, LLCriticalDamp::getInterpolant(CONTEXT_FADE_TIME));
  516. }
  518. updateImageStats();
  520. // if we're inactive, gray out "apply immediate" checkbox
  521. childSetEnabled("show_folders_check", mActive && mCanApplyImmediately && !mNoCopyTextureSelected);
  522. childSetEnabled("Select", mActive);
  523. childSetEnabled("Pipette", mActive);
  524. childSetValue("Pipette", LLToolMgr::getInstance()->getCurrentTool() == LLToolPipette::getInstance());
  526. //BOOL allow_copy = FALSE;
  527. if( mOwner ) 
  528. {
  529. mTexturep = NULL;
  530. if(mImageAssetID.notNull())
  531. {
  532. mTexturep = LLViewerTextureManager::getFetchedTexture(mImageAssetID, MIPMAP_YES);
  533. mTexturep->setBoostLevel(LLViewerTexture::BOOST_PREVIEW);
  534. }
  535. else if (!mFallbackImageName.empty())
  536. {
  537. mTexturep = LLViewerTextureManager::getFetchedTextureFromFile(mFallbackImageName);
  538. mTexturep->setBoostLevel(LLViewerTexture::BOOST_PREVIEW);
  539. }
  541. if (mTentativeLabel)
  542. {
  543. mTentativeLabel->setVisible( FALSE  );
  544. }
  546. childSetEnabled("Default",  mImageAssetID != mOwner->getDefaultImageAssetID());
  547. childSetEnabled("Blank",   mImageAssetID != mWhiteImageAssetID );
  548. childSetEnabled("None", mOwner->getAllowNoTexture() && !mImageAssetID.isNull() );
  550. LLFloater::draw();
  552. if( isMinimized() )
  553. {
  554. return;
  555. }
  557. // Border
  558. LLRect border( BORDER_PAD, 
  559.    getRect().getHeight() - floater_header_size - BORDER_PAD, 
  560.    ((getMinWidth() / 2) - TEXTURE_INVENTORY_PADDING - HPAD) - BORDER_PAD,
  561.    BORDER_PAD + FOOTER_HEIGHT + (getRect().getHeight() - getMinHeight()));
  562. gl_rect_2d( border, LLColor4::black, FALSE );
  565. // Interior
  566. LLRect interior = border;
  567. interior.stretch( -1 ); 
  569. if( mTexturep )
  570. {
  571. if( mTexturep->getComponents() == 4 )
  572. {
  573. gl_rect_2d_checkerboard( interior );
  574. }
  576. gl_draw_scaled_image( interior.mLeft, interior.mBottom, interior.getWidth(), interior.getHeight(), mTexturep );
  578. // Pump the priority
  579. mTexturep->addTextureStats( (F32)(interior.getWidth() * interior.getHeight()) );
  581. // Draw Tentative Label over the image
  582. if( mOwner->getTentative() && !mViewModel->isDirty() )
  583. {
  584. mTentativeLabel->setVisible( TRUE );
  585. drawChild(mTentativeLabel);
  586. }
  587. }
  588. else
  589. {
  590. gl_rect_2d( interior, LLColor4::grey, TRUE );
  592. // Draw X
  593. gl_draw_x(interior, LLColor4::black );
  594. }
  595. }
  596. }
  598. // static
  599. /*
  600. void LLFloaterTexturePicker::onSaveAnotherCopyDialog( S32 option, void* userdata )
  601. {
  602. LLFloaterTexturePicker* self = (LLFloaterTexturePicker*) userdata;
  603. if( 0 == option )
  604. {
  605. self->copyToInventoryFinal();
  606. }
  607. }
  608. */
  610. const LLUUID& LLFloaterTexturePicker::findItemID(const LLUUID& asset_id, BOOL copyable_only)
  611. {
  612. LLViewerInventoryCategory::cat_array_t cats;
  613. LLViewerInventoryItem::item_array_t items;
  614. LLAssetIDMatches asset_id_matches(asset_id);
  615. gInventory.collectDescendentsIf(LLUUID::null,
  616. cats,
  617. items,
  618. LLInventoryModel::INCLUDE_TRASH,
  619. asset_id_matches);
  621. if (items.count())
  622. {
  623. // search for copyable version first
  624. for (S32 i = 0; i < items.count(); i++)
  625. {
  626. LLInventoryItem* itemp = items[i];
  627. LLPermissions item_permissions = itemp->getPermissions();
  628. if (item_permissions.allowCopyBy(gAgent.getID(), gAgent.getGroupID()))
  629. {
  630. return itemp->getUUID();
  631. }
  632. }
  633. // otherwise just return first instance, unless copyable requested
  634. if (copyable_only)
  635. {
  636. return LLUUID::null;
  637. }
  638. else
  639. {
  640. return items[0]->getUUID();
  641. }
  642. }
  644. return LLUUID::null;
  645. }
  647. PermissionMask LLFloaterTexturePicker::getFilterPermMask()
  648. {
  649. bool apply_immediate = childGetValue("apply_immediate_check").asBoolean();
  650. return apply_immediate ? mImmediateFilterPermMask : mNonImmediateFilterPermMask;
  651. }
  653. void LLFloaterTexturePicker::commitIfImmediateSet()
  654. {
  655. bool apply_immediate = childGetValue("apply_immediate_check").asBoolean();
  656. if (!mNoCopyTextureSelected && apply_immediate && mOwner)
  657. {
  658. mOwner->onFloaterCommit(LLTextureCtrl::TEXTURE_CHANGE);
  659. }
  660. }
  662. // static
  663. void LLFloaterTexturePicker::onBtnSetToDefault(void* userdata)
  664. {
  665. LLFloaterTexturePicker* self = (LLFloaterTexturePicker*) userdata;
  666. if (self->mOwner)
  667. {
  668. self->setImageID( self->mOwner->getDefaultImageAssetID() );
  669. }
  670. self->commitIfImmediateSet();
  671. }
  673. // static
  674. void LLFloaterTexturePicker::onBtnWhite(void* userdata)
  675. {
  676. LLFloaterTexturePicker* self = (LLFloaterTexturePicker*) userdata;
  677. self->setImageID( self->mWhiteImageAssetID );
  678. self->commitIfImmediateSet();
  679. }
  682. // static
  683. void LLFloaterTexturePicker::onBtnNone(void* userdata)
  684. {
  685. LLFloaterTexturePicker* self = (LLFloaterTexturePicker*) userdata;
  686. self->setImageID( LLUUID::null );
  687. self->commitIfImmediateSet();
  688. }
  690. /*
  691. // static
  692. void LLFloaterTexturePicker::onBtnRevert(void* userdata)
  693. {
  694. LLFloaterTexturePicker* self = (LLFloaterTexturePicker*) userdata;
  695. self->setImageID( self->mOriginalImageAssetID );
  696. // TODO: Change this to tell the owner to cancel.  It needs to be
  697. // smart enough to restore multi-texture selections.
  698. self->mOwner->onFloaterCommit();
  699. self->mViewModel->resetDirty();
  700. }*/
  702. // static
  703. void LLFloaterTexturePicker::onBtnCancel(void* userdata)
  704. {
  705. LLFloaterTexturePicker* self = (LLFloaterTexturePicker*) userdata;
  706. self->setImageID( self->mOriginalImageAssetID );
  707. if (self->mOwner)
  708. {
  709. self->mOwner->onFloaterCommit(LLTextureCtrl::TEXTURE_CANCEL);
  710. }
  711. self->mViewModel->resetDirty();
  712. self->closeFloater();
  713. }
  715. // static
  716. void LLFloaterTexturePicker::onBtnSelect(void* userdata)
  717. {
  718. LLFloaterTexturePicker* self = (LLFloaterTexturePicker*) userdata;
  719. if (self->mOwner)
  720. {
  721. self->mOwner->onFloaterCommit(LLTextureCtrl::TEXTURE_SELECT);
  722. }
  723. self->closeFloater();
  724. }
  726. void LLFloaterTexturePicker::onBtnPipette()
  727. {
  728. BOOL pipette_active = childGetValue("Pipette").asBoolean();
  729. pipette_active = !pipette_active;
  730. if (pipette_active)
  731. {
  732. LLToolMgr::getInstance()->setTransientTool(LLToolPipette::getInstance());
  733. }
  734. else
  735. {
  736. LLToolMgr::getInstance()->clearTransientTool();
  737. }
  738. }
  740. void LLFloaterTexturePicker::onSelectionChange(const std::deque<LLFolderViewItem*> &items, BOOL user_action)
  741. {
  742. if (items.size())
  743. {
  744. LLFolderViewItem* first_item = items.front();
  745. LLInventoryItem* itemp = gInventory.getItem(first_item->getListener()->getUUID());
  746. mNoCopyTextureSelected = FALSE;
  747. if (itemp)
  748. {
  749. if (!itemp->getPermissions().allowCopyBy(gAgent.getID()))
  750. {
  751. mNoCopyTextureSelected = TRUE;
  752. }
  753. mImageAssetID = itemp->getAssetUUID();
  754. mViewModel->setDirty(); // *TODO: shouldn't we be using setValue() here?
  755. if (user_action)
  756. {
  757. // only commit intentional selections, not implicit ones
  758. commitIfImmediateSet();
  759. }
  760. }
  761. }
  762. }
  764. // static
  765. void LLFloaterTexturePicker::onShowFolders(LLUICtrl* ctrl, void *user_data)
  766. {
  767. LLCheckBoxCtrl* check_box = (LLCheckBoxCtrl*)ctrl;
  768. LLFloaterTexturePicker* picker = (LLFloaterTexturePicker*)user_data;
  770. if (check_box->get())
  771. {
  772. picker->mInventoryPanel->setShowFolderState(LLInventoryFilter::SHOW_NON_EMPTY_FOLDERS);
  773. }
  774. else
  775. {
  776. picker->mInventoryPanel->setShowFolderState(LLInventoryFilter::SHOW_NO_FOLDERS);
  777. }
  778. }
  780. // static
  781. void LLFloaterTexturePicker::onApplyImmediateCheck(LLUICtrl* ctrl, void *user_data)
  782. {
  783. LLFloaterTexturePicker* picker = (LLFloaterTexturePicker*)user_data;
  785. LLCheckBoxCtrl* check_box = (LLCheckBoxCtrl*)ctrl;
  786. gSavedSettings.setBOOL("ApplyTextureImmediately", check_box->get());
  788. picker->updateFilterPermMask();
  789. picker->commitIfImmediateSet();
  790. }
  792. void LLFloaterTexturePicker::updateFilterPermMask()
  793. {
  794. //mInventoryPanel->setFilterPermMask( getFilterPermMask() );  Commented out due to no-copy texture loss.
  795. }
  797. void LLFloaterTexturePicker::onFilterEdit(const std::string& search_string )
  798. {
  799. std::string upper_case_search_string = search_string;
  800. LLStringUtil::toUpper(upper_case_search_string);
  802. if (upper_case_search_string.empty())
  803. {
  804. if (mInventoryPanel->getFilterSubString().empty())
  805. {
  806. // current filter and new filter empty, do nothing
  807. return;
  808. }
  810. mSavedFolderState.setApply(TRUE);
  811. mInventoryPanel->getRootFolder()->applyFunctorRecursively(mSavedFolderState);
  812. // add folder with current item to list of previously opened folders
  813. LLOpenFoldersWithSelection opener;
  814. mInventoryPanel->getRootFolder()->applyFunctorRecursively(opener);
  815. mInventoryPanel->getRootFolder()->scrollToShowSelection();
  817. }
  818. else if (mInventoryPanel->getFilterSubString().empty())
  819. {
  820. // first letter in search term, save existing folder open state
  821. if (!mInventoryPanel->getRootFolder()->isFilterModified())
  822. {
  823. mSavedFolderState.setApply(FALSE);
  824. mInventoryPanel->getRootFolder()->applyFunctorRecursively(mSavedFolderState);
  825. }
  826. }
  828. mInventoryPanel->setFilterSubString(upper_case_search_string);
  829. }
  831. void LLFloaterTexturePicker::onTextureSelect( const LLTextureEntry& te )
  832. {
  833. LLUUID inventory_item_id = findItemID(te.getID(), TRUE);
  834. if (inventory_item_id.notNull())
  835. {
  836. LLToolPipette::getInstance()->setResult(TRUE, "");
  837. setImageID(te.getID());
  839. mNoCopyTextureSelected = FALSE;
  840. LLInventoryItem* itemp = gInventory.getItem(inventory_item_id);
  842. if (itemp && !itemp->getPermissions().allowCopyBy(gAgent.getID()))
  843. {
  844. // no copy texture
  845. mNoCopyTextureSelected = TRUE;
  846. }
  848. commitIfImmediateSet();
  849. }
  850. else
  851. {
  852. LLToolPipette::getInstance()->setResult(FALSE, LLTrans::getString("InventoryNoTexture"));
  853. }
  854. }
  856. ///////////////////////////////////////////////////////////////////////
  857. // LLTextureCtrl
  859. static LLDefaultChildRegistry::Register<LLTextureCtrl> r("texture_picker");
  861. LLTextureCtrl::LLTextureCtrl(const LLTextureCtrl::Params& p)
  862. : LLUICtrl(p),
  863. mDragCallback(NULL),
  864. mDropCallback(NULL),
  865. mOnCancelCallback(NULL),
  866. mOnSelectCallback(NULL),
  867. mBorderColor( p.border_color() ),
  868. mAllowNoTexture( FALSE ),
  869. mImmediateFilterPermMask( PERM_NONE ),
  870. mNonImmediateFilterPermMask( PERM_NONE ),
  871. mCanApplyImmediately( FALSE ),
  872. mNeedsRawImageData( FALSE ),
  873. mValid( TRUE ),
  874. mShowLoadingPlaceholder( TRUE ),
  875. mImageAssetID(p.image_id),
  876. mDefaultImageAssetID(p.default_image_id),
  877. mDefaultImageName(p.default_image_name)
  878. {
  879. setAllowNoTexture(p.allow_no_texture);
  880. setCanApplyImmediately(p.can_apply_immediately);
  881. mCommitOnSelection = !p.no_commit_on_selection;
  883. LLTextBox::Params params(p.caption_text);
  884. params.name(p.label);
  885. params.rect(LLRect( 0, BTN_HEIGHT_SMALL, getRect().getWidth(), 0 ));
  886. params.initial_value(p.label());
  887. params.follows.flags(FOLLOWS_LEFT | FOLLOWS_RIGHT | FOLLOWS_BOTTOM);
  888. mCaption = LLUICtrlFactory::create<LLTextBox> (params);
  889. addChild( mCaption );
  891. S32 image_top = getRect().getHeight();
  892. S32 image_bottom = BTN_HEIGHT_SMALL;
  893. S32 image_middle = (image_top + image_bottom) / 2;
  894. S32 line_height = llround(LLFontGL::getFontSansSerifSmall()->getLineHeight());
  896. LLTextBox::Params tentative_label_p(p.multiselect_text);
  897. tentative_label_p.name("Multiple");
  898. tentative_label_p.rect(LLRect (0, image_middle + line_height / 2, getRect().getWidth(), image_middle - line_height / 2 ));
  899. tentative_label_p.follows.flags(FOLLOWS_ALL);
  900. mTentativeLabel = LLUICtrlFactory::create<LLTextBox> (tentative_label_p);
  901. addChild( mTentativeLabel );
  903. LLRect border_rect = getLocalRect();
  904. border_rect.mBottom += BTN_HEIGHT_SMALL;
  905. LLViewBorder::Params vbparams(p.border);
  906. vbparams.name("border");
  907. vbparams.rect(border_rect);
  908. mBorder = LLUICtrlFactory::create<LLViewBorder> (vbparams);
  909. addChild(mBorder);
  911. mLoadingPlaceholderString = LLTrans::getString("texture_loading");
  912. }
  914. LLTextureCtrl::~LLTextureCtrl()
  915. {
  916. closeDependentFloater();
  917. }
  919. void LLTextureCtrl::setShowLoadingPlaceholder(BOOL showLoadingPlaceholder)
  920. {
  921. mShowLoadingPlaceholder = showLoadingPlaceholder;
  922. }
  924. void LLTextureCtrl::setCaption(const std::string& caption)
  925. {
  926. mCaption->setText( caption );
  927. }
  929. void LLTextureCtrl::setCanApplyImmediately(BOOL b)
  930. {
  931. mCanApplyImmediately = b; 
  932. LLFloaterTexturePicker* floaterp = (LLFloaterTexturePicker*)mFloaterHandle.get();
  933. if( floaterp )
  934. {
  935. floaterp->setCanApplyImmediately(b);
  936. }
  937. }
  939. void LLTextureCtrl::setVisible( BOOL visible ) 
  940. {
  941. if( !visible )
  942. {
  943. closeDependentFloater();
  944. }
  945. LLUICtrl::setVisible( visible );
  946. }
  948. void LLTextureCtrl::setEnabled( BOOL enabled )
  949. {
  950. LLFloaterTexturePicker* floaterp = (LLFloaterTexturePicker*)mFloaterHandle.get();
  951. if( enabled )
  952. {
  953. std::string tooltip;
  954. if (floaterp) tooltip = floaterp->getString("choose_picture");
  955. setToolTip( tooltip );
  956. }
  957. else
  958. {
  959. setToolTip( std::string() );
  960. // *TODO: would be better to keep floater open and show
  961. // disabled state.
  962. closeDependentFloater();
  963. }
  965. if( floaterp )
  966. {
  967. floaterp->setActive(enabled);
  968. }
  970. mCaption->setEnabled( enabled );
  972. LLView::setEnabled( enabled );
  973. }
  975. void LLTextureCtrl::setValid(BOOL valid )
  976. {
  977. mValid = valid;
  978. if (!valid)
  979. {
  980. LLFloaterTexturePicker* pickerp = (LLFloaterTexturePicker*)mFloaterHandle.get();
  981. if (pickerp)
  982. {
  983. pickerp->setActive(FALSE);
  984. }
  985. }
  986. }
  989. // virtual
  990. void LLTextureCtrl::clear()
  991. {
  992. setImageAssetID(LLUUID::null);
  993. }
  995. void LLTextureCtrl::setLabel(const std::string& label)
  996. {
  997. mLabel = label;
  998. mCaption->setText(label);
  999. }
  1001. void LLTextureCtrl::showPicker(BOOL take_focus)
  1002. {
  1003. // show hourglass cursor when loading inventory window
  1004. // because inventory construction is slooow
  1005. getWindow()->setCursor(UI_CURSOR_WAIT);
  1006. LLFloater* floaterp = mFloaterHandle.get();
  1008. // Show the dialog
  1009. if( floaterp )
  1010. {
  1011. floaterp->openFloater();
  1012. }
  1013. else
  1014. {
  1015. floaterp = new LLFloaterTexturePicker(
  1016. this,
  1017. mLabel,
  1018. mImmediateFilterPermMask,
  1019. mNonImmediateFilterPermMask,
  1020. mCanApplyImmediately,
  1021. mFallbackImageName);
  1023. mFloaterHandle = floaterp->getHandle();
  1025. LLFloater* root_floater = gFloaterView->getParentFloater(this);
  1026. if (root_floater)
  1027. root_floater->addDependentFloater(floaterp);
  1028. floaterp->openFloater();
  1029. }
  1031. if (take_focus)
  1032. {
  1033. floaterp->setFocus(TRUE);
  1034. }
  1035. }
  1038. void LLTextureCtrl::closeDependentFloater()
  1039. {
  1040. LLFloaterTexturePicker* floaterp = (LLFloaterTexturePicker*)mFloaterHandle.get();
  1041. if( floaterp )
  1042. {
  1043. floaterp->setOwner(NULL);
  1044. floaterp->closeFloater();
  1045. }
  1046. }
  1048. // Allow us to download textures quickly when floater is shown
  1049. class LLTextureFetchDescendentsObserver : public LLInventoryFetchDescendentsObserver
  1050. {
  1051. public:
  1052. virtual void done()
  1053. {
  1054. // We need to find textures in all folders, so get the main
  1055. // background download going.
  1056. gInventory.startBackgroundFetch();
  1057. gInventory.removeObserver(this);
  1058. delete this;
  1059. }
  1060. };
  1062. BOOL LLTextureCtrl::handleHover(S32 x, S32 y, MASK mask)
  1063. {
  1064. getWindow()->setCursor(UI_CURSOR_HAND);
  1065. return TRUE;
  1066. }
  1069. BOOL LLTextureCtrl::handleMouseDown(S32 x, S32 y, MASK mask)
  1070. {
  1071. BOOL handled = LLUICtrl::handleMouseDown( x, y , mask );
  1073. if( !handled )
  1074. {
  1075. showPicker(FALSE);
  1076. //grab textures first...
  1077. gInventory.startBackgroundFetch(gInventory.findCategoryUUIDForType(LLFolderType::FT_TEXTURE));
  1078. //...then start full inventory fetch.
  1079. gInventory.startBackgroundFetch();
  1080. handled = TRUE;
  1081. }
  1083. return handled;
  1084. }
  1086. void LLTextureCtrl::onFloaterClose()
  1087. {
  1088. LLFloaterTexturePicker* floaterp = (LLFloaterTexturePicker*)mFloaterHandle.get();
  1090. if (floaterp)
  1091. {
  1092. floaterp->setOwner(NULL);
  1093. }
  1095. mFloaterHandle.markDead();
  1096. }
  1098. void LLTextureCtrl::onFloaterCommit(ETexturePickOp op)
  1099. {
  1100. LLFloaterTexturePicker* floaterp = (LLFloaterTexturePicker*)mFloaterHandle.get();
  1102. if( floaterp && getEnabled())
  1103. {
  1104. if (op == TEXTURE_CANCEL)
  1105. mViewModel->resetDirty();
  1106. // If the "no_commit_on_selection" parameter is set
  1107. // we get dirty only when user presses OK in the picker
  1108. // (i.e. op == TEXTURE_SELECT) or texture changes via DnD.
  1109. else if (mCommitOnSelection || op == TEXTURE_SELECT)
  1110. mViewModel->setDirty(); // *TODO: shouldn't we be using setValue() here?
  1112. if( floaterp->isDirty() )
  1113. {
  1114. setTentative( FALSE );
  1115. mImageItemID = floaterp->findItemID(floaterp->getAssetID(), FALSE);
  1116. lldebugs << "mImageItemID: " << mImageItemID << llendl;
  1117. mImageAssetID = floaterp->getAssetID();
  1118. lldebugs << "mImageAssetID: " << mImageAssetID << llendl;
  1119. if (op == TEXTURE_SELECT && mOnSelectCallback)
  1120. {
  1121. mOnSelectCallback( this, LLSD() );
  1122. }
  1123. else if (op == TEXTURE_CANCEL && mOnCancelCallback)
  1124. {
  1125. mOnCancelCallback( this, LLSD() );
  1126. }
  1127. else
  1128. {
  1129. // If the "no_commit_on_selection" parameter is set
  1130. // we commit only when user presses OK in the picker
  1131. // (i.e. op == TEXTURE_SELECT) or texture changes via DnD.
  1132. if (mCommitOnSelection || op == TEXTURE_SELECT)
  1133. onCommit();
  1134. }
  1135. }
  1136. }
  1137. }
  1139. void LLTextureCtrl::setImageAssetID( const LLUUID& asset_id )
  1140. {
  1141. if( mImageAssetID != asset_id )
  1142. {
  1143. mImageItemID.setNull();
  1144. mImageAssetID = asset_id;
  1145. LLFloaterTexturePicker* floaterp = (LLFloaterTexturePicker*)mFloaterHandle.get();
  1146. if( floaterp && getEnabled() )
  1147. {
  1148. floaterp->setImageID( asset_id );
  1149. floaterp->resetDirty();
  1150. }
  1151. }
  1152. }
  1154. BOOL LLTextureCtrl::handleDragAndDrop(S32 x, S32 y, MASK mask,
  1155.   BOOL drop, EDragAndDropType cargo_type, void *cargo_data,
  1156.   EAcceptance *accept,
  1157.   std::string& tooltip_msg)
  1158. {
  1159. BOOL handled = FALSE;
  1161. // this downcast may be invalid - but if the second test below
  1162. // returns true, then the cast was valid, and we can perform
  1163. // the third test without problems.
  1164. LLInventoryItem* item = (LLInventoryItem*)cargo_data; 
  1165. if (getEnabled() && (cargo_type == DAD_TEXTURE) && allowDrop(item))
  1166. {
  1167. if (drop)
  1168. {
  1169. if(doDrop(item))
  1170. {
  1171. if (!mCommitOnSelection)
  1172. mViewModel->setDirty();
  1174. // This removes the 'Multiple' overlay, since
  1175. // there is now only one texture selected.
  1176. setTentative( FALSE ); 
  1177. onCommit();
  1178. }
  1179. }
  1181. *accept = ACCEPT_YES_SINGLE;
  1182. }
  1183. else
  1184. {
  1185. *accept = ACCEPT_NO;
  1186. }
  1188. handled = TRUE;
  1189. lldebugst(LLERR_USER_INPUT) << "dragAndDrop handled by LLTextureCtrl " << getName() << llendl;
  1191. return handled;
  1192. }
  1194. void LLTextureCtrl::draw()
  1195. {
  1196. mBorder->setKeyboardFocusHighlight(hasFocus());
  1198. if (!mValid)
  1199. {
  1200. mTexturep = NULL;
  1201. }
  1202. else if (!mImageAssetID.isNull())
  1203. {
  1204. LLPointer<LLViewerFetchedTexture> texture = LLViewerTextureManager::getFetchedTexture(mImageAssetID, MIPMAP_YES,LLViewerTexture::BOOST_NONE, LLViewerTexture::LOD_TEXTURE);
  1206. texture->setBoostLevel(LLViewerTexture::BOOST_PREVIEW);
  1207. texture->forceToSaveRawImage(0) ;
  1209. mTexturep = texture;
  1210. }
  1211. else if (!mFallbackImageName.empty())
  1212. {
  1213. // Show fallback image.
  1214. mTexturep = LLViewerTextureManager::getFetchedTextureFromFile(mFallbackImageName);
  1215. mTexturep->setBoostLevel(LLViewerTexture::BOOST_PREVIEW);
  1216. }
  1217. else//mImageAssetID == LLUUID::null
  1218. {
  1219. mTexturep = NULL;
  1220. }
  1222. // Border
  1223. LLRect border( 0, getRect().getHeight(), getRect().getWidth(), BTN_HEIGHT_SMALL );
  1224. gl_rect_2d( border, mBorderColor.get(), FALSE );
  1226. // Interior
  1227. LLRect interior = border;
  1228. interior.stretch( -1 ); 
  1230. if( mTexturep )
  1231. {
  1232. if( mTexturep->getComponents() == 4 )
  1233. {
  1234. gl_rect_2d_checkerboard( interior );
  1235. }
  1237. gl_draw_scaled_image( interior.mLeft, interior.mBottom, interior.getWidth(), interior.getHeight(), mTexturep);
  1238. mTexturep->addTextureStats( (F32)(interior.getWidth() * interior.getHeight()) );
  1239. }
  1240. else
  1241. {
  1242. gl_rect_2d( interior, LLColor4::grey, TRUE );
  1244. // Draw X
  1245. gl_draw_x( interior, LLColor4::black );
  1246. }
  1248. mTentativeLabel->setVisible( !mTexturep.isNull() && getTentative() );
  1251. // Show "Loading..." string on the top left corner while this texture is loading.
  1252. // Using the discard level, do not show the string if the texture is almost but not 
  1253. // fully loaded.
  1254. if ( mTexturep.notNull() &&
  1255.  (!mTexturep->isFullyLoaded()) &&
  1256.  (mShowLoadingPlaceholder == TRUE) && 
  1257.  (mTexturep->getDiscardLevel() != 1) &&
  1258.  (mTexturep->getDiscardLevel() != 0))
  1259. {
  1260. LLFontGL* font = LLFontGL::getFontSansSerif();
  1261. font->renderUTF8(
  1262. mLoadingPlaceholderString, 0,
  1263. llfloor(interior.mLeft+3), 
  1264. llfloor(interior.mTop-25),
  1265. LLColor4::white,
  1266. LLFontGL::LEFT,
  1267. LLFontGL::BASELINE,
  1268. LLFontGL::DROP_SHADOW);
  1269. }
  1271. LLUICtrl::draw();
  1272. }
  1274. BOOL LLTextureCtrl::allowDrop(LLInventoryItem* item)
  1275. {
  1276. BOOL copy = item->getPermissions().allowCopyBy(gAgent.getID());
  1277. BOOL mod = item->getPermissions().allowModifyBy(gAgent.getID());
  1278. BOOL xfer = item->getPermissions().allowOperationBy(PERM_TRANSFER,
  1279. gAgent.getID());
  1281. PermissionMask item_perm_mask = 0;
  1282. if (copy) item_perm_mask |= PERM_COPY;
  1283. if (mod)  item_perm_mask |= PERM_MODIFY;
  1284. if (xfer) item_perm_mask |= PERM_TRANSFER;
  1286. // PermissionMask filter_perm_mask = mCanApplyImmediately ? commented out due to no-copy texture loss.
  1287. // mImmediateFilterPermMask : mNonImmediateFilterPermMask;
  1288. PermissionMask filter_perm_mask = mImmediateFilterPermMask;
  1289. if ( (item_perm_mask & filter_perm_mask) == filter_perm_mask )
  1290. {
  1291. if(mDragCallback)
  1292. {
  1293. return mDragCallback(this, item);
  1294. }
  1295. else
  1296. {
  1297. return TRUE;
  1298. }
  1299. }
  1300. else
  1301. {
  1302. return FALSE;
  1303. }
  1304. }
  1306. BOOL LLTextureCtrl::doDrop(LLInventoryItem* item)
  1307. {
  1308. // call the callback if it exists.
  1309. if(mDropCallback)
  1310. {
  1311. // if it returns TRUE, we return TRUE, and therefore the
  1312. // commit is called above.
  1313. return mDropCallback(this, item);
  1314. }
  1316. // no callback installed, so just set the image ids and carry on.
  1317. setImageAssetID( item->getAssetUUID() );
  1318. mImageItemID = item->getUUID();
  1319. return TRUE;
  1320. }
  1322. BOOL LLTextureCtrl::handleUnicodeCharHere(llwchar uni_char)
  1323. {
  1324. if( ' ' == uni_char )
  1325. {
  1326. showPicker(TRUE);
  1327. return TRUE;
  1328. }
  1329. return LLUICtrl::handleUnicodeCharHere(uni_char);
  1330. }
  1332. void LLTextureCtrl::setValue( const LLSD& value )
  1333. {
  1334. setImageAssetID(value.asUUID());
  1335. }
  1337. LLSD LLTextureCtrl::getValue() const
  1338. {
  1339. return LLSD(getImageAssetID());
  1340. }