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

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

游戏引擎

开发平台：

C++ Builder

llfloatersnapshot.cpp：源码内容
  1. /** 
  2.  * @file llfloatersnapshot.cpp
  3.  * @brief Snapshot preview window, allowing saving, e-mailing, etc.
  4.  *
  5.  * $LicenseInfo:firstyear=2004&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2004-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"
  35. #include "llfloatersnapshot.h"
  37. #include "llfloaterreg.h"
  39. // Viewer includes
  40. #include "llagent.h"
  41. #include "llcallbacklist.h"
  42. #include "llcriticaldamp.h"
  43. #include "llui.h"
  44. #include "llfocusmgr.h"
  45. #include "llbutton.h"
  46. #include "llcombobox.h"
  47. #include "lleconomy.h"
  48. #include "llsliderctrl.h"
  49. #include "llspinctrl.h"
  50. #include "llviewercontrol.h"
  51. #include "lluictrlfactory.h"
  52. #include "llviewerstats.h"
  53. #include "llviewercamera.h"
  54. #include "llviewerwindow.h"
  55. #include "llviewermenufile.h" // upload_new_resource()
  56. #include "llfloaterpostcard.h"
  57. #include "llcheckboxctrl.h"
  58. #include "llradiogroup.h"
  59. #include "lltoolfocus.h"
  60. #include "lltoolmgr.h"
  61. #include "llworld.h"
  62. #include "llagentui.h"
  64. // Linden library includes
  65. #include "llfontgl.h"
  66. #include "llsys.h"
  67. #include "llrender.h"
  68. #include "v3dmath.h"
  69. #include "llmath.h"
  70. #include "lldir.h"
  71. #include "llsdserialize.h"
  72. #include "llgl.h"
  73. #include "llglheaders.h"
  74. #include "llimagejpeg.h"
  75. #include "llimagepng.h"
  76. #include "llimagebmp.h"
  77. #include "llimagej2c.h"
  78. #include "lllocalcliprect.h"
  79. #include "llnotificationsutil.h"
  80. #include "llresmgr.h" // LLLocale
  81. #include "llvfile.h"
  82. #include "llvfs.h"
  83. #include "llwindow.h"
  85. ///----------------------------------------------------------------------------
  86. /// Local function declarations, constants, enums, and typedefs
  87. ///----------------------------------------------------------------------------
  88. S32 LLFloaterSnapshot::sUIWinHeightLong = 526 ;
  89. S32 LLFloaterSnapshot::sUIWinHeightShort = LLFloaterSnapshot::sUIWinHeightLong - 230 ;
  90. S32 LLFloaterSnapshot::sUIWinWidth = 215 ;
  92. LLSnapshotFloaterView* gSnapshotFloaterView = NULL;
  94. const F32 AUTO_SNAPSHOT_TIME_DELAY = 1.f;
  96. F32 SHINE_TIME = 0.5f;
  97. F32 SHINE_WIDTH = 0.6f;
  98. F32 SHINE_OPACITY = 0.3f;
  99. F32 FALL_TIME = 0.6f;
  100. S32 BORDER_WIDTH = 6;
  102. const S32 MAX_POSTCARD_DATASIZE = 1024 * 1024; // one megabyte
  103. const S32 MAX_TEXTURE_SIZE = 512 ; //max upload texture size 512 * 512
  105. static LLDefaultChildRegistry::Register<LLSnapshotFloaterView> r("snapshot_floater_view");
  107. ///----------------------------------------------------------------------------
  108. /// Class LLSnapshotLivePreview 
  109. ///----------------------------------------------------------------------------
  110. class LLSnapshotLivePreview : public LLView
  111. {
  112. public:
  113. enum ESnapshotType
  114. {
  115. SNAPSHOT_POSTCARD,
  116. SNAPSHOT_TEXTURE,
  117. SNAPSHOT_LOCAL
  118. };
  121. struct Params : public LLInitParam::Block<Params, LLView::Params>
  122. {
  123. Params()
  124. {
  125. name = "snapshot_live_preview";
  126. mouse_opaque = false;
  127. }
  128. };
  131. LLSnapshotLivePreview(const LLSnapshotLivePreview::Params& p);
  132. ~LLSnapshotLivePreview();
  134. /*virtual*/ void draw();
  135. /*virtual*/ void reshape(S32 width, S32 height, BOOL called_from_parent);
  137. void setSize(S32 w, S32 h);
  138. void getSize(S32& w, S32& h) const;
  139. S32 getDataSize() const { return mDataSize; }
  140. void setMaxImageSize(S32 size) ;
  141. S32  getMaxImageSize() {return mMaxImageSize ;}
  143. ESnapshotType getSnapshotType() const { return mSnapshotType; }
  144. LLFloaterSnapshot::ESnapshotFormat getSnapshotFormat() const { return mSnapshotFormat; }
  145. BOOL getSnapshotUpToDate() const { return mSnapshotUpToDate; }
  146. BOOL isSnapshotActive() { return mSnapshotActive; }
  147. LLViewerTexture* getThumbnailImage() const { return mThumbnailImage ; }
  148. S32  getThumbnailWidth() const { return mThumbnailWidth ; }
  149. S32  getThumbnailHeight() const { return mThumbnailHeight ; }
  150. BOOL getThumbnailLock() const { return mThumbnailUpdateLock ; }
  151. BOOL getThumbnailUpToDate() const { return mThumbnailUpToDate ;}
  152. LLViewerTexture* getCurrentImage();
  153. F32 getImageAspect();
  154. F32 getAspect() ;
  155. LLRect getImageRect();
  156. BOOL isImageScaled();
  158. void setSnapshotType(ESnapshotType type) { mSnapshotType = type; }
  159. void setSnapshotFormat(LLFloaterSnapshot::ESnapshotFormat type) { mSnapshotFormat = type; }
  160. void setSnapshotQuality(S32 quality);
  161. void setSnapshotBufferType(LLViewerWindow::ESnapshotType type) { mSnapshotBufferType = type; }
  162. void updateSnapshot(BOOL new_snapshot, BOOL new_thumbnail = FALSE, F32 delay = 0.f);
  163. LLFloaterPostcard* savePostcard();
  164. void saveTexture();
  165. BOOL saveLocal();
  167. BOOL setThumbnailImageSize() ;
  168. void generateThumbnailImage(BOOL force_update = FALSE) ;
  169. void resetThumbnailImage() { mThumbnailImage = NULL ; }
  170. void drawPreviewRect(S32 offset_x, S32 offset_y) ;
  172. // Returns TRUE when snapshot generated, FALSE otherwise.
  173. static BOOL onIdle( void* snapshot_preview );
  175. private:
  176. LLColor4 mColor;
  177. LLPointer<LLViewerTexture> mViewerImage[2]; //used to represent the scene when the frame is frozen.
  178. LLRect mImageRect[2];
  179. S32 mWidth[2];
  180. S32 mHeight[2];
  181. BOOL mImageScaled[2];
  182. S32                         mMaxImageSize ;
  184. //thumbnail image
  185. LLPointer<LLViewerTexture> mThumbnailImage ;
  186. S32                         mThumbnailWidth ;
  187. S32                         mThumbnailHeight ;
  188. LLRect                      mPreviewRect ;
  189. BOOL                        mThumbnailUpdateLock ;
  190. BOOL                        mThumbnailUpToDate ;
  192. S32 mCurImageIndex;
  193. LLPointer<LLImageRaw> mPreviewImage;
  194. LLPointer<LLImageRaw> mPreviewImageEncoded;
  195. LLPointer<LLImageFormatted> mFormattedImage;
  196. LLFrameTimer mSnapshotDelayTimer;
  197. S32 mShineCountdown;
  198. LLFrameTimer mShineAnimTimer;
  199. F32 mFlashAlpha;
  200. BOOL mNeedsFlash;
  201. LLVector3d mPosTakenGlobal;
  202. S32 mSnapshotQuality;
  203. S32 mDataSize;
  204. ESnapshotType mSnapshotType;
  205. LLFloaterSnapshot::ESnapshotFormat mSnapshotFormat;
  206. BOOL mSnapshotUpToDate;
  207. LLFrameTimer mFallAnimTimer;
  208. LLVector3 mCameraPos;
  209. LLQuaternion mCameraRot;
  210. BOOL mSnapshotActive;
  211. LLViewerWindow::ESnapshotType mSnapshotBufferType;
  213. public:
  214. static std::set<LLSnapshotLivePreview*> sList;
  215. BOOL                        mKeepAspectRatio ;
  216. };
  218. std::set<LLSnapshotLivePreview*> LLSnapshotLivePreview::sList;
  220. LLSnapshotLivePreview::LLSnapshotLivePreview (const LLSnapshotLivePreview::Params& p) 
  221. : LLView(p),
  222. mColor(1.f, 0.f, 0.f, 0.5f), 
  223. mCurImageIndex(0),
  224. mPreviewImage(NULL),
  225. mThumbnailImage(NULL) ,
  226. mThumbnailWidth(0),
  227. mThumbnailHeight(0),
  228. mPreviewImageEncoded(NULL),
  229. mFormattedImage(NULL),
  230. mShineCountdown(0),
  231. mFlashAlpha(0.f),
  232. mNeedsFlash(TRUE),
  233. mSnapshotQuality(gSavedSettings.getS32("SnapshotQuality")),
  234. mDataSize(0),
  235. mSnapshotType(SNAPSHOT_POSTCARD),
  236. mSnapshotFormat(LLFloaterSnapshot::ESnapshotFormat(gSavedSettings.getS32("SnapshotFormat"))),
  237. mSnapshotUpToDate(FALSE),
  238. mCameraPos(LLViewerCamera::getInstance()->getOrigin()),
  239. mCameraRot(LLViewerCamera::getInstance()->getQuaternion()),
  240. mSnapshotActive(FALSE),
  241. mSnapshotBufferType(LLViewerWindow::SNAPSHOT_TYPE_COLOR)
  242. {
  243. setSnapshotQuality(gSavedSettings.getS32("SnapshotQuality"));
  244. mSnapshotDelayTimer.setTimerExpirySec(0.0f);
  245. mSnapshotDelayTimer.start();
  246. //  gIdleCallbacks.addFunction( &LLSnapshotLivePreview::onIdle, (void*)this );
  247. sList.insert(this);
  248. setFollowsAll();
  249. mWidth[0] = gViewerWindow->getWindowWidthRaw();
  250. mWidth[1] = gViewerWindow->getWindowWidthRaw();
  251. mHeight[0] = gViewerWindow->getWindowHeightRaw();
  252. mHeight[1] = gViewerWindow->getWindowHeightRaw();
  253. mImageScaled[0] = FALSE;
  254. mImageScaled[1] = FALSE;
  256. mMaxImageSize = MAX_SNAPSHOT_IMAGE_SIZE ;
  257. mKeepAspectRatio = gSavedSettings.getBOOL("KeepAspectForSnapshot") ;
  258. mThumbnailUpdateLock = FALSE ;
  259. mThumbnailUpToDate   = FALSE ;
  260. }
  262. LLSnapshotLivePreview::~LLSnapshotLivePreview()
  263. {
  264. // delete images
  265. mPreviewImage = NULL;
  266. mPreviewImageEncoded = NULL;
  267. mFormattedImage = NULL;
  269. //  gIdleCallbacks.deleteFunction( &LLSnapshotLivePreview::onIdle, (void*)this );
  270. sList.erase(this);
  271. }
  273. void LLSnapshotLivePreview::setMaxImageSize(S32 size) 
  274. {
  275. if(size < MAX_SNAPSHOT_IMAGE_SIZE)
  276. {
  277. mMaxImageSize = size;
  278. }
  279. else
  280. {
  281. mMaxImageSize = MAX_SNAPSHOT_IMAGE_SIZE ;
  282. }
  283. }
  285. LLViewerTexture* LLSnapshotLivePreview::getCurrentImage()
  286. {
  287. return mViewerImage[mCurImageIndex];
  288. }
  290. F32 LLSnapshotLivePreview::getAspect()
  291. {
  292. F32 image_aspect_ratio = ((F32)mWidth[mCurImageIndex]) / ((F32)mHeight[mCurImageIndex]);
  293. F32 window_aspect_ratio = ((F32)getRect().getWidth()) / ((F32)getRect().getHeight());
  295. if (!mKeepAspectRatio)//gSavedSettings.getBOOL("KeepAspectForSnapshot"))
  296. {
  297. return image_aspect_ratio;
  298. }
  299. else
  300. {
  301. return window_aspect_ratio;
  302. }
  303. }
  305. F32 LLSnapshotLivePreview::getImageAspect()
  306. {
  307. if (!mViewerImage[mCurImageIndex])
  308. {
  309. return 0.f;
  310. }
  312. return getAspect() ;
  313. }
  315. LLRect LLSnapshotLivePreview::getImageRect()
  316. {
  317. return mImageRect[mCurImageIndex];
  318. }
  320. BOOL LLSnapshotLivePreview::isImageScaled()
  321. {
  322. return mImageScaled[mCurImageIndex];
  323. }
  325. void LLSnapshotLivePreview::updateSnapshot(BOOL new_snapshot, BOOL new_thumbnail, F32 delay) 
  326. { 
  327. if (mSnapshotUpToDate)
  328. {
  329. S32 old_image_index = mCurImageIndex;
  330. mCurImageIndex = (mCurImageIndex + 1) % 2; 
  331. mWidth[mCurImageIndex] = mWidth[old_image_index];
  332. mHeight[mCurImageIndex] = mHeight[old_image_index];
  333. mFallAnimTimer.start();
  334. }
  335. mSnapshotUpToDate = FALSE; 
  337. LLRect& rect = mImageRect[mCurImageIndex];
  338. rect.set(0, getRect().getHeight(), getRect().getWidth(), 0);
  340. F32 image_aspect_ratio = ((F32)mWidth[mCurImageIndex]) / ((F32)mHeight[mCurImageIndex]);
  341. F32 window_aspect_ratio = ((F32)getRect().getWidth()) / ((F32)getRect().getHeight());
  343. if (mKeepAspectRatio)//gSavedSettings.getBOOL("KeepAspectForSnapshot"))
  344. {
  345. if (image_aspect_ratio > window_aspect_ratio)
  346. {
  347. // trim off top and bottom
  348. S32 new_height = llround((F32)getRect().getWidth() / image_aspect_ratio); 
  349. rect.mBottom += (getRect().getHeight() - new_height) / 2;
  350. rect.mTop -= (getRect().getHeight() - new_height) / 2;
  351. }
  352. else if (image_aspect_ratio < window_aspect_ratio)
  353. {
  354. // trim off left and right
  355. S32 new_width = llround((F32)getRect().getHeight() * image_aspect_ratio); 
  356. rect.mLeft += (getRect().getWidth() - new_width) / 2;
  357. rect.mRight -= (getRect().getWidth() - new_width) / 2;
  358. }
  359. }
  361. mShineAnimTimer.stop();
  362. if (new_snapshot)
  363. {
  364. mSnapshotDelayTimer.start();
  365. mSnapshotDelayTimer.setTimerExpirySec(delay);
  366. }
  367. if(new_thumbnail)
  368. {
  369. mThumbnailUpToDate = FALSE ;
  370. }
  371. setThumbnailImageSize();
  372. }
  374. void LLSnapshotLivePreview::setSnapshotQuality(S32 quality)
  375. {
  376. llclamp(quality, 0, 100);
  377. if (quality != mSnapshotQuality)
  378. {
  379. mSnapshotQuality = quality;
  380. gSavedSettings.setS32("SnapshotQuality", quality);
  381. mSnapshotUpToDate = FALSE;
  382. }
  383. }
  385. void LLSnapshotLivePreview::drawPreviewRect(S32 offset_x, S32 offset_y)
  386. {
  387. F32 line_width ; 
  388. glGetFloatv(GL_LINE_WIDTH, &line_width) ;
  389. glLineWidth(2.0f * line_width) ;
  390. LLColor4 color(0.0f, 0.0f, 0.0f, 1.0f) ;
  391. gl_rect_2d( mPreviewRect.mLeft + offset_x, mPreviewRect.mTop + offset_y,
  392. mPreviewRect.mRight + offset_x, mPreviewRect.mBottom + offset_y, color, FALSE ) ;
  393. glLineWidth(line_width) ;
  395. //draw four alpha rectangles to cover areas outside of the snapshot image
  396. if(!mKeepAspectRatio)
  397. {
  398. LLColor4 alpha_color(0.5f, 0.5f, 0.5f, 0.8f) ;
  399. S32 dwl = 0, dwr = 0 ;
  400. if(mThumbnailWidth > mPreviewRect.getWidth())
  401. {
  402. dwl = (mThumbnailWidth - mPreviewRect.getWidth()) >> 1 ;
  403. dwr = mThumbnailWidth - mPreviewRect.getWidth() - dwl ;
  405. gl_rect_2d(mPreviewRect.mLeft + offset_x - dwl, mPreviewRect.mTop + offset_y,
  406. mPreviewRect.mLeft + offset_x, mPreviewRect.mBottom + offset_y, alpha_color, TRUE ) ;
  407. gl_rect_2d( mPreviewRect.mRight + offset_x, mPreviewRect.mTop + offset_y,
  408. mPreviewRect.mRight + offset_x + dwr, mPreviewRect.mBottom + offset_y, alpha_color, TRUE ) ;
  409. }
  411. if(mThumbnailHeight > mPreviewRect.getHeight())
  412. {
  413. S32 dh = (mThumbnailHeight - mPreviewRect.getHeight()) >> 1 ;
  414. gl_rect_2d(mPreviewRect.mLeft + offset_x - dwl, mPreviewRect.mBottom + offset_y ,
  415. mPreviewRect.mRight + offset_x + dwr, mPreviewRect.mBottom + offset_y - dh, alpha_color, TRUE ) ;
  417. dh = mThumbnailHeight - mPreviewRect.getHeight() - dh ;
  418. gl_rect_2d( mPreviewRect.mLeft + offset_x - dwl, mPreviewRect.mTop + offset_y + dh,
  419. mPreviewRect.mRight + offset_x + dwr, mPreviewRect.mTop + offset_y, alpha_color, TRUE ) ;
  420. }
  421. }
  422. }
  424. //called when the frame is frozen.
  425. void LLSnapshotLivePreview::draw()
  426. {
  427. if (mViewerImage[mCurImageIndex].notNull() &&
  428.     mPreviewImageEncoded.notNull() &&
  429.     mSnapshotUpToDate)
  430. {
  431. LLColor4 bg_color(0.f, 0.f, 0.3f, 0.4f);
  432. gl_rect_2d(getRect(), bg_color);
  433. LLRect &rect = mImageRect[mCurImageIndex];
  434. LLRect shadow_rect = mImageRect[mCurImageIndex];
  435. shadow_rect.stretch(BORDER_WIDTH);
  436. gl_drop_shadow(shadow_rect.mLeft, shadow_rect.mTop, shadow_rect.mRight, shadow_rect.mBottom, LLColor4(0.f, 0.f, 0.f, mNeedsFlash ? 0.f :0.5f), 10);
  438. LLColor4 image_color(1.f, 1.f, 1.f, 1.f);
  439. gGL.color4fv(image_color.mV);
  440. gGL.getTexUnit(0)->bind(mViewerImage[mCurImageIndex]);
  441. // calculate UV scale
  442. F32 uv_width = mImageScaled[mCurImageIndex] ? 1.f : llmin((F32)mWidth[mCurImageIndex] / (F32)mViewerImage[mCurImageIndex]->getWidth(), 1.f);
  443. F32 uv_height = mImageScaled[mCurImageIndex] ? 1.f : llmin((F32)mHeight[mCurImageIndex] / (F32)mViewerImage[mCurImageIndex]->getHeight(), 1.f);
  444. glPushMatrix();
  445. {
  446. glTranslatef((F32)rect.mLeft, (F32)rect.mBottom, 0.f);
  447. gGL.begin(LLRender::QUADS);
  448. {
  449. gGL.texCoord2f(uv_width, uv_height);
  450. gGL.vertex2i(rect.getWidth(), rect.getHeight() );
  452. gGL.texCoord2f(0.f, uv_height);
  453. gGL.vertex2i(0, rect.getHeight() );
  455. gGL.texCoord2f(0.f, 0.f);
  456. gGL.vertex2i(0, 0);
  458. gGL.texCoord2f(uv_width, 0.f);
  459. gGL.vertex2i(rect.getWidth(), 0);
  460. }
  461. gGL.end();
  462. }
  463. glPopMatrix();
  465. gGL.color4f(1.f, 1.f, 1.f, mFlashAlpha);
  466. gl_rect_2d(getRect());
  467. if (mNeedsFlash)
  468. {
  469. if (mFlashAlpha < 1.f)
  470. {
  471. mFlashAlpha = lerp(mFlashAlpha, 1.f, LLCriticalDamp::getInterpolant(0.02f));
  472. }
  473. else
  474. {
  475. mNeedsFlash = FALSE;
  476. }
  477. }
  478. else
  479. {
  480. mFlashAlpha = lerp(mFlashAlpha, 0.f, LLCriticalDamp::getInterpolant(0.15f));
  481. }
  483. if (mShineCountdown > 0)
  484. {
  485. mShineCountdown--;
  486. if (mShineCountdown == 0)
  487. {
  488. mShineAnimTimer.start();
  489. }
  490. }
  491. else if (mShineAnimTimer.getStarted())
  492. {
  493. F32 shine_interp = llmin(1.f, mShineAnimTimer.getElapsedTimeF32() / SHINE_TIME);
  495. // draw "shine" effect
  496. LLLocalClipRect clip(getLocalRect());
  497. {
  498. // draw diagonal stripe with gradient that passes over screen
  499. S32 x1 = gViewerWindow->getWindowWidthScaled() * llround((clamp_rescale(shine_interp, 0.f, 1.f, -1.f - SHINE_WIDTH, 1.f)));
  500. S32 x2 = x1 + llround(gViewerWindow->getWindowWidthScaled() * SHINE_WIDTH);
  501. S32 x3 = x2 + llround(gViewerWindow->getWindowWidthScaled() * SHINE_WIDTH);
  502. S32 y1 = 0;
  503. S32 y2 = gViewerWindow->getWindowHeightScaled();
  505. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  506. gGL.begin(LLRender::QUADS);
  507. {
  508. gGL.color4f(1.f, 1.f, 1.f, 0.f);
  509. gGL.vertex2i(x1, y1);
  510. gGL.vertex2i(x1 + gViewerWindow->getWindowWidthScaled(), y2);
  511. gGL.color4f(1.f, 1.f, 1.f, SHINE_OPACITY);
  512. gGL.vertex2i(x2 + gViewerWindow->getWindowWidthScaled(), y2);
  513. gGL.vertex2i(x2, y1);
  515. gGL.color4f(1.f, 1.f, 1.f, SHINE_OPACITY);
  516. gGL.vertex2i(x2, y1);
  517. gGL.vertex2i(x2 + gViewerWindow->getWindowWidthScaled(), y2);
  518. gGL.color4f(1.f, 1.f, 1.f, 0.f);
  519. gGL.vertex2i(x3 + gViewerWindow->getWindowWidthScaled(), y2);
  520. gGL.vertex2i(x3, y1);
  521. }
  522. gGL.end();
  523. }
  525. // if we're at the end of the animation, stop
  526. if (shine_interp >= 1.f)
  527. {
  528. mShineAnimTimer.stop();
  529. }
  530. }
  531. }
  533. // draw framing rectangle
  534. {
  535. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  536. gGL.color4f(1.f, 1.f, 1.f, 1.f);
  537. LLRect outline_rect = mImageRect[mCurImageIndex];
  538. gGL.begin(LLRender::QUADS);
  539. {
  540. gGL.vertex2i(outline_rect.mLeft - BORDER_WIDTH, outline_rect.mTop + BORDER_WIDTH);
  541. gGL.vertex2i(outline_rect.mRight + BORDER_WIDTH, outline_rect.mTop + BORDER_WIDTH);
  542. gGL.vertex2i(outline_rect.mRight, outline_rect.mTop);
  543. gGL.vertex2i(outline_rect.mLeft, outline_rect.mTop);
  545. gGL.vertex2i(outline_rect.mLeft, outline_rect.mBottom);
  546. gGL.vertex2i(outline_rect.mRight, outline_rect.mBottom);
  547. gGL.vertex2i(outline_rect.mRight + BORDER_WIDTH, outline_rect.mBottom - BORDER_WIDTH);
  548. gGL.vertex2i(outline_rect.mLeft - BORDER_WIDTH, outline_rect.mBottom - BORDER_WIDTH);
  550. gGL.vertex2i(outline_rect.mLeft, outline_rect.mTop);
  551. gGL.vertex2i(outline_rect.mLeft, outline_rect.mBottom);
  552. gGL.vertex2i(outline_rect.mLeft - BORDER_WIDTH, outline_rect.mBottom - BORDER_WIDTH);
  553. gGL.vertex2i(outline_rect.mLeft - BORDER_WIDTH, outline_rect.mTop + BORDER_WIDTH);
  555. gGL.vertex2i(outline_rect.mRight, outline_rect.mBottom);
  556. gGL.vertex2i(outline_rect.mRight, outline_rect.mTop);
  557. gGL.vertex2i(outline_rect.mRight + BORDER_WIDTH, outline_rect.mTop + BORDER_WIDTH);
  558. gGL.vertex2i(outline_rect.mRight + BORDER_WIDTH, outline_rect.mBottom - BORDER_WIDTH);
  559. }
  560. gGL.end();
  561. }
  563. // draw old image dropping away
  564. if (mFallAnimTimer.getStarted())
  565. {
  566. S32 old_image_index = (mCurImageIndex + 1) % 2;
  567. if (mViewerImage[old_image_index].notNull() && mFallAnimTimer.getElapsedTimeF32() < FALL_TIME)
  568. {
  569. F32 fall_interp = mFallAnimTimer.getElapsedTimeF32() / FALL_TIME;
  570. F32 alpha = clamp_rescale(fall_interp, 0.f, 1.f, 0.8f, 0.4f);
  571. LLColor4 image_color(1.f, 1.f, 1.f, alpha);
  572. gGL.color4fv(image_color.mV);
  573. gGL.getTexUnit(0)->bind(mViewerImage[old_image_index]);
  574. // calculate UV scale
  575. // *FIX get this to work with old image
  576. BOOL rescale = !mImageScaled[old_image_index] && mViewerImage[mCurImageIndex].notNull();
  577. F32 uv_width = rescale ? llmin((F32)mWidth[old_image_index] / (F32)mViewerImage[mCurImageIndex]->getWidth(), 1.f) : 1.f;
  578. F32 uv_height = rescale ? llmin((F32)mHeight[old_image_index] / (F32)mViewerImage[mCurImageIndex]->getHeight(), 1.f) : 1.f;
  579. glPushMatrix();
  580. {
  581. LLRect& rect = mImageRect[old_image_index];
  582. glTranslatef((F32)rect.mLeft, (F32)rect.mBottom - llround(getRect().getHeight() * 2.f * (fall_interp * fall_interp)), 0.f);
  583. glRotatef(-45.f * fall_interp, 0.f, 0.f, 1.f);
  584. gGL.begin(LLRender::QUADS);
  585. {
  586. gGL.texCoord2f(uv_width, uv_height);
  587. gGL.vertex2i(rect.getWidth(), rect.getHeight() );
  589. gGL.texCoord2f(0.f, uv_height);
  590. gGL.vertex2i(0, rect.getHeight() );
  592. gGL.texCoord2f(0.f, 0.f);
  593. gGL.vertex2i(0, 0);
  595. gGL.texCoord2f(uv_width, 0.f);
  596. gGL.vertex2i(rect.getWidth(), 0);
  597. }
  598. gGL.end();
  599. }
  600. glPopMatrix();
  601. }
  602. }
  603. }
  605. /*virtual*/ 
  606. void LLSnapshotLivePreview::reshape(S32 width, S32 height, BOOL called_from_parent)
  607. {
  608. LLRect old_rect = getRect();
  609. LLView::reshape(width, height, called_from_parent);
  610. if (old_rect.getWidth() != width || old_rect.getHeight() != height)
  611. {
  612. updateSnapshot(FALSE, TRUE);
  613. }
  614. }
  616. BOOL LLSnapshotLivePreview::setThumbnailImageSize()
  617. {
  618. if(mWidth[mCurImageIndex] < 10 || mHeight[mCurImageIndex] < 10)
  619. {
  620. return FALSE ;
  621. }
  622. S32 window_width = gViewerWindow->getWindowWidthRaw() ;
  623. S32 window_height = gViewerWindow->getWindowHeightRaw() ;
  625. F32 window_aspect_ratio = ((F32)window_width) / ((F32)window_height);
  627. // UI size for thumbnail
  628. S32 max_width = LLFloaterSnapshot::getUIWinWidth() - 20;
  629. S32 max_height = 90;
  631. if (window_aspect_ratio > (F32)max_width / max_height)
  632. {
  633. // image too wide, shrink to width
  634. mThumbnailWidth = max_width;
  635. mThumbnailHeight = llround((F32)max_width / window_aspect_ratio);
  636. }
  637. else
  638. {
  639. // image too tall, shrink to height
  640. mThumbnailHeight = max_height;
  641. mThumbnailWidth = llround((F32)max_height * window_aspect_ratio);
  642. }
  644. if(mThumbnailWidth > window_width || mThumbnailHeight > window_height)
  645. {
  646. return FALSE ;//if the window is too small, ignore thumbnail updating.
  647. }
  649. S32 left = 0 , top = mThumbnailHeight, right = mThumbnailWidth, bottom = 0 ;
  650. if(!mKeepAspectRatio)
  651. {
  652. F32 ratio_x = (F32)mWidth[mCurImageIndex] / window_width ;
  653. F32 ratio_y = (F32)mHeight[mCurImageIndex] / window_height ;
  655. //if(mWidth[mCurImageIndex] > window_width ||
  656. // mHeight[mCurImageIndex] > window_height )
  657. {
  658. if(ratio_x > ratio_y)
  659. {
  660. top = (S32)(top * ratio_y / ratio_x) ;
  661. }
  662. else
  663. {
  664. right = (S32)(right * ratio_x / ratio_y) ;
  665. }
  666. }
  667. //else
  668. //{
  669. // right = (S32)(right * ratio_x) ;
  670. // top = (S32)(top * ratio_y) ;
  671. //}
  672. left = (S32)((mThumbnailWidth - right) * 0.5f) ;
  673. bottom = (S32)((mThumbnailHeight - top) * 0.5f) ;
  674. top += bottom ;
  675. right += left ;
  676. }
  677. mPreviewRect.set(left - 1, top + 1, right + 1, bottom - 1) ;
  679. return TRUE ;
  680. }
  682. void LLSnapshotLivePreview::generateThumbnailImage(BOOL force_update)
  683. {
  684. if(mThumbnailUpdateLock) //in the process of updating
  685. {
  686. return ;
  687. }
  688. if(mThumbnailUpToDate && !force_update)//already updated
  689. {
  690. return ;
  691. }
  692. if(mWidth[mCurImageIndex] < 10 || mHeight[mCurImageIndex] < 10)
  693. {
  694. return ;
  695. }
  697. ////lock updating
  698. mThumbnailUpdateLock = TRUE ;
  700. if(!setThumbnailImageSize())
  701. {
  702. mThumbnailUpdateLock = FALSE ;
  703. mThumbnailUpToDate = TRUE ;
  704. return ;
  705. }
  707. if(mThumbnailImage)
  708. {
  709. resetThumbnailImage() ;
  710. }
  712. LLPointer<LLImageRaw> raw = NULL ;
  713. S32 w , h ;
  714. w = get_lower_power_two(mThumbnailWidth, 512) * 2 ;
  715. h = get_lower_power_two(mThumbnailHeight, 512) * 2 ;
  717. {
  718. raw = new LLImageRaw ;
  719. if(!gViewerWindow->thumbnailSnapshot(raw,
  720. w, h,
  721. gSavedSettings.getBOOL("RenderUIInSnapshot"),
  722. FALSE,
  723. mSnapshotBufferType) )
  724. {
  725. raw = NULL ;
  726. }
  727. }
  729. if(raw)
  730. {
  731. mThumbnailImage = LLViewerTextureManager::getLocalTexture(raw.get(), FALSE); 
  732. mThumbnailUpToDate = TRUE ;
  733. }
  735. //unlock updating
  736. mThumbnailUpdateLock = FALSE ;
  737. }
  740. // Called often. Checks whether it's time to grab a new snapshot and if so, does it.
  741. // Returns TRUE if new snapshot generated, FALSE otherwise.
  742. //static 
  743. BOOL LLSnapshotLivePreview::onIdle( void* snapshot_preview )
  744. {
  745. LLSnapshotLivePreview* previewp = (LLSnapshotLivePreview*)snapshot_preview;
  747. LLVector3 new_camera_pos = LLViewerCamera::getInstance()->getOrigin();
  748. LLQuaternion new_camera_rot = LLViewerCamera::getInstance()->getQuaternion();
  749. if (gSavedSettings.getBOOL("FreezeTime") && 
  750. (new_camera_pos != previewp->mCameraPos || dot(new_camera_rot, previewp->mCameraRot) < 0.995f))
  751. {
  752. previewp->mCameraPos = new_camera_pos;
  753. previewp->mCameraRot = new_camera_rot;
  754. // request a new snapshot whenever the camera moves, with a time delay
  755. BOOL autosnap = gSavedSettings.getBOOL("AutoSnapshot");
  756. previewp->updateSnapshot(
  757. autosnap, // whether a new snapshot is needed or merely invalidate the existing one
  758. FALSE, // or if 1st arg is false, whether to produce a new thumbnail image.
  759. autosnap ? AUTO_SNAPSHOT_TIME_DELAY : 0.f); // shutter delay if 1st arg is true.
  760. }
  762. // see if it's time yet to snap the shot and bomb out otherwise.
  763. previewp->mSnapshotActive = 
  764. (previewp->mSnapshotDelayTimer.getStarted() && previewp->mSnapshotDelayTimer.hasExpired())
  765. && !LLToolCamera::getInstance()->hasMouseCapture(); // don't take snapshots while ALT-zoom active
  766. if ( ! previewp->mSnapshotActive)
  767. {
  768. return FALSE;
  769. }
  771. // time to produce a snapshot
  773. if (!previewp->mPreviewImage)
  774. {
  775. previewp->mPreviewImage = new LLImageRaw;
  776. }
  778. if (!previewp->mPreviewImageEncoded)
  779. {
  780. previewp->mPreviewImageEncoded = new LLImageRaw;
  781. }
  783. previewp->setVisible(FALSE);
  784. previewp->setEnabled(FALSE);
  786. previewp->getWindow()->incBusyCount();
  787. previewp->mImageScaled[previewp->mCurImageIndex] = FALSE;
  789. // grab the raw image and encode it into desired format
  790. if(gViewerWindow->rawSnapshot(
  791. previewp->mPreviewImage,
  792. previewp->mWidth[previewp->mCurImageIndex],
  793. previewp->mHeight[previewp->mCurImageIndex],
  794. previewp->mKeepAspectRatio,//gSavedSettings.getBOOL("KeepAspectForSnapshot"),
  795. previewp->getSnapshotType() == LLSnapshotLivePreview::SNAPSHOT_TEXTURE,
  796. gSavedSettings.getBOOL("RenderUIInSnapshot"),
  797. FALSE,
  798. previewp->mSnapshotBufferType,
  799. previewp->getMaxImageSize()))
  800. {
  801. previewp->mPreviewImageEncoded->resize(
  802. previewp->mPreviewImage->getWidth(), 
  803. previewp->mPreviewImage->getHeight(), 
  804. previewp->mPreviewImage->getComponents());
  806. if(previewp->getSnapshotType() == SNAPSHOT_TEXTURE)
  807. {
  808. LLPointer<LLImageJ2C> formatted = new LLImageJ2C;
  809. LLPointer<LLImageRaw> scaled = new LLImageRaw(
  810. previewp->mPreviewImage->getData(),
  811. previewp->mPreviewImage->getWidth(),
  812. previewp->mPreviewImage->getHeight(),
  813. previewp->mPreviewImage->getComponents());
  815. scaled->biasedScaleToPowerOfTwo(512);
  816. previewp->mImageScaled[previewp->mCurImageIndex] = TRUE;
  817. if (formatted->encode(scaled, 0.f))
  818. {
  819. previewp->mDataSize = formatted->getDataSize();
  820. formatted->decode(previewp->mPreviewImageEncoded, 0);
  821. }
  822. }
  823. else
  824. {
  825. // delete any existing image
  826. previewp->mFormattedImage = NULL;
  827. // now create the new one of the appropriate format.
  828. // note: postcards hardcoded to use jpeg always.
  829. LLFloaterSnapshot::ESnapshotFormat format = previewp->getSnapshotType() == SNAPSHOT_POSTCARD
  830. ? LLFloaterSnapshot::SNAPSHOT_FORMAT_JPEG : previewp->getSnapshotFormat();
  831. switch(format)
  832. {
  833. case LLFloaterSnapshot::SNAPSHOT_FORMAT_PNG:
  834. previewp->mFormattedImage = new LLImagePNG(); 
  835. break;
  836. case LLFloaterSnapshot::SNAPSHOT_FORMAT_JPEG:
  837. previewp->mFormattedImage = new LLImageJPEG(previewp->mSnapshotQuality); 
  838. break;
  839. case LLFloaterSnapshot::SNAPSHOT_FORMAT_BMP:
  840. previewp->mFormattedImage = new LLImageBMP(); 
  841. break;
  842. }
  843. if (previewp->mFormattedImage->encode(previewp->mPreviewImage, 0))
  844. {
  845. previewp->mDataSize = previewp->mFormattedImage->getDataSize();
  846. // special case BMP to copy instead of decode otherwise decode will crash.
  847. if(format == LLFloaterSnapshot::SNAPSHOT_FORMAT_BMP)
  848. {
  849. previewp->mPreviewImageEncoded->copy(previewp->mPreviewImage);
  850. }
  851. else
  852. {
  853. previewp->mFormattedImage->decode(previewp->mPreviewImageEncoded, 0);
  854. }
  855. }
  856. }
  858. LLPointer<LLImageRaw> scaled = new LLImageRaw(
  859. previewp->mPreviewImageEncoded->getData(),
  860. previewp->mPreviewImageEncoded->getWidth(),
  861. previewp->mPreviewImageEncoded->getHeight(),
  862. previewp->mPreviewImageEncoded->getComponents());
  864. if(!scaled->isBufferInvalid())
  865. {
  866. // leave original image dimensions, just scale up texture buffer
  867. if (previewp->mPreviewImageEncoded->getWidth() > 1024 || previewp->mPreviewImageEncoded->getHeight() > 1024)
  868. {
  869. // go ahead and shrink image to appropriate power of 2 for display
  870. scaled->biasedScaleToPowerOfTwo(1024);
  871. previewp->mImageScaled[previewp->mCurImageIndex] = TRUE;
  872. }
  873. else
  874. {
  875. // expand image but keep original image data intact
  876. scaled->expandToPowerOfTwo(1024, FALSE);
  877. }
  879. previewp->mViewerImage[previewp->mCurImageIndex] = LLViewerTextureManager::getLocalTexture(scaled.get(), FALSE);
  880. LLPointer<LLViewerTexture> curr_preview_image = previewp->mViewerImage[previewp->mCurImageIndex];
  881. gGL.getTexUnit(0)->bind(curr_preview_image);
  882. if (previewp->getSnapshotType() != SNAPSHOT_TEXTURE)
  883. {
  884. curr_preview_image->setFilteringOption(LLTexUnit::TFO_POINT);
  885. }
  886. else
  887. {
  888. curr_preview_image->setFilteringOption(LLTexUnit::TFO_ANISOTROPIC);
  889. }
  890. curr_preview_image->setAddressMode(LLTexUnit::TAM_CLAMP);
  892. previewp->mSnapshotUpToDate = TRUE;
  893. previewp->generateThumbnailImage(TRUE) ;
  895. previewp->mPosTakenGlobal = gAgent.getCameraPositionGlobal();
  896. previewp->mShineCountdown = 4; // wait a few frames to avoid animation glitch due to readback this frame
  897. }
  898. }
  899. previewp->getWindow()->decBusyCount();
  900. // only show fullscreen preview when in freeze frame mode
  901. previewp->setVisible(gSavedSettings.getBOOL("UseFreezeFrame"));
  902. previewp->mSnapshotDelayTimer.stop();
  903. previewp->mSnapshotActive = FALSE;
  905. if(!previewp->getThumbnailUpToDate())
  906. {
  907. previewp->generateThumbnailImage() ;
  908. }
  910. return TRUE;
  911. }
  913. void LLSnapshotLivePreview::setSize(S32 w, S32 h)
  914. {
  915. mWidth[mCurImageIndex] = w;
  916. mHeight[mCurImageIndex] = h;
  917. }
  919. void LLSnapshotLivePreview::getSize(S32& w, S32& h) const
  920. {
  921. w = mWidth[mCurImageIndex];
  922. h = mHeight[mCurImageIndex];
  923. }
  925. LLFloaterPostcard* LLSnapshotLivePreview::savePostcard()
  926. {
  927. if(mViewerImage[mCurImageIndex].isNull())
  928. {
  929. //this should never happen!!
  930. llwarns << "The snapshot image has not been generated!" << llendl ;
  931. return NULL ;
  932. }
  934. // calculate and pass in image scale in case image data only use portion
  935. // of viewerimage buffer
  936. LLVector2 image_scale(1.f, 1.f);
  937. if (!isImageScaled())
  938. {
  939. image_scale.setVec(llmin(1.f, (F32)mWidth[mCurImageIndex] / (F32)getCurrentImage()->getWidth()), llmin(1.f, (F32)mHeight[mCurImageIndex] / (F32)getCurrentImage()->getHeight()));
  940. }
  942. LLImageJPEG* jpg = dynamic_cast<LLImageJPEG*>(mFormattedImage.get());
  943. if(!jpg)
  944. {
  945. llwarns << "Formatted image not a JPEG" << llendl;
  946. return NULL;
  947. }
  948. LLFloaterPostcard* floater = LLFloaterPostcard::showFromSnapshot(jpg, mViewerImage[mCurImageIndex], image_scale, mPosTakenGlobal);
  949. // relinquish lifetime of jpeg image to postcard floater
  950. mFormattedImage = NULL;
  951. mDataSize = 0;
  952. updateSnapshot(FALSE, FALSE);
  954. return floater;
  955. }
  957. void LLSnapshotLivePreview::saveTexture()
  958. {
  959. // gen a new uuid for this asset
  960. LLTransactionID tid;
  961. tid.generate();
  962. LLAssetID new_asset_id = tid.makeAssetID(gAgent.getSecureSessionID());
  964. LLPointer<LLImageJ2C> formatted = new LLImageJ2C;
  965. LLPointer<LLImageRaw> scaled = new LLImageRaw(mPreviewImage->getData(),
  966.   mPreviewImage->getWidth(),
  967.   mPreviewImage->getHeight(),
  968.   mPreviewImage->getComponents());
  970. scaled->biasedScaleToPowerOfTwo(512);
  972. if (formatted->encode(scaled, 0.0f))
  973. {
  974. LLVFile::writeFile(formatted->getData(), formatted->getDataSize(), gVFS, new_asset_id, LLAssetType::AT_TEXTURE);
  975. std::string pos_string;
  976. LLAgentUI::buildLocationString(pos_string, LLAgentUI::LOCATION_FORMAT_FULL);
  977. std::string who_took_it;
  978. LLAgentUI::buildFullname(who_took_it);
  979. LLAssetStorage::LLStoreAssetCallback callback = NULL;
  980. S32 expected_upload_cost = LLGlobalEconomy::Singleton::getInstance()->getPriceUpload();
  981. void *userdata = NULL;
  982. upload_new_resource(tid, // tid
  983.     LLAssetType::AT_TEXTURE,
  984.     "Snapshot : " + pos_string,
  985.     "Taken by " + who_took_it + " at " + pos_string,
  986.     0,
  987.     LLFolderType::FT_SNAPSHOT_CATEGORY,
  988.     LLInventoryType::IT_SNAPSHOT,
  989.     PERM_ALL,  // Note: Snapshots to inventory is a special case of content upload
  990.     PERM_NONE, // that ignores the user's premissions preferences and continues to
  991.     PERM_NONE, // always use these fairly permissive hard-coded initial perms. - MG
  992.     "Snapshot : " + pos_string,
  993.     callback, expected_upload_cost, userdata);
  994. gViewerWindow->playSnapshotAnimAndSound();
  995. }
  996. else
  997. {
  998. LLNotificationsUtil::add("ErrorEncodingSnapshot");
  999. llwarns << "Error encoding snapshot" << llendl;
  1000. }
  1002. LLViewerStats::getInstance()->incStat(LLViewerStats::ST_SNAPSHOT_COUNT );
  1004. mDataSize = 0;
  1005. }
  1007. BOOL LLSnapshotLivePreview::saveLocal()
  1008. {
  1009. BOOL success = gViewerWindow->saveImageNumbered(mFormattedImage);
  1011. // Relinquish image memory. Save button will be disabled as a side-effect.
  1012. mFormattedImage = NULL;
  1013. mDataSize = 0;
  1014. updateSnapshot(FALSE, FALSE);
  1016. if(success)
  1017. {
  1018. gViewerWindow->playSnapshotAnimAndSound();
  1019. }
  1020. return success;
  1021. }
  1023. ///----------------------------------------------------------------------------
  1024. /// Class LLFloaterSnapshot::Impl
  1025. ///----------------------------------------------------------------------------
  1027. class LLFloaterSnapshot::Impl
  1028. {
  1029. public:
  1030. Impl()
  1031. : mAvatarPauseHandles(),
  1032. mLastToolset(NULL),
  1033. mAspectRatioCheckOff(false)
  1034. {
  1035. }
  1036. ~Impl()
  1037. {
  1038. //unpause avatars
  1039. mAvatarPauseHandles.clear();
  1041. }
  1042. static void onClickDiscard(void* data);
  1043. static void onClickKeep(void* data);
  1044. static void onCommitSave(LLUICtrl* ctrl, void* data);
  1045. static void onClickNewSnapshot(void* data);
  1046. static void onClickAutoSnap(LLUICtrl *ctrl, void* data);
  1047. //static void onClickAdvanceSnap(LLUICtrl *ctrl, void* data);
  1048. static void onClickLess(void* data) ;
  1049. static void onClickMore(void* data) ;
  1050. static void onClickUICheck(LLUICtrl *ctrl, void* data);
  1051. static void onClickHUDCheck(LLUICtrl *ctrl, void* data);
  1052. static void onClickKeepOpenCheck(LLUICtrl *ctrl, void* data);
  1053. static void onClickKeepAspectCheck(LLUICtrl *ctrl, void* data);
  1054. static void onCommitQuality(LLUICtrl* ctrl, void* data);
  1055. static void onCommitResolution(LLUICtrl* ctrl, void* data) { updateResolution(ctrl, data); }
  1056. static void updateResolution(LLUICtrl* ctrl, void* data, BOOL do_update = TRUE);
  1057. static void onCommitFreezeFrame(LLUICtrl* ctrl, void* data);
  1058. static void onCommitLayerTypes(LLUICtrl* ctrl, void*data);
  1059. static void onCommitSnapshotType(LLUICtrl* ctrl, void* data);
  1060. static void onCommitSnapshotFormat(LLUICtrl* ctrl, void* data);
  1061. static void onCommitCustomResolution(LLUICtrl *ctrl, void* data);
  1062. static void resetSnapshotSizeOnUI(LLFloaterSnapshot *view, S32 width, S32 height) ;
  1063. static BOOL checkImageSize(LLSnapshotLivePreview* previewp, S32& width, S32& height, BOOL isWidthChanged, S32 max_value);
  1065. static LLSnapshotLivePreview* getPreviewView(LLFloaterSnapshot *floater);
  1066. static void setResolution(LLFloaterSnapshot* floater, const std::string& comboname);
  1067. static void updateControls(LLFloaterSnapshot* floater);
  1068. static void updateLayout(LLFloaterSnapshot* floater);
  1069. static void updateResolutionTextEntry(LLFloaterSnapshot* floater);
  1071. private:
  1072. static LLSnapshotLivePreview::ESnapshotType getTypeIndex(LLFloaterSnapshot* floater);
  1073. static ESnapshotFormat getFormatIndex(LLFloaterSnapshot* floater);
  1074. static LLViewerWindow::ESnapshotType getLayerType(LLFloaterSnapshot* floater);
  1075. static void comboSetCustom(LLFloaterSnapshot *floater, const std::string& comboname);
  1076. static void checkAutoSnapshot(LLSnapshotLivePreview* floater, BOOL update_thumbnail = FALSE);
  1077. static void checkAspectRatio(LLFloaterSnapshot *view, S32 index) ;
  1079. public:
  1080. std::vector<LLAnimPauseRequest> mAvatarPauseHandles;
  1082. LLToolset* mLastToolset;
  1083. LLHandle<LLView> mPreviewHandle;
  1084. bool mAspectRatioCheckOff ;
  1085. };
  1087. // static
  1088. LLSnapshotLivePreview* LLFloaterSnapshot::Impl::getPreviewView(LLFloaterSnapshot *floater)
  1089. {
  1090. LLSnapshotLivePreview* previewp = (LLSnapshotLivePreview*)floater->impl.mPreviewHandle.get();
  1091. return previewp;
  1092. }
  1094. // static
  1095. LLSnapshotLivePreview::ESnapshotType LLFloaterSnapshot::Impl::getTypeIndex(LLFloaterSnapshot* floater)
  1096. {
  1097. LLSnapshotLivePreview::ESnapshotType index = LLSnapshotLivePreview::SNAPSHOT_POSTCARD;
  1098. LLSD value = floater->childGetValue("snapshot_type_radio");
  1099. const std::string id = value.asString();
  1100. if (id == "postcard")
  1101. index = LLSnapshotLivePreview::SNAPSHOT_POSTCARD;
  1102. else if (id == "texture")
  1103. index = LLSnapshotLivePreview::SNAPSHOT_TEXTURE;
  1104. else if (id == "local")
  1105. index = LLSnapshotLivePreview::SNAPSHOT_LOCAL;
  1106. return index;
  1107. }
  1110. // static
  1111. LLFloaterSnapshot::ESnapshotFormat LLFloaterSnapshot::Impl::getFormatIndex(LLFloaterSnapshot* floater)
  1112. {
  1113. ESnapshotFormat index = SNAPSHOT_FORMAT_PNG;
  1114. if(floater->hasChild("local_format_combo"))
  1115. {
  1116. LLComboBox* local_format_combo = floater->findChild<LLComboBox>("local_format_combo");
  1117. const std::string id  = local_format_combo->getSelectedItemLabel();
  1118. if (id == "PNG")
  1119. index = SNAPSHOT_FORMAT_PNG;
  1120. else if (id == "JPEG")
  1121. index = SNAPSHOT_FORMAT_JPEG;
  1122. else if (id == "BMP")
  1123. index = SNAPSHOT_FORMAT_BMP;
  1124. }
  1125. return index;
  1126. }
  1130. // static
  1131. LLViewerWindow::ESnapshotType LLFloaterSnapshot::Impl::getLayerType(LLFloaterSnapshot* floater)
  1132. {
  1133. LLViewerWindow::ESnapshotType type = LLViewerWindow::SNAPSHOT_TYPE_COLOR;
  1134. LLSD value = floater->childGetValue("layer_types");
  1135. const std::string id = value.asString();
  1136. if (id == "colors")
  1137. type = LLViewerWindow::SNAPSHOT_TYPE_COLOR;
  1138. else if (id == "depth")
  1139. type = LLViewerWindow::SNAPSHOT_TYPE_DEPTH;
  1140. else if (id == "objects")
  1141. type = LLViewerWindow::SNAPSHOT_TYPE_OBJECT_ID;
  1142. return type;
  1143. }
  1145. // static
  1146. void LLFloaterSnapshot::Impl::setResolution(LLFloaterSnapshot* floater, const std::string& comboname)
  1147. {
  1148. LLComboBox* combo = floater->getChild<LLComboBox>(comboname);
  1149. combo->setVisible(TRUE);
  1150. updateResolution(combo, floater, FALSE); // to sync spinners with combo
  1151. }
  1153. //static 
  1154. void LLFloaterSnapshot::Impl::updateLayout(LLFloaterSnapshot* floaterp)
  1155. {
  1156. LLSnapshotLivePreview* previewp = getPreviewView(floaterp);
  1158. S32 delta_height = gSavedSettings.getBOOL("AdvanceSnapshot") ? 0 : floaterp->getUIWinHeightShort() - floaterp->getUIWinHeightLong() ;
  1160. if(!gSavedSettings.getBOOL("AdvanceSnapshot")) //set to original window resolution
  1161. {
  1162. previewp->mKeepAspectRatio = TRUE;
  1164. floaterp->getChild<LLComboBox>("postcard_size_combo")->setCurrentByIndex(0);
  1165. gSavedSettings.setS32("SnapshotPostcardLastResolution", 0);
  1167. floaterp->getChild<LLComboBox>("texture_size_combo")->setCurrentByIndex(0);
  1168. gSavedSettings.setS32("SnapshotTextureLastResolution", 0);
  1170. floaterp->getChild<LLComboBox>("local_size_combo")->setCurrentByIndex(0);
  1171. gSavedSettings.setS32("SnapshotLocalLastResolution", 0);
  1173. LLSnapshotLivePreview* previewp = getPreviewView(floaterp);
  1174. previewp->setSize(gViewerWindow->getWindowWidthRaw(), gViewerWindow->getWindowHeightRaw());
  1175. }
  1177. bool use_freeze_frame = floaterp->childGetValue("freeze_frame_check").asBoolean();
  1179. if (use_freeze_frame)
  1180. {
  1181. // stop all mouse events at fullscreen preview layer
  1182. floaterp->getParent()->setMouseOpaque(TRUE);
  1184. // shrink to smaller layout
  1185. floaterp->reshape(floaterp->getRect().getWidth(), floaterp->getUIWinHeightLong() + delta_height);
  1187. // can see and interact with fullscreen preview now
  1188. if (previewp)
  1189. {
  1190. previewp->setVisible(TRUE);
  1191. previewp->setEnabled(TRUE);
  1192. }
  1194. //RN: freeze all avatars
  1195. LLCharacter* avatarp;
  1196. for (std::vector<LLCharacter*>::iterator iter = LLCharacter::sInstances.begin();
  1197. iter != LLCharacter::sInstances.end(); ++iter)
  1198. {
  1199. avatarp = *iter;
  1200. floaterp->impl.mAvatarPauseHandles.push_back(avatarp->requestPause());
  1201. }
  1203. // freeze everything else
  1204. gSavedSettings.setBOOL("FreezeTime", TRUE);
  1206. if (LLToolMgr::getInstance()->getCurrentToolset() != gCameraToolset)
  1207. {
  1208. floaterp->impl.mLastToolset = LLToolMgr::getInstance()->getCurrentToolset();
  1209. LLToolMgr::getInstance()->setCurrentToolset(gCameraToolset);
  1210. }
  1211. }
  1212. else // turning off freeze frame mode
  1213. {
  1214. floaterp->getParent()->setMouseOpaque(FALSE);
  1215. floaterp->reshape(floaterp->getRect().getWidth(), floaterp->getUIWinHeightLong() + delta_height);
  1216. if (previewp)
  1217. {
  1218. previewp->setVisible(FALSE);
  1219. previewp->setEnabled(FALSE);
  1220. }
  1222. //RN: thaw all avatars
  1223. floaterp->impl.mAvatarPauseHandles.clear();
  1225. // thaw everything else
  1226. gSavedSettings.setBOOL("FreezeTime", FALSE);
  1228. // restore last tool (e.g. pie menu, etc)
  1229. if (floaterp->impl.mLastToolset)
  1230. {
  1231. LLToolMgr::getInstance()->setCurrentToolset(floaterp->impl.mLastToolset);
  1232. }
  1233. }
  1234. }
  1236. // This is the main function that keeps all the GUI controls in sync with the saved settings.
  1237. // It should be called anytime a setting is changed that could affect the controls.
  1238. // No other methods should be changing any of the controls directly except for helpers called by this method.
  1239. // The basic pattern for programmatically changing the GUI settings is to first set the
  1240. // appropriate saved settings and then call this method to sync the GUI with them.
  1241. // static
  1242. void LLFloaterSnapshot::Impl::updateControls(LLFloaterSnapshot* floater)
  1243. {
  1244. LLRadioGroup* snapshot_type_radio = floater->getChild<LLRadioGroup>("snapshot_type_radio");
  1245. snapshot_type_radio->setSelectedIndex(gSavedSettings.getS32("LastSnapshotType"));
  1246. LLSnapshotLivePreview::ESnapshotType shot_type = getTypeIndex(floater);
  1247. ESnapshotFormat shot_format = (ESnapshotFormat)gSavedSettings.getS32("SnapshotFormat"); //getFormatIndex(floater); LLViewerWindow::ESnapshotType layer_type = getLayerType(floater);
  1248. LLViewerWindow::ESnapshotType layer_type = getLayerType(floater);
  1250. floater->childSetVisible("postcard_size_combo", FALSE);
  1251. floater->childSetVisible("texture_size_combo", FALSE);
  1252. floater->childSetVisible("local_size_combo", FALSE);
  1254. floater->getChild<LLComboBox>("postcard_size_combo")->selectNthItem(gSavedSettings.getS32("SnapshotPostcardLastResolution"));
  1255. floater->getChild<LLComboBox>("texture_size_combo")->selectNthItem(gSavedSettings.getS32("SnapshotTextureLastResolution"));
  1256. floater->getChild<LLComboBox>("local_size_combo")->selectNthItem(gSavedSettings.getS32("SnapshotLocalLastResolution"));
  1257. floater->getChild<LLComboBox>("local_format_combo")->selectNthItem(gSavedSettings.getS32("SnapshotFormat"));
  1259. floater->childSetVisible("upload_btn", shot_type == LLSnapshotLivePreview::SNAPSHOT_TEXTURE);
  1260. floater->childSetVisible("send_btn", shot_type == LLSnapshotLivePreview::SNAPSHOT_POSTCARD);
  1261. floater->childSetVisible("save_btn", shot_type == LLSnapshotLivePreview::SNAPSHOT_LOCAL);
  1262. floater->childSetEnabled("keep_aspect_check", shot_type != LLSnapshotLivePreview::SNAPSHOT_TEXTURE && !floater->impl.mAspectRatioCheckOff);
  1263. floater->childSetEnabled("layer_types", shot_type == LLSnapshotLivePreview::SNAPSHOT_LOCAL);
  1265. BOOL is_advance = gSavedSettings.getBOOL("AdvanceSnapshot");
  1266. BOOL is_local = shot_type == LLSnapshotLivePreview::SNAPSHOT_LOCAL;
  1267. BOOL show_slider = 
  1268. shot_type == LLSnapshotLivePreview::SNAPSHOT_POSTCARD
  1269. || (is_local && shot_format == LLFloaterSnapshot::SNAPSHOT_FORMAT_JPEG);
  1271. floater->childSetVisible("more_btn", !is_advance); // the only item hidden in advanced mode
  1272. floater->childSetVisible("less_btn", is_advance);
  1273. floater->childSetVisible("type_label2", is_advance);
  1274. floater->childSetVisible("format_label", is_advance && is_local);
  1275. floater->childSetVisible("local_format_combo", is_advance && is_local);
  1276. floater->childSetVisible("layer_types", is_advance);
  1277. floater->childSetVisible("layer_type_label", is_advance);
  1278. floater->childSetVisible("snapshot_width", is_advance);
  1279. floater->childSetVisible("snapshot_height", is_advance);
  1280. floater->childSetVisible("keep_aspect_check", is_advance);
  1281. floater->childSetVisible("ui_check", is_advance);
  1282. floater->childSetVisible("hud_check", is_advance);
  1283. floater->childSetVisible("keep_open_check", is_advance);
  1284. floater->childSetVisible("freeze_frame_check", is_advance);
  1285. floater->childSetVisible("auto_snapshot_check", is_advance);
  1286. floater->childSetVisible("image_quality_slider", is_advance && show_slider);
  1288. LLSnapshotLivePreview* previewp = getPreviewView(floater);
  1289. BOOL got_bytes = previewp && previewp->getDataSize() > 0;
  1290. BOOL got_snap = previewp && previewp->getSnapshotUpToDate();
  1292. floater->childSetEnabled("send_btn",   shot_type == LLSnapshotLivePreview::SNAPSHOT_POSTCARD && got_snap && previewp->getDataSize() <= MAX_POSTCARD_DATASIZE);
  1293. floater->childSetEnabled("upload_btn", shot_type == LLSnapshotLivePreview::SNAPSHOT_TEXTURE  && got_snap);
  1294. floater->childSetEnabled("save_btn",   shot_type == LLSnapshotLivePreview::SNAPSHOT_LOCAL    && got_snap);
  1296. LLLocale locale(LLLocale::USER_LOCALE);
  1297. std::string bytes_string;
  1298. if (got_snap)
  1299. {
  1300. LLResMgr::getInstance()->getIntegerString(bytes_string, (previewp->getDataSize()) >> 10 );
  1301. }
  1302. S32 upload_cost = LLGlobalEconomy::Singleton::getInstance()->getPriceUpload();
  1303. floater->childSetLabelArg("texture", "[AMOUNT]", llformat("%d",upload_cost));
  1304. floater->childSetLabelArg("upload_btn", "[AMOUNT]", llformat("%d",upload_cost));
  1305. floater->childSetTextArg("file_size_label", "[SIZE]", got_snap ? bytes_string : floater->getString("unknown"));
  1306. floater->childSetColor("file_size_label", 
  1307. shot_type == LLSnapshotLivePreview::SNAPSHOT_POSTCARD 
  1308. && got_bytes
  1309. && previewp->getDataSize() > MAX_POSTCARD_DATASIZE ? LLUIColor(LLColor4::red) : LLUIColorTable::instance().getColor( "LabelTextColor" ));
  1311. switch(shot_type)
  1312. {
  1313.   case LLSnapshotLivePreview::SNAPSHOT_POSTCARD:
  1314. layer_type = LLViewerWindow::SNAPSHOT_TYPE_COLOR;
  1315. floater->childSetValue("layer_types", "colors");
  1316. if(is_advance)
  1317. {
  1318. setResolution(floater, "postcard_size_combo");
  1319. }
  1320. break;
  1321.   case LLSnapshotLivePreview::SNAPSHOT_TEXTURE:
  1322. layer_type = LLViewerWindow::SNAPSHOT_TYPE_COLOR;
  1323. floater->childSetValue("layer_types", "colors");
  1324. if(is_advance)
  1325. {
  1326. setResolution(floater, "texture_size_combo");
  1327. }
  1328. break;
  1329.   case  LLSnapshotLivePreview::SNAPSHOT_LOCAL:
  1330. if(is_advance)
  1331. {
  1332. setResolution(floater, "local_size_combo");
  1333. }
  1334. break;
  1335.   default:
  1336. break;
  1337. }
  1339. updateResolutionTextEntry(floater);
  1341. if (previewp)
  1342. {
  1343. previewp->setSnapshotType(shot_type);
  1344. previewp->setSnapshotFormat(shot_format);
  1345. previewp->setSnapshotBufferType(layer_type);
  1346. }
  1347. }
  1349. // static
  1350. void LLFloaterSnapshot::Impl::updateResolutionTextEntry(LLFloaterSnapshot* floater)
  1351. {
  1352. LLSpinCtrl* width_spinner = floater->getChild<LLSpinCtrl>("snapshot_width");
  1353. LLSpinCtrl* height_spinner = floater->getChild<LLSpinCtrl>("snapshot_height");
  1355. if(getTypeIndex(floater) == LLSnapshotLivePreview::SNAPSHOT_TEXTURE)
  1356. {
  1357. width_spinner->setAllowEdit(FALSE);
  1358. height_spinner->setAllowEdit(FALSE);
  1359. }
  1360. else
  1361. {
  1362. width_spinner->setAllowEdit(TRUE);
  1363. height_spinner->setAllowEdit(TRUE);
  1364. }
  1365. }
  1367. // static
  1368. void LLFloaterSnapshot::Impl::checkAutoSnapshot(LLSnapshotLivePreview* previewp, BOOL update_thumbnail)
  1369. {
  1370. if (previewp)
  1371. {
  1372. BOOL autosnap = gSavedSettings.getBOOL("AutoSnapshot");
  1373. previewp->updateSnapshot(autosnap, update_thumbnail, autosnap ? AUTO_SNAPSHOT_TIME_DELAY : 0.f);
  1374. }
  1375. }
  1377. // static
  1378. void LLFloaterSnapshot::Impl::onClickDiscard(void* data)
  1379. {
  1380. LLFloaterSnapshot *view = (LLFloaterSnapshot *)data;
  1382. if (view)
  1383. {
  1384. view->closeFloater();
  1385. }
  1386. }
  1389. // static
  1390. void LLFloaterSnapshot::Impl::onCommitSave(LLUICtrl* ctrl, void* data)
  1391. {
  1392. if (ctrl->getValue().asString() == "save as")
  1393. {
  1394. gViewerWindow->resetSnapshotLoc();
  1395. }
  1396. onClickKeep(data);
  1397. }
  1399. // static
  1400. void LLFloaterSnapshot::Impl::onClickKeep(void* data)
  1401. {
  1402. LLFloaterSnapshot *view = (LLFloaterSnapshot *)data;
  1403. LLSnapshotLivePreview* previewp = getPreviewView(view);
  1405. if (previewp)
  1406. {
  1407. if (previewp->getSnapshotType() == LLSnapshotLivePreview::SNAPSHOT_POSTCARD)
  1408. {
  1409. LLFloaterPostcard* floater = previewp->savePostcard();
  1410. // if still in snapshot mode, put postcard floater in snapshot floaterview
  1411. // and link it to snapshot floater
  1412. if (floater && !gSavedSettings.getBOOL("CloseSnapshotOnKeep"))
  1413. {
  1414. gFloaterView->removeChild(floater);
  1415. gSnapshotFloaterView->addChild(floater);
  1416. view->addDependentFloater(floater, FALSE);
  1417. }
  1418. }
  1419. else if (previewp->getSnapshotType() == LLSnapshotLivePreview::SNAPSHOT_TEXTURE)
  1420. {
  1421. previewp->saveTexture();
  1422. }
  1423. else
  1424. {
  1425. previewp->saveLocal();
  1426. }
  1428. if (gSavedSettings.getBOOL("CloseSnapshotOnKeep"))
  1429. {
  1430. view->closeFloater();
  1431. }
  1432. else
  1433. {
  1434. checkAutoSnapshot(previewp);
  1435. }
  1437. updateControls(view);
  1438. }
  1439. }
  1441. // static
  1442. void LLFloaterSnapshot::Impl::onClickNewSnapshot(void* data)
  1443. {
  1444. LLSnapshotLivePreview* previewp = getPreviewView((LLFloaterSnapshot *)data);
  1445. LLFloaterSnapshot *view = (LLFloaterSnapshot *)data;
  1446. if (previewp && view)
  1447. {
  1448. previewp->updateSnapshot(TRUE);
  1449. }
  1450. }
  1452. // static
  1453. void LLFloaterSnapshot::Impl::onClickAutoSnap(LLUICtrl *ctrl, void* data)
  1454. {
  1455. LLCheckBoxCtrl *check = (LLCheckBoxCtrl *)ctrl;
  1456. gSavedSettings.setBOOL( "AutoSnapshot", check->get() );
  1458. LLFloaterSnapshot *view = (LLFloaterSnapshot *)data;
  1459. if (view)
  1460. {
  1461. checkAutoSnapshot(getPreviewView(view));
  1462. updateControls(view);
  1463. }
  1464. }
  1466. void LLFloaterSnapshot::Impl::onClickMore(void* data)
  1467. {
  1468. gSavedSettings.setBOOL( "AdvanceSnapshot", TRUE );
  1470. LLFloaterSnapshot *view = (LLFloaterSnapshot *)data;
  1471. if (view)
  1472. {
  1473. view->translate( 0, view->getUIWinHeightShort() - view->getUIWinHeightLong() );
  1474. view->reshape(view->getRect().getWidth(), view->getUIWinHeightLong());
  1475. updateControls(view) ;
  1476. updateLayout(view) ;
  1477. if(getPreviewView(view))
  1478. {
  1479. getPreviewView(view)->setThumbnailImageSize() ;
  1480. }
  1481. }
  1482. }
  1483. void LLFloaterSnapshot::Impl::onClickLess(void* data)
  1484. {
  1485. gSavedSettings.setBOOL( "AdvanceSnapshot", FALSE );
  1487. LLFloaterSnapshot *view = (LLFloaterSnapshot *)data;
  1488. if (view)
  1489. {
  1490. view->translate( 0, view->getUIWinHeightLong() - view->getUIWinHeightShort() );
  1491. view->reshape(view->getRect().getWidth(), view->getUIWinHeightShort());
  1492. updateControls(view) ;
  1493. updateLayout(view) ;
  1494. if(getPreviewView(view))
  1495. {
  1496. getPreviewView(view)->setThumbnailImageSize() ;
  1497. }
  1498. }
  1499. }
  1501. // static
  1502. void LLFloaterSnapshot::Impl::onClickUICheck(LLUICtrl *ctrl, void* data)
  1503. {
  1504. LLCheckBoxCtrl *check = (LLCheckBoxCtrl *)ctrl;
  1505. gSavedSettings.setBOOL( "RenderUIInSnapshot", check->get() );
  1507. LLFloaterSnapshot *view = (LLFloaterSnapshot *)data;
  1508. if (view)
  1509. {
  1510. checkAutoSnapshot(getPreviewView(view), TRUE);
  1511. updateControls(view);
  1512. }
  1513. }
  1515. // static
  1516. void LLFloaterSnapshot::Impl::onClickHUDCheck(LLUICtrl *ctrl, void* data)
  1517. {
  1518. LLCheckBoxCtrl *check = (LLCheckBoxCtrl *)ctrl;
  1519. gSavedSettings.setBOOL( "RenderHUDInSnapshot", check->get() );
  1521. LLFloaterSnapshot *view = (LLFloaterSnapshot *)data;
  1522. if (view)
  1523. {
  1524. checkAutoSnapshot(getPreviewView(view), TRUE);
  1525. updateControls(view);
  1526. }
  1527. }
  1529. // static
  1530. void LLFloaterSnapshot::Impl::onClickKeepOpenCheck(LLUICtrl* ctrl, void* data)
  1531. {
  1532. LLCheckBoxCtrl *check = (LLCheckBoxCtrl *)ctrl;
  1534. gSavedSettings.setBOOL( "CloseSnapshotOnKeep", !check->get() );
  1535. }
  1537. // static
  1538. void LLFloaterSnapshot::Impl::onClickKeepAspectCheck(LLUICtrl* ctrl, void* data)
  1539. {
  1540. LLCheckBoxCtrl *check = (LLCheckBoxCtrl *)ctrl;
  1541. gSavedSettings.setBOOL( "KeepAspectForSnapshot", check->get() );
  1543. LLFloaterSnapshot *view = (LLFloaterSnapshot *)data;
  1544. if (view)
  1545. {
  1546. LLSnapshotLivePreview* previewp = getPreviewView(view) ;
  1547. if(previewp)
  1548. {
  1549. previewp->mKeepAspectRatio = gSavedSettings.getBOOL("KeepAspectForSnapshot") ;
  1551. S32 w, h ;
  1552. previewp->getSize(w, h) ;
  1553. if(checkImageSize(previewp, w, h, TRUE, previewp->getMaxImageSize()))
  1554. {
  1555. resetSnapshotSizeOnUI(view, w, h) ;
  1556. }
  1558. previewp->setSize(w, h) ;
  1559. previewp->updateSnapshot(FALSE, TRUE);
  1560. checkAutoSnapshot(previewp, TRUE);
  1561. }
  1562. }
  1563. }
  1565. // static
  1566. void LLFloaterSnapshot::Impl::onCommitQuality(LLUICtrl* ctrl, void* data)
  1567. {
  1568. LLSliderCtrl* slider = (LLSliderCtrl*)ctrl;
  1569. S32 quality_val = llfloor((F32)slider->getValue().asReal());
  1571. LLSnapshotLivePreview* previewp = getPreviewView((LLFloaterSnapshot *)data);
  1572. if (previewp)
  1573. {
  1574. previewp->setSnapshotQuality(quality_val);
  1575. }
  1576. checkAutoSnapshot(previewp, TRUE);
  1577. }
  1579. // static
  1580. void LLFloaterSnapshot::Impl::onCommitFreezeFrame(LLUICtrl* ctrl, void* data)
  1581. {
  1582. LLCheckBoxCtrl* check_box = (LLCheckBoxCtrl*)ctrl;
  1583. LLFloaterSnapshot *view = (LLFloaterSnapshot *)data;
  1585. if (!view || !check_box)
  1586. {
  1587. return;
  1588. }
  1590. gSavedSettings.setBOOL("UseFreezeFrame", check_box->get());
  1592. updateLayout(view);
  1593. }
  1595. // static
  1596. void LLFloaterSnapshot::Impl::checkAspectRatio(LLFloaterSnapshot *view, S32 index)
  1597. {
  1598. LLSnapshotLivePreview *previewp = getPreviewView(view) ;
  1600. // Don't round texture sizes; textures are commonly stretched in world, profiles, etc and need to be "squashed" during upload, not cropped here
  1601. #if 0
  1602. if(LLSnapshotLivePreview::SNAPSHOT_TEXTURE == getTypeIndex(view))
  1603. {
  1604. previewp->mKeepAspectRatio = FALSE ;
  1605. return ;
  1606. }
  1607. #endif
  1609. if(0 == index) //current window size
  1610. {
  1611. view->impl.mAspectRatioCheckOff = true ;
  1612. view->childSetEnabled("keep_aspect_check", FALSE) ;
  1614. if(previewp)
  1615. {
  1616. previewp->mKeepAspectRatio = TRUE ;
  1617. }
  1618. }
  1619. else if(-1 == index) //custom
  1620. {
  1621. view->impl.mAspectRatioCheckOff = false ;
  1622. //if(LLSnapshotLivePreview::SNAPSHOT_TEXTURE != gSavedSettings.getS32("LastSnapshotType"))
  1623. {
  1624. view->childSetEnabled("keep_aspect_check", TRUE) ;
  1626. if(previewp)
  1627. {
  1628. previewp->mKeepAspectRatio = gSavedSettings.getBOOL("KeepAspectForSnapshot") ;
  1629. }
  1630. }
  1631. }
  1632. else
  1633. {
  1634. view->impl.mAspectRatioCheckOff = true ;
  1635. view->childSetEnabled("keep_aspect_check", FALSE) ;
  1637. if(previewp)
  1638. {
  1639. previewp->mKeepAspectRatio = FALSE ;
  1640. }
  1641. }
  1643. return ;
  1644. }
  1646. static std::string lastSnapshotWidthName()
  1647. {
  1648. switch(gSavedSettings.getS32("LastSnapshotType"))
  1649. {
  1650. case LLSnapshotLivePreview::SNAPSHOT_POSTCARD: return "LastSnapshotToEmailWidth";
  1651. case LLSnapshotLivePreview::SNAPSHOT_TEXTURE:  return "LastSnapshotToInventoryWidth";
  1652. default:                                       return "LastSnapshotToDiskWidth";
  1653. }
  1654. }
  1655. static std::string lastSnapshotHeightName()
  1656. {
  1657. switch(gSavedSettings.getS32("LastSnapshotType"))
  1658. {
  1659. case LLSnapshotLivePreview::SNAPSHOT_POSTCARD: return "LastSnapshotToEmailHeight";
  1660. case LLSnapshotLivePreview::SNAPSHOT_TEXTURE:  return "LastSnapshotToInventoryHeight";
  1661. default:                                       return "LastSnapshotToDiskHeight";
  1662. }
  1663. }
  1665. // static
  1666. void LLFloaterSnapshot::Impl::updateResolution(LLUICtrl* ctrl, void* data, BOOL do_update)
  1667. {
  1668. LLComboBox* combobox = (LLComboBox*)ctrl;
  1669. LLFloaterSnapshot *view = (LLFloaterSnapshot *)data;
  1671. if (!view || !combobox)
  1672. {
  1673. return;
  1674. }
  1676. // save off all selected resolution values
  1677. gSavedSettings.setS32("SnapshotPostcardLastResolution", view->getChild<LLComboBox>("postcard_size_combo")->getCurrentIndex());
  1678. gSavedSettings.setS32("SnapshotTextureLastResolution",  view->getChild<LLComboBox>("texture_size_combo")->getCurrentIndex());
  1679. gSavedSettings.setS32("SnapshotLocalLastResolution",    view->getChild<LLComboBox>("local_size_combo")->getCurrentIndex());
  1681. std::string sdstring = combobox->getSelectedValue();
  1682. LLSD sdres;
  1683. std::stringstream sstream(sdstring);
  1684. LLSDSerialize::fromNotation(sdres, sstream, sdstring.size());
  1686. S32 width = sdres[0];
  1687. S32 height = sdres[1];
  1689. LLSnapshotLivePreview* previewp = getPreviewView(view);
  1690. if (previewp && combobox->getCurrentIndex() >= 0)
  1691. {
  1692. S32 original_width = 0 , original_height = 0 ;
  1693. previewp->getSize(original_width, original_height) ;
  1695. if (width == 0 || height == 0)
  1696. {
  1697. // take resolution from current window size
  1698. previewp->setSize(gViewerWindow->getWindowWidthRaw(), gViewerWindow->getWindowHeightRaw());
  1699. }
  1700. else if (width == -1 || height == -1)
  1701. {
  1702. // load last custom value
  1703. previewp->setSize(gSavedSettings.getS32(lastSnapshotWidthName()), gSavedSettings.getS32(lastSnapshotHeightName()));
  1704. }
  1705. else
  1706. {
  1707. // use the resolution from the selected pre-canned drop-down choice
  1708. previewp->setSize(width, height);
  1709. }
  1711. checkAspectRatio(view, width) ;
  1713. previewp->getSize(width, height);
  1715. if(checkImageSize(previewp, width, height, TRUE, previewp->getMaxImageSize()))
  1716. {
  1717. resetSnapshotSizeOnUI(view, width, height) ;
  1718. }
  1720. if(view->childGetValue("snapshot_width").asInteger() != width || view->childGetValue("snapshot_height").asInteger() != height)
  1721. {
  1722. view->childSetValue("snapshot_width", width);
  1723. view->childSetValue("snapshot_height", height);
  1724. }
  1726. if(original_width != width || original_height != height)
  1727. {
  1728. previewp->setSize(width, height);
  1730. // hide old preview as the aspect ratio could be wrong
  1731. checkAutoSnapshot(previewp, FALSE);
  1732. getPreviewView(view)->updateSnapshot(FALSE, TRUE);
  1733. if(do_update)
  1734. {
  1735. updateControls(view);
  1736. }
  1737. }
  1738. }
  1739. }
  1741. // static
  1742. void LLFloaterSnapshot::Impl::onCommitLayerTypes(LLUICtrl* ctrl, void*data)
  1743. {
  1744. LLComboBox* combobox = (LLComboBox*)ctrl;
  1746. LLFloaterSnapshot *view = (LLFloaterSnapshot *)data;
  1748. if (view)
  1749. {
  1750. LLSnapshotLivePreview* previewp = getPreviewView(view);
  1751. if (previewp)
  1752. {
  1753. previewp->setSnapshotBufferType((LLViewerWindow::ESnapshotType)combobox->getCurrentIndex());
  1754. }
  1755. checkAutoSnapshot(previewp, TRUE);
  1756. }
  1757. }
  1759. //static 
  1760. void LLFloaterSnapshot::Impl::onCommitSnapshotType(LLUICtrl* ctrl, void* data)
  1761. {
  1762. LLFloaterSnapshot *view = (LLFloaterSnapshot *)data;
  1763. if (view)
  1764. {
  1765. gSavedSettings.setS32("LastSnapshotType", getTypeIndex(view));
  1766. getPreviewView(view)->updateSnapshot(TRUE);
  1767. updateControls(view);
  1768. }
  1769. }
  1772. //static 
  1773. void LLFloaterSnapshot::Impl::onCommitSnapshotFormat(LLUICtrl* ctrl, void* data)
  1774. {
  1775. LLFloaterSnapshot *view = (LLFloaterSnapshot *)data;
  1776. if (view)
  1777. {
  1778. gSavedSettings.setS32("SnapshotFormat", getFormatIndex(view));
  1779. getPreviewView(view)->updateSnapshot(TRUE);
  1780. updateControls(view);
  1781. }
  1782. }
  1786. // Sets the named size combo to "custom" mode.
  1787. // static
  1788. void LLFloaterSnapshot::Impl::comboSetCustom(LLFloaterSnapshot* floater, const std::string& comboname)
  1789. {
  1790. LLComboBox* combo = floater->getChild<LLComboBox>(comboname);
  1792. combo->setCurrentByIndex(combo->getItemCount() - 1); // "custom" is always the last index
  1794. if(comboname == "postcard_size_combo") 
  1795. {
  1796. gSavedSettings.setS32("SnapshotPostcardLastResolution", combo->getCurrentIndex());
  1797. }
  1798. else if(comboname == "texture_size_combo") 
  1799. {
  1800. gSavedSettings.setS32("SnapshotTextureLastResolution", combo->getCurrentIndex());
  1801. }
  1802. else if(comboname == "local_size_combo") 
  1803. {
  1804. gSavedSettings.setS32("SnapshotLocalLastResolution", combo->getCurrentIndex());
  1805. }
  1807. checkAspectRatio(floater, -1); // -1 means custom
  1808. }
  1812. //static
  1813. BOOL LLFloaterSnapshot::Impl::checkImageSize(LLSnapshotLivePreview* previewp, S32& width, S32& height, BOOL isWidthChanged, S32 max_value)
  1814. {
  1815. S32 w = width ;
  1816. S32 h = height ;
  1818. //if texture, ignore aspect ratio setting, round image size to power of 2.
  1819. #if 0 // Don't round texture sizes; textures are commonly stretched in world, profiles, etc and need to be "squashed" during upload, not cropped here
  1820. if(LLSnapshotLivePreview::SNAPSHOT_TEXTURE == gSavedSettings.getS32("LastSnapshotType"))
  1821. {
  1822. if(width > max_value)
  1823. {
  1824. width = max_value ;
  1825. }
  1826. if(height > max_value)
  1827. {
  1828. height = max_value ;
  1829. }
  1831. //round to nearest power of 2 based on the direction of movement
  1832. // i.e. higher power of two if increasing texture resolution
  1833. if(gSavedSettings.getS32("LastSnapshotToInventoryWidth") < width ||
  1834. gSavedSettings.getS32("LastSnapshotToInventoryHeight") < height)
  1835. {
  1836. // Up arrow pressed
  1837. width = get_next_power_two(width, MAX_TEXTURE_SIZE) ;
  1838. height = get_next_power_two(height, MAX_TEXTURE_SIZE) ;
  1839. }
  1840. else
  1841. {
  1842. // Down or no change
  1843. width = get_lower_power_two(width, MAX_TEXTURE_SIZE) ;
  1844. height = get_lower_power_two(height, MAX_TEXTURE_SIZE) ;
  1845. }
  1846. }
  1847. else
  1848. #endif
  1849. if(previewp && previewp->mKeepAspectRatio)
  1850. {
  1851. if(gViewerWindow->getWindowWidthRaw() < 1 || gViewerWindow->getWindowHeightRaw() < 1)
  1852. {
  1853. return FALSE ;
  1854. }
  1856. //aspect ratio of the current window
  1857. F32 aspect_ratio = (F32)gViewerWindow->getWindowWidthRaw() / gViewerWindow->getWindowHeightRaw() ;
  1859. //change another value proportionally
  1860. if(isWidthChanged)
  1861. {
  1862. height = (S32)(width / aspect_ratio) ;
  1863. }
  1864. else
  1865. {
  1866. width = (S32)(height * aspect_ratio) ;
  1867. }
  1869. //bound w/h by the max_value
  1870. if(width > max_value || height > max_value)
  1871. {
  1872. if(width > height)
  1873. {
  1874. width = max_value ;
  1875. height = (S32)(width / aspect_ratio) ;
  1876. }
  1877. else
  1878. {
  1879. height = max_value ;
  1880. width = (S32)(height * aspect_ratio) ;
  1881. }
  1882. }
  1883. }
  1884. else
  1885. {
  1886. }
  1888. return (w != width || h != height) ;
  1889. }
  1891. //static
  1892. void LLFloaterSnapshot::Impl::resetSnapshotSizeOnUI(LLFloaterSnapshot *view, S32 width, S32 height)
  1893. {
  1894. view->getChild<LLSpinCtrl>("snapshot_width")->forceSetValue(width);
  1895. view->getChild<LLSpinCtrl>("snapshot_height")->forceSetValue(height);
  1896. gSavedSettings.setS32(lastSnapshotWidthName(), width);
  1897. gSavedSettings.setS32(lastSnapshotHeightName(), height);
  1898. }
  1900. //static
  1901. void LLFloaterSnapshot::Impl::onCommitCustomResolution(LLUICtrl *ctrl, void* data)
  1902. {
  1903. LLFloaterSnapshot *view = (LLFloaterSnapshot *)data;
  1904. if (view)
  1905. {
  1906. S32 w = llfloor((F32)view->childGetValue("snapshot_width").asReal());
  1907. S32 h = llfloor((F32)view->childGetValue("snapshot_height").asReal());
  1909. LLSnapshotLivePreview* previewp = getPreviewView(view);
  1910. if (previewp)
  1911. {
  1912. S32 curw,curh;
  1913. previewp->getSize(curw, curh);
  1915. if (w != curw || h != curh)
  1916. {
  1917. BOOL update_ = FALSE ;
  1918. //if to upload a snapshot, process spinner input in a special way.
  1919. #if 0  // Don't round texture sizes; textures are commonly stretched in world, profiles, etc and need to be "squashed" during upload, not cropped here
  1920. if(LLSnapshotLivePreview::SNAPSHOT_TEXTURE == gSavedSettings.getS32("LastSnapshotType"))
  1921. {
  1922. S32 spinner_increment = (S32)((LLSpinCtrl*)ctrl)->getIncrement() ;
  1923. S32 dw = w - curw ;
  1924. S32 dh = h - curh ;
  1925. dw = (dw == spinner_increment) ? 1 : ((dw == -spinner_increment) ? -1 : 0) ;
  1926. dh = (dh == spinner_increment) ? 1 : ((dh == -spinner_increment) ? -1 : 0) ;
  1928. if(dw)
  1929. {
  1930. w = (dw > 0) ? curw << dw : curw >> -dw ;
  1931. update_ = TRUE ;
  1932. }
  1933. if(dh)
  1934. {
  1935. h = (dh > 0) ? curh << dh : curh >> -dh ;
  1936. update_ = TRUE ;
  1937. }
  1938. }
  1939. #endif
  1940. previewp->setMaxImageSize((S32)((LLSpinCtrl *)ctrl)->getMaxValue()) ;
  1942. // Check image size changes the value of height and width
  1943. if(checkImageSize(previewp, w, h, w != curw, previewp->getMaxImageSize())
  1944. || update_)
  1945. {
  1946. resetSnapshotSizeOnUI(view, w, h) ;
  1947. }
  1949. previewp->setSize(w,h);
  1950. checkAutoSnapshot(previewp, FALSE);
  1951. previewp->updateSnapshot(FALSE, TRUE);
  1952. comboSetCustom(view, "postcard_size_combo");
  1953. comboSetCustom(view, "texture_size_combo");
  1954. comboSetCustom(view, "local_size_combo");
  1955. }
  1956. }
  1958. gSavedSettings.setS32(lastSnapshotWidthName(), w);
  1959. gSavedSettings.setS32(lastSnapshotHeightName(), h);
  1961. updateControls(view);
  1962. }
  1963. }
  1965. ///----------------------------------------------------------------------------
  1966. /// Class LLFloaterSnapshot
  1967. ///----------------------------------------------------------------------------
  1969. // Default constructor
  1970. LLFloaterSnapshot::LLFloaterSnapshot(const LLSD& key)
  1971. : LLFloater(key),
  1972.   impl (*(new Impl))
  1973. {
  1974. //Called from floater reg: LLUICtrlFactory::getInstance()->buildFloater(this, "floater_snapshot.xml", FALSE);
  1975. }
  1977. // Destroys the object
  1978. LLFloaterSnapshot::~LLFloaterSnapshot()
  1979. {
  1980. LLView::deleteViewByHandle(impl.mPreviewHandle);
  1982. //unfreeze everything else
  1983. gSavedSettings.setBOOL("FreezeTime", FALSE);
  1985. if (impl.mLastToolset)
  1986. {
  1987. LLToolMgr::getInstance()->setCurrentToolset(impl.mLastToolset);
  1988. }
  1990. delete &impl;
  1991. }
  1994. BOOL LLFloaterSnapshot::postBuild()
  1995. {
  1996. childSetCommitCallback("snapshot_type_radio", Impl::onCommitSnapshotType, this);
  1997. childSetCommitCallback("local_format_combo", Impl::onCommitSnapshotFormat, this);
  1999. childSetAction("new_snapshot_btn", Impl::onClickNewSnapshot, this);
  2001. childSetAction("more_btn", Impl::onClickMore, this);
  2002. childSetAction("less_btn", Impl::onClickLess, this);
  2004. childSetAction("upload_btn", Impl::onClickKeep, this);
  2005. childSetAction("send_btn", Impl::onClickKeep, this);
  2006. childSetCommitCallback("save_btn", Impl::onCommitSave, this);
  2007. childSetAction("discard_btn", Impl::onClickDiscard, this);
  2009. childSetCommitCallback("image_quality_slider", Impl::onCommitQuality, this);
  2010. childSetValue("image_quality_slider", gSavedSettings.getS32("SnapshotQuality"));
  2012. childSetCommitCallback("snapshot_width", Impl::onCommitCustomResolution, this);
  2013. childSetCommitCallback("snapshot_height", Impl::onCommitCustomResolution, this);
  2015. childSetCommitCallback("ui_check", Impl::onClickUICheck, this);
  2016. childSetValue("ui_check", gSavedSettings.getBOOL("RenderUIInSnapshot"));
  2018. childSetCommitCallback("hud_check", Impl::onClickHUDCheck, this);
  2019. childSetValue("hud_check", gSavedSettings.getBOOL("RenderHUDInSnapshot"));
  2021. childSetCommitCallback("keep_open_check", Impl::onClickKeepOpenCheck, this);
  2022. childSetValue("keep_open_check", !gSavedSettings.getBOOL("CloseSnapshotOnKeep"));
  2024. childSetCommitCallback("keep_aspect_check", Impl::onClickKeepAspectCheck, this);
  2025. childSetValue("keep_aspect_check", gSavedSettings.getBOOL("KeepAspectForSnapshot"));
  2027. childSetCommitCallback("layer_types", Impl::onCommitLayerTypes, this);
  2028. childSetValue("layer_types", "colors");
  2029. childSetEnabled("layer_types", FALSE);
  2031. childSetValue("snapshot_width", gSavedSettings.getS32(lastSnapshotWidthName()));
  2032. childSetValue("snapshot_height", gSavedSettings.getS32(lastSnapshotHeightName()));
  2034. childSetValue("freeze_frame_check", gSavedSettings.getBOOL("UseFreezeFrame"));
  2035. childSetCommitCallback("freeze_frame_check", Impl::onCommitFreezeFrame, this);
  2037. childSetValue("auto_snapshot_check", gSavedSettings.getBOOL("AutoSnapshot"));
  2038. childSetCommitCallback("auto_snapshot_check", Impl::onClickAutoSnap, this);
  2040. childSetCommitCallback("postcard_size_combo", Impl::onCommitResolution, this);
  2041. childSetCommitCallback("texture_size_combo", Impl::onCommitResolution, this);
  2042. childSetCommitCallback("local_size_combo", Impl::onCommitResolution, this);
  2044. // create preview window
  2045. LLRect full_screen_rect = getRootView()->getRect();
  2046. LLSnapshotLivePreview::Params p;
  2047. p.rect(full_screen_rect);
  2048. LLSnapshotLivePreview* previewp = new LLSnapshotLivePreview(p);
  2049. LLView* parent_view = gSnapshotFloaterView->getParent();
  2051. parent_view->removeChild(gSnapshotFloaterView);
  2052. // make sure preview is below snapshot floater
  2053. parent_view->addChild(previewp);
  2054. parent_view->addChild(gSnapshotFloaterView);
  2056. //move snapshot floater to special purpose snapshotfloaterview
  2057. gFloaterView->removeChild(this);
  2058. gSnapshotFloaterView->addChild(this);
  2060. impl.mPreviewHandle = previewp->getHandle();
  2061. impl.updateControls(this);
  2062. impl.updateLayout(this);
  2064. return TRUE;
  2065. }
  2067. void LLFloaterSnapshot::draw()
  2068. {
  2069. LLSnapshotLivePreview* previewp = impl.getPreviewView(this);
  2071. if (previewp && (previewp->isSnapshotActive() || previewp->getThumbnailLock()))
  2072. {
  2073. // don't render snapshot window in snapshot, even if "show ui" is turned on
  2074. return;
  2075. }
  2077. LLFloater::draw();
  2079. if (previewp)
  2080. {
  2081. if(previewp->getThumbnailImage())
  2082. {
  2083. LLRect thumbnail_rect = getChild<LLUICtrl>("thumbnail_placeholder")->getRect();
  2085. S32 offset_x = (getRect().getWidth() - previewp->getThumbnailWidth()) / 2 ;
  2086. S32 offset_y = thumbnail_rect.mBottom + (thumbnail_rect.getHeight() - previewp->getThumbnailHeight()) / 2 ;
  2088. glMatrixMode(GL_MODELVIEW);
  2089. gl_draw_scaled_image(offset_x, offset_y, 
  2090. previewp->getThumbnailWidth(), previewp->getThumbnailHeight(), 
  2091. previewp->getThumbnailImage(), LLColor4::white);
  2093. previewp->drawPreviewRect(offset_x, offset_y) ;
  2094. }
  2095. }
  2096. }
  2098. void LLFloaterSnapshot::onOpen(const LLSD& key)
  2099. {
  2100. LLSnapshotLivePreview* preview = LLFloaterSnapshot::Impl::getPreviewView(this);
  2101. if(preview)
  2102. {
  2103. preview->updateSnapshot(TRUE);
  2104. }
  2105. focusFirstItem(FALSE);
  2106. gSnapshotFloaterView->setEnabled(TRUE);
  2107. gSnapshotFloaterView->setVisible(TRUE);
  2108. gSnapshotFloaterView->adjustToFitScreen(this, FALSE);
  2109. }
  2111. void LLFloaterSnapshot::onClose(bool app_quitting)
  2112. {
  2113. getParent()->setMouseOpaque(FALSE);
  2114. }
  2117. //static 
  2118. void LLFloaterSnapshot::update()
  2119. {
  2120. LLFloaterSnapshot* inst = LLFloaterReg::findTypedInstance<LLFloaterSnapshot>("snapshot");
  2121. if (!inst)
  2122. return;
  2124. BOOL changed = FALSE;
  2125. for (std::set<LLSnapshotLivePreview*>::iterator iter = LLSnapshotLivePreview::sList.begin();
  2126.  iter != LLSnapshotLivePreview::sList.end(); ++iter)
  2127. {
  2128. changed |= LLSnapshotLivePreview::onIdle(*iter);
  2129. }
  2130. if(changed)
  2131. {
  2132. inst->impl.updateControls(inst);
  2133. }
  2134. }
  2137. ///----------------------------------------------------------------------------
  2138. /// Class LLSnapshotFloaterView
  2139. ///----------------------------------------------------------------------------
  2141. LLSnapshotFloaterView::LLSnapshotFloaterView (const Params& p) : LLFloaterView (p)
  2142. {
  2143. }
  2145. LLSnapshotFloaterView::~LLSnapshotFloaterView()
  2146. {
  2147. }
  2149. BOOL LLSnapshotFloaterView::handleKey(KEY key, MASK mask, BOOL called_from_parent)
  2150. {
  2151. // use default handler when not in freeze-frame mode
  2152. if(!gSavedSettings.getBOOL("FreezeTime"))
  2153. {
  2154. return LLFloaterView::handleKey(key, mask, called_from_parent);
  2155. }
  2157. if (called_from_parent)
  2158. {
  2159. // pass all keystrokes down
  2160. LLFloaterView::handleKey(key, mask, called_from_parent);
  2161. }
  2162. else
  2163. {
  2164. // bounce keystrokes back down
  2165. LLFloaterView::handleKey(key, mask, TRUE);
  2166. }
  2167. return TRUE;
  2168. }
  2170. BOOL LLSnapshotFloaterView::handleMouseDown(S32 x, S32 y, MASK mask)
  2171. {
  2172. // use default handler when not in freeze-frame mode
  2173. if(!gSavedSettings.getBOOL("FreezeTime"))
  2174. {
  2175. return LLFloaterView::handleMouseDown(x, y, mask);
  2176. }
  2177. // give floater a change to handle mouse, else camera tool
  2178. if (childrenHandleMouseDown(x, y, mask) == NULL)
  2179. {
  2180. LLToolMgr::getInstance()->getCurrentTool()->handleMouseDown( x, y, mask );
  2181. }
  2182. return TRUE;
  2183. }
  2185. BOOL LLSnapshotFloaterView::handleMouseUp(S32 x, S32 y, MASK mask)
  2186. {
  2187. // use default handler when not in freeze-frame mode
  2188. if(!gSavedSettings.getBOOL("FreezeTime"))
  2189. {
  2190. return LLFloaterView::handleMouseUp(x, y, mask);
  2191. }
  2192. // give floater a change to handle mouse, else camera tool
  2193. if (childrenHandleMouseUp(x, y, mask) == NULL)
  2194. {
  2195. LLToolMgr::getInstance()->getCurrentTool()->handleMouseUp( x, y, mask );
  2196. }
  2197. return TRUE;
  2198. }
  2200. BOOL LLSnapshotFloaterView::handleHover(S32 x, S32 y, MASK mask)
  2201. {
  2202. // use default handler when not in freeze-frame mode
  2203. if(!gSavedSettings.getBOOL("FreezeTime"))
  2204. {
  2205. return LLFloaterView::handleHover(x, y, mask);
  2206. }
  2207. // give floater a change to handle mouse, else camera tool
  2208. if (childrenHandleHover(x, y, mask) == NULL)
  2209. {
  2210. LLToolMgr::getInstance()->getCurrentTool()->handleHover( x, y, mask );
  2211. }
  2212. return TRUE;
  2213. }