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

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

游戏引擎

开发平台：

C++ Builder

llfloatercolorpicker.cpp：源码内容
  1. /** 
  2.  * @file llfloatercolorpicker.cpp
  3.  * @brief Generic system color picker
  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 "llfloatercolorpicker.h"
  37. // Viewer project includes
  38. #include "lltoolmgr.h"
  39. #include "lltoolpipette.h"
  40. #include "llviewercontrol.h"
  41. #include "llworld.h"
  43. // Linden library includes
  44. #include "llfontgl.h"
  45. #include "llsys.h"
  46. #include "llgl.h"
  47. #include "llrender.h"
  48. #include "v3dmath.h"
  49. #include "lldir.h"
  50. #include "llui.h"
  51. #include "lllineeditor.h"
  52. #include "v4coloru.h"
  53. #include "llbutton.h"
  54. #include "lluictrlfactory.h"
  55. #include "llgl.h"
  56. #include "llpointer.h"
  57. #include "llimage.h"
  58. #include "llmousehandler.h"
  59. #include "llglheaders.h"
  60. #include "llcheckboxctrl.h"
  61. #include "lltextbox.h"
  62. #include "lluiconstants.h"
  63. #include "llfocusmgr.h"
  64. #include "lldraghandle.h"
  65. #include "llwindow.h"
  67. // System includes
  68. #include <sstream>
  69. #include <iomanip>
  71. const F32 CONTEXT_CONE_IN_ALPHA = 0.0f;
  72. const F32 CONTEXT_CONE_OUT_ALPHA = 1.f;
  73. const F32 CONTEXT_FADE_TIME = 0.08f;
  75. //////////////////////////////////////////////////////////////////////////////
  76. //
  77. // Class LLFloaterColorPicker
  78. //
  79. //////////////////////////////////////////////////////////////////////////////
  81. LLFloaterColorPicker::LLFloaterColorPicker (LLColorSwatchCtrl* swatch, BOOL show_apply_immediate )
  82. : LLFloater(LLSD()),
  83.   mComponents ( 3 ),
  84.   mMouseDownInLumRegion ( FALSE ),
  85.   mMouseDownInHueRegion ( FALSE ),
  86.   mMouseDownInSwatch ( FALSE ),
  87.   // *TODO: Specify this in XML
  88.   mRGBViewerImageLeft ( 140 ),
  89.   mRGBViewerImageTop ( 356 ),
  90.   mRGBViewerImageWidth ( 256 ),
  91.   mRGBViewerImageHeight ( 256 ),
  92.   mLumRegionLeft ( mRGBViewerImageLeft + mRGBViewerImageWidth + 16 ),
  93.   mLumRegionTop ( mRGBViewerImageTop ),
  94.   mLumRegionWidth ( 16 ),
  95.   mLumRegionHeight ( mRGBViewerImageHeight ),
  96.   mLumMarkerSize ( 6 ),
  97.   // *TODO: Specify this in XML
  98.   mSwatchRegionLeft ( 12 ),
  99.   mSwatchRegionTop ( 190 ),
  100.   mSwatchRegionWidth ( 116 ),
  101.   mSwatchRegionHeight ( 60 ),
  102.   mSwatchView ( NULL ),
  103.   // *TODO: Specify this in XML
  104.   numPaletteColumns ( 16 ),
  105.   numPaletteRows ( 2 ),
  106.   highlightEntry ( -1 ),
  107.   mPaletteRegionLeft ( 11 ),
  108.   mPaletteRegionTop ( 100 - 8 ),
  109.   mPaletteRegionWidth ( mLumRegionLeft + mLumRegionWidth - 10 ),
  110.   mPaletteRegionHeight ( 40 ),
  111.   mSwatch ( swatch ),
  112.   mActive ( TRUE ),
  113.   mCanApplyImmediately ( show_apply_immediate ),
  114.   mContextConeOpacity ( 0.f )
  115. {
  116. // build the majority of the gui using the factory builder
  117. LLUICtrlFactory::getInstance()->buildFloater ( this, "floater_color_picker.xml", NULL );
  119. // create user interface for this picker
  120. createUI ();
  122. if (!mCanApplyImmediately)
  123. {
  124. mApplyImmediateCheck->setEnabled(FALSE);
  125. mApplyImmediateCheck->set(FALSE);
  126. }
  127. }
  129. LLFloaterColorPicker::~LLFloaterColorPicker()
  130. {
  131. // destroy the UI we created
  132. destroyUI ();
  133. }
  135. //////////////////////////////////////////////////////////////////////////////
  136. //
  137. void LLFloaterColorPicker::createUI ()
  138. {
  139. // create RGB type area (not really RGB but it's got R,G & B in it.,..
  141. LLPointer<LLImageRaw> raw = new LLImageRaw ( mRGBViewerImageWidth, mRGBViewerImageHeight, mComponents );
  142. U8* bits = raw->getData();
  143. S32 linesize = mRGBViewerImageWidth * mComponents;
  144. for ( S32 y = 0; y < mRGBViewerImageHeight; ++y )
  145. {
  146. for ( S32 x = 0; x < linesize; x += mComponents )
  147. {
  148. F32 rVal, gVal, bVal;
  150. hslToRgb ( (F32)x / (F32) ( linesize - 1 ),
  151.    (F32)y / (F32) ( mRGBViewerImageHeight - 1 ),
  152.    0.5f,
  153.    rVal,
  154.    gVal,
  155.    bVal );
  157. * ( bits + x + y * linesize + 0 ) = ( U8 )( rVal * 255.0f );
  158. * ( bits + x + y * linesize + 1 ) = ( U8 )( gVal * 255.0f );
  159. * ( bits + x + y * linesize + 2 ) = ( U8 )( bVal * 255.0f );
  160. }
  161. }
  162. mRGBImage = LLViewerTextureManager::getLocalTexture( (LLImageRaw*)raw, FALSE );
  163. gGL.getTexUnit(0)->bind(mRGBImage);
  164. mRGBImage->setAddressMode(LLTexUnit::TAM_CLAMP);
  166. // create palette
  167. for ( S32 each = 0; each < numPaletteColumns * numPaletteRows; ++each )
  168. {
  169. std::ostringstream codec;
  170. codec << "ColorPaletteEntry" << std::setfill ( '0' ) << std::setw ( 2 ) << each + 1;
  172. // argh!
  173. const std::string s ( codec.str () );
  174. mPalette.push_back ( new LLColor4 ( LLUIColorTable::instance().getColor ( s )  ) );
  175. }
  176. }
  178. //////////////////////////////////////////////////////////////////////////////
  179. //
  180. void LLFloaterColorPicker::showUI ()
  181. {
  182. setVisible ( TRUE );
  183. setFocus ( TRUE );
  184. openFloater(getKey());
  186. // HACK: if system color picker is required - close the SL one we made and use default system dialog
  187. if ( gSavedSettings.getBOOL ( "UseDefaultColorPicker" ) )
  188. {
  189. LLColorSwatchCtrl* swatch = getSwatch ();
  191. setVisible ( FALSE );
  193. // code that will get switched in for default system color picker
  194. if ( swatch )
  195. {
  196. LLColor4 curCol = swatch->get ();
  197. send_agent_pause();
  198. getWindow()->dialogColorPicker( &curCol [ 0 ], &curCol [ 1 ], &curCol [ 2 ] );
  199. send_agent_resume();
  201. setOrigRgb ( curCol [ 0 ], curCol [ 1 ], curCol [ 2 ] );
  202. setCurRgb( curCol [ 0 ], curCol [ 1 ], curCol [ 2 ] );
  204. LLColorSwatchCtrl::onColorChanged ( swatch, LLColorSwatchCtrl::COLOR_CHANGE );
  205. }
  207. closeFloater();
  208. }
  209. }
  211. //////////////////////////////////////////////////////////////////////////////
  212. // called after the dialog is rendered
  213. BOOL LLFloaterColorPicker::postBuild()
  214. {
  215. mCancelBtn = getChild<LLButton>( "cancel_btn" );
  216.     mCancelBtn->setClickedCallback ( onClickCancel, this );
  218. mSelectBtn = getChild<LLButton>( "select_btn");
  219.     mSelectBtn->setClickedCallback ( onClickSelect, this );
  220. mSelectBtn->setFocus ( TRUE );
  222. mPipetteBtn = getChild<LLButton>("color_pipette" );
  224. mPipetteBtn->setImages(std::string("eye_button_inactive.tga"), std::string("eye_button_active.tga"));
  226. mPipetteBtn->setCommitCallback( boost::bind(&LLFloaterColorPicker::onClickPipette, this ));
  228. mApplyImmediateCheck = getChild<LLCheckBoxCtrl>("apply_immediate");
  229. mApplyImmediateCheck->set(gSavedSettings.getBOOL("ApplyColorImmediately"));
  230. mApplyImmediateCheck->setCommitCallback(onImmediateCheck, this);
  232. childSetCommitCallback("rspin", onTextCommit, (void*)this );
  233. childSetCommitCallback("gspin", onTextCommit, (void*)this );
  234. childSetCommitCallback("bspin", onTextCommit, (void*)this );
  235. childSetCommitCallback("hspin", onTextCommit, (void*)this );
  236. childSetCommitCallback("sspin", onTextCommit, (void*)this );
  237. childSetCommitCallback("lspin", onTextCommit, (void*)this );
  239. LLToolPipette::getInstance()->setToolSelectCallback(boost::bind(&LLFloaterColorPicker::onColorSelect, this, _1));
  241.     return TRUE;
  242. }
  244. //////////////////////////////////////////////////////////////////////////////
  245. //
  246. void LLFloaterColorPicker::initUI ( F32 rValIn, F32 gValIn, F32 bValIn )
  247. {
  248. // under some circumstances, we get rogue values that can be calmed by clamping...
  249. rValIn = llclamp ( rValIn, 0.0f, 1.0f );
  250. gValIn = llclamp ( gValIn, 0.0f, 1.0f );
  251. bValIn = llclamp ( bValIn, 0.0f, 1.0f );
  253. // store initial value in case cancel or revert is selected
  254. setOrigRgb ( rValIn, gValIn, bValIn );
  256. // starting point for current value to
  257. setCurRgb ( rValIn, gValIn, bValIn );
  259. // unpdate text entry fields
  260. updateTextEntry ();
  261. }
  263. //////////////////////////////////////////////////////////////////////////////
  264. //
  265. void LLFloaterColorPicker::destroyUI ()
  266. {
  267. // shut down pipette tool if active
  268. stopUsingPipette();
  270. // delete palette we created
  271. std::vector < LLColor4* >::iterator iter = mPalette.begin ();
  272. while ( iter != mPalette.end () )
  273. {
  274. delete ( *iter );
  275. ++iter;
  276. }
  278. if ( mSwatchView )
  279. {
  280. this->removeChild ( mSwatchView );
  281. delete mSwatchView;
  282. mSwatchView = NULL;
  283. }
  284. }
  287. //////////////////////////////////////////////////////////////////////////////
  288. //
  289. F32 LLFloaterColorPicker::hueToRgb ( F32 val1In, F32 val2In, F32 valHUeIn )
  290. {
  291. if ( valHUeIn < 0.0f ) valHUeIn += 1.0f;
  292. if ( valHUeIn > 1.0f ) valHUeIn -= 1.0f;
  293. if ( ( 6.0f * valHUeIn ) < 1.0f ) return ( val1In + ( val2In - val1In ) * 6.0f * valHUeIn );
  294. if ( ( 2.0f * valHUeIn ) < 1.0f ) return ( val2In );
  295. if ( ( 3.0f * valHUeIn ) < 2.0f ) return ( val1In + ( val2In - val1In ) * ( ( 2.0f / 3.0f ) - valHUeIn ) * 6.0f );
  296. return ( val1In );
  297. }
  299. //////////////////////////////////////////////////////////////////////////////
  300. //
  301. void LLFloaterColorPicker::hslToRgb ( F32 hValIn, F32 sValIn, F32 lValIn, F32& rValOut, F32& gValOut, F32& bValOut )
  302. {
  303. if ( sValIn < 0.00001f )
  304. {
  305. rValOut = lValIn;
  306. gValOut = lValIn;
  307. bValOut = lValIn;
  308. }
  309. else
  310. {
  311. F32 interVal1;
  312. F32 interVal2;
  314. if ( lValIn < 0.5f )
  315. interVal2 = lValIn * ( 1.0f + sValIn );
  316. else
  317. interVal2 = ( lValIn + sValIn ) - ( sValIn * lValIn );
  319. interVal1 = 2.0f * lValIn - interVal2;
  321. rValOut = hueToRgb ( interVal1, interVal2, hValIn + ( 1.f / 3.f ) );
  322. gValOut = hueToRgb ( interVal1, interVal2, hValIn );
  323. bValOut = hueToRgb ( interVal1, interVal2, hValIn - ( 1.f / 3.f ) );
  324. }
  325. }
  327. //////////////////////////////////////////////////////////////////////////////
  328. // mutator for original RGB value
  329. void LLFloaterColorPicker::setOrigRgb ( F32 origRIn, F32 origGIn, F32 origBIn )
  330. {
  331. origR = origRIn;
  332. origG = origGIn;
  333. origB = origBIn;
  334. }
  336. //////////////////////////////////////////////////////////////////////////////
  337. // accessor for original RGB value
  338. void LLFloaterColorPicker::getOrigRgb ( F32& origROut, F32& origGOut, F32& origBOut )
  339. {
  340. origROut = origR;
  341. origGOut = origG;
  342. origBOut = origB;
  343. }
  345. //////////////////////////////////////////////////////////////////////////////
  346. // mutator for current RGB value
  347. void LLFloaterColorPicker::setCurRgb ( F32 curRIn, F32 curGIn, F32 curBIn )
  348. {
  349. // save current RGB
  350. curR = curRIn;
  351. curG = curGIn;
  352. curB = curBIn;
  354. // update corresponding HSL values and
  355. LLColor3(curRIn, curGIn, curBIn).calcHSL(&curH, &curS, &curL);
  357. // color changed so update text fields
  358.     updateTextEntry();
  359. }
  361. //////////////////////////////////////////////////////////////////////////////
  362. // accessor for current RGB value
  363. void LLFloaterColorPicker::getCurRgb ( F32& curROut, F32& curGOut, F32& curBOut )
  364. {
  365. curROut = curR;
  366. curGOut = curG;
  367. curBOut = curB;
  368. }
  370. //////////////////////////////////////////////////////////////////////////////
  371. // mutator for current HSL value
  372. void LLFloaterColorPicker::setCurHsl ( F32 curHIn, F32 curSIn, F32 curLIn )
  373. {
  374. // save current HSL
  375. curH = curHIn;
  376. curS = curSIn;
  377. curL = curLIn;
  379. // update corresponding RGB values and
  380. hslToRgb ( curH, curS, curL, curR, curG, curB );
  381. }
  383. //////////////////////////////////////////////////////////////////////////////
  384. // accessor for current HSL value
  385. void LLFloaterColorPicker::getCurHsl ( F32& curHOut, F32& curSOut, F32& curLOut )
  386. {
  387. curHOut = curH;
  388. curSOut = curS;
  389. curLOut = curL;
  390. }
  392. //////////////////////////////////////////////////////////////////////////////
  393. // called when 'cancel' clicked
  394. void LLFloaterColorPicker::onClickCancel ( void* data )
  395. {
  396. if (data)
  397. {
  398. LLFloaterColorPicker* self = ( LLFloaterColorPicker* )data;
  400. if ( self )
  401. {
  402. self->cancelSelection ();
  403. self->closeFloater();
  404. }
  405. }
  406. }
  408. //////////////////////////////////////////////////////////////////////////////
  409. // called when 'select' clicked
  410. void LLFloaterColorPicker::onClickSelect ( void* data )
  411. {
  412. if (data)
  413. {
  414. LLFloaterColorPicker* self = ( LLFloaterColorPicker* )data;
  416. if ( self )
  417. {
  418. // apply to selection
  419. LLColorSwatchCtrl::onColorChanged ( self->getSwatch (), LLColorSwatchCtrl::COLOR_SELECT );
  420. self->closeFloater();
  421. }
  422. }
  423. }
  425. void LLFloaterColorPicker::onClickPipette( )
  426. {
  427. BOOL pipette_active = mPipetteBtn->getToggleState();
  428. pipette_active = !pipette_active;
  429. if (pipette_active)
  430. {
  431. LLToolMgr::getInstance()->setTransientTool(LLToolPipette::getInstance());
  432. }
  433. else
  434. {
  435. LLToolMgr::getInstance()->clearTransientTool();
  436. }
  437. }
  439. //////////////////////////////////////////////////////////////////////////////
  440. // called when 'text is committed' - i,e. focus moves from a text field
  441. void LLFloaterColorPicker::onTextCommit ( LLUICtrl* ctrl, void* data )
  442. {
  443. if ( data )
  444. {
  445. LLFloaterColorPicker* self = ( LLFloaterColorPicker* )data;
  446. if ( self )
  447. {
  448. self->onTextEntryChanged ( ctrl );
  449. }
  450. }
  451. }
  453. void LLFloaterColorPicker::onImmediateCheck( LLUICtrl* ctrl, void* data)
  454. {
  455. LLFloaterColorPicker* self = ( LLFloaterColorPicker* )data;
  456. if (self)
  457. {
  458. gSavedSettings.setBOOL("ApplyColorImmediately", self->mApplyImmediateCheck->get());
  460. if (self->mApplyImmediateCheck->get())
  461. {
  462. LLColorSwatchCtrl::onColorChanged ( self->getSwatch (), LLColorSwatchCtrl::COLOR_CHANGE );
  463. }
  464. }
  465. }
  467. void LLFloaterColorPicker::onColorSelect( const LLTextureEntry& te )
  468. {
  469. setCurRgb(te.getColor().mV[VRED], te.getColor().mV[VGREEN], te.getColor().mV[VBLUE]);
  470. if (mApplyImmediateCheck->get())
  471. {
  472. LLColorSwatchCtrl::onColorChanged ( getSwatch (), LLColorSwatchCtrl::COLOR_CHANGE );
  473. }
  474. }
  476. void LLFloaterColorPicker::onMouseCaptureLost()
  477. {
  478. setMouseDownInHueRegion(FALSE);
  479. setMouseDownInLumRegion(FALSE);
  480. }
  482. //////////////////////////////////////////////////////////////////////////////
  483. //
  484. void LLFloaterColorPicker::draw()
  485. {
  486. LLRect swatch_rect;
  487. mSwatch->localRectToOtherView(mSwatch->getLocalRect(), &swatch_rect, this);
  488. // draw context cone connecting color picker with color swatch in parent floater
  489. LLRect local_rect = getLocalRect();
  490. if (gFocusMgr.childHasKeyboardFocus(this) && mSwatch->isInVisibleChain() && mContextConeOpacity > 0.001f)
  491. {
  492. gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
  493. LLGLEnable(GL_CULL_FACE);
  494. gGL.begin(LLRender::QUADS);
  495. {
  496. gGL.color4f(0.f, 0.f, 0.f, CONTEXT_CONE_IN_ALPHA * mContextConeOpacity);
  497. gGL.vertex2i(swatch_rect.mLeft, swatch_rect.mTop);
  498. gGL.vertex2i(swatch_rect.mRight, swatch_rect.mTop);
  499. gGL.color4f(0.f, 0.f, 0.f, CONTEXT_CONE_OUT_ALPHA * mContextConeOpacity);
  500. gGL.vertex2i(local_rect.mRight, local_rect.mTop);
  501. gGL.vertex2i(local_rect.mLeft, local_rect.mTop);
  503. gGL.color4f(0.f, 0.f, 0.f, CONTEXT_CONE_OUT_ALPHA * mContextConeOpacity);
  504. gGL.vertex2i(local_rect.mLeft, local_rect.mTop);
  505. gGL.vertex2i(local_rect.mLeft, local_rect.mBottom);
  506. gGL.color4f(0.f, 0.f, 0.f, CONTEXT_CONE_IN_ALPHA * mContextConeOpacity);
  507. gGL.vertex2i(swatch_rect.mLeft, swatch_rect.mBottom);
  508. gGL.vertex2i(swatch_rect.mLeft, swatch_rect.mTop);
  510. gGL.color4f(0.f, 0.f, 0.f, CONTEXT_CONE_OUT_ALPHA * mContextConeOpacity);
  511. gGL.vertex2i(local_rect.mRight, local_rect.mBottom);
  512. gGL.vertex2i(local_rect.mRight, local_rect.mTop);
  513. gGL.color4f(0.f, 0.f, 0.f, CONTEXT_CONE_IN_ALPHA * mContextConeOpacity);
  514. gGL.vertex2i(swatch_rect.mRight, swatch_rect.mTop);
  515. gGL.vertex2i(swatch_rect.mRight, swatch_rect.mBottom);
  517. gGL.color4f(0.f, 0.f, 0.f, CONTEXT_CONE_OUT_ALPHA * mContextConeOpacity);
  518. gGL.vertex2i(local_rect.mLeft, local_rect.mBottom);
  519. gGL.vertex2i(local_rect.mRight, local_rect.mBottom);
  520. gGL.color4f(0.f, 0.f, 0.f, CONTEXT_CONE_IN_ALPHA * mContextConeOpacity);
  521. gGL.vertex2i(swatch_rect.mRight, swatch_rect.mBottom);
  522. gGL.vertex2i(swatch_rect.mLeft, swatch_rect.mBottom);
  523. }
  524. gGL.end();
  525. }
  527. if (gFocusMgr.childHasMouseCapture(getDragHandle()))
  528. {
  529. mContextConeOpacity = lerp(mContextConeOpacity, gSavedSettings.getF32("PickerContextOpacity"), LLCriticalDamp::getInterpolant(CONTEXT_FADE_TIME));
  530. }
  531. else
  532. {
  533. mContextConeOpacity = lerp(mContextConeOpacity, 0.f, LLCriticalDamp::getInterpolant(CONTEXT_FADE_TIME));
  534. }
  536. mPipetteBtn->setToggleState(LLToolMgr::getInstance()->getCurrentTool() == LLToolPipette::getInstance());
  537. mApplyImmediateCheck->setEnabled(mActive && mCanApplyImmediately);
  538. mSelectBtn->setEnabled(mActive);
  540. // base floater stuff
  541. LLFloater::draw ();
  543. // draw image for RGB area (not really RGB but you'll see what I mean...
  544. gl_draw_image ( mRGBViewerImageLeft, mRGBViewerImageTop - mRGBViewerImageHeight, mRGBImage, LLColor4::white );
  546. // update 'cursor' into RGB Section
  547. S32 xPos = ( S32 ) ( ( F32 )mRGBViewerImageWidth * getCurH () ) - 8;
  548. S32 yPos = ( S32 ) ( ( F32 )mRGBViewerImageHeight * getCurS () ) - 8;
  549. gl_line_2d ( mRGBViewerImageLeft + xPos,
  550.  mRGBViewerImageTop - mRGBViewerImageHeight + yPos + 8,
  551.  mRGBViewerImageLeft + xPos + 16,
  552.  mRGBViewerImageTop - mRGBViewerImageHeight + yPos + 8,
  553.  LLColor4 ( 0.0f, 0.0f, 0.0f, 1.0f ) );
  555. gl_line_2d ( mRGBViewerImageLeft + xPos + 8,
  556.  mRGBViewerImageTop - mRGBViewerImageHeight + yPos,
  557.  mRGBViewerImageLeft + xPos + 8,
  558.  mRGBViewerImageTop - mRGBViewerImageHeight + yPos + 16,
  559.  LLColor4 ( 0.0f, 0.0f, 0.0f, 1.0f ) );
  561. // create rgb area outline
  562. gl_rect_2d ( mRGBViewerImageLeft,
  563.  mRGBViewerImageTop - mRGBViewerImageHeight,
  564.  mRGBViewerImageLeft + mRGBViewerImageWidth + 1,
  565.  mRGBViewerImageTop,
  566.  LLColor4 ( 0.0f, 0.0f, 0.0f, 1.0f ),
  567.  FALSE );
  569. // draw luminance slider
  570. for ( S32 y = 0; y < mLumRegionHeight; ++y )
  571. {
  572. F32 rValSlider, gValSlider, bValSlider;
  573. hslToRgb ( getCurH (), getCurS (), ( F32 )y / ( F32 )mLumRegionHeight, rValSlider, gValSlider, bValSlider );
  575. gl_rect_2d( mLumRegionLeft, 
  576. mLumRegionTop - mLumRegionHeight + y, 
  577. mLumRegionLeft + mLumRegionWidth, 
  578. mLumRegionTop - mLumRegionHeight + y - 1, 
  579. LLColor4 ( rValSlider, gValSlider, bValSlider, 1.0f ) );
  580. }
  583. // draw luninance marker
  584. S32 startX = mLumRegionLeft + mLumRegionWidth;
  585. S32 startY = mLumRegionTop - mLumRegionHeight + ( S32 ) ( mLumRegionHeight * getCurL () );
  586. gl_triangle_2d ( startX, startY,
  587. startX + mLumMarkerSize, startY - mLumMarkerSize,
  588. startX + mLumMarkerSize, startY + mLumMarkerSize,
  589. LLColor4 ( 0.75f, 0.75f, 0.75f, 1.0f ), TRUE );
  591. // draw luminance slider outline
  592. gl_rect_2d ( mLumRegionLeft,
  593.  mLumRegionTop - mLumRegionHeight,
  594.  mLumRegionLeft + mLumRegionWidth + 1,
  595.  mLumRegionTop,
  596.  LLColor4 ( 0.0f, 0.0f, 0.0f, 1.0f ),
  597.  FALSE );
  599. // draw selected color swatch
  600. gl_rect_2d ( mSwatchRegionLeft,
  601.  mSwatchRegionTop - mSwatchRegionHeight,
  602.  mSwatchRegionLeft + mSwatchRegionWidth,
  603.  mSwatchRegionTop,
  604.  LLColor4 ( getCurR (), getCurG (), getCurB (), 1.0f ),
  605.  TRUE );
  607. // draw selected color swatch outline
  608. gl_rect_2d ( mSwatchRegionLeft,
  609.  mSwatchRegionTop - mSwatchRegionHeight,
  610.  mSwatchRegionLeft + mSwatchRegionWidth + 1,
  611.  mSwatchRegionTop,
  612.  LLColor4 ( 0.0f, 0.0f, 0.0f, 1.0f ),
  613.  FALSE );
  615. // color palette code is a little more involved so break it out into its' own method
  616. drawPalette ();
  617. }
  619. //////////////////////////////////////////////////////////////////////////////
  620. // find a complimentary color to the one passed in that can be used to highlight
  621. const LLColor4& LLFloaterColorPicker::getComplimentaryColor ( const LLColor4& backgroundColor )
  622. {
  623. // going to base calculation on luminance
  624. F32 hVal, sVal, lVal;
  625. backgroundColor.calcHSL(&hVal, &sVal, &lVal);
  626. hVal *= 360.f;
  627. sVal *= 100.f;
  628. lVal *= 100.f;
  630. // fairly simple heuristic for now...!
  631. if ( lVal < 0.5f )
  632. {
  633. return LLColor4::white;
  634. }
  636. return LLColor4::black;
  637. }
  639. //////////////////////////////////////////////////////////////////////////////
  640. // draw color palette
  641. void LLFloaterColorPicker::drawPalette ()
  642. {
  643. S32 curEntry = 0;
  645. for ( S32 y = 0; y < numPaletteRows; ++y )
  646. {
  647. for ( S32 x = 0; x < numPaletteColumns; ++x )
  648. {
  649. // calculate position
  650. S32 x1 = mPaletteRegionLeft + ( mPaletteRegionWidth * x ) / numPaletteColumns;
  651. S32 y1 = mPaletteRegionTop - ( mPaletteRegionHeight * y ) / numPaletteRows;
  652. S32 x2 = ( mPaletteRegionLeft + ( mPaletteRegionWidth * ( x + 1 ) ) / numPaletteColumns );
  653. S32 y2 = ( mPaletteRegionTop - ( mPaletteRegionHeight * ( y + 1 ) ) / numPaletteRows );
  655. // draw palette entry color
  656. if ( mPalette [ curEntry ] )
  657. {
  658. gl_rect_2d ( x1 + 2, y1 - 2, x2 - 2, y2 + 2, *mPalette [ curEntry++ ], TRUE );
  659. gl_rect_2d ( x1 + 1, y1 - 1, x2 - 1, y2 + 1, LLColor4 ( 0.0f, 0.0f, 0.0f, 1.0f ), FALSE );
  660. }
  661. }
  662. }
  664. // if there is something to highlight (mouse down in swatch & hovering over palette)
  665. if ( highlightEntry >= 0 )
  666. {
  667. // extract row/column from palette index
  668. S32 entryColumn = highlightEntry % numPaletteColumns;
  669. S32 entryRow = highlightEntry / numPaletteColumns;
  671. // calculate position of this entry
  672. S32 x1 = mPaletteRegionLeft + ( mPaletteRegionWidth * entryColumn ) / numPaletteColumns;
  673. S32 y1 = mPaletteRegionTop - ( mPaletteRegionHeight * entryRow ) / numPaletteRows;
  674. S32 x2 = ( mPaletteRegionLeft + ( mPaletteRegionWidth * ( entryColumn + 1 ) ) / numPaletteColumns );
  675. S32 y2 = ( mPaletteRegionTop - ( mPaletteRegionHeight * ( entryRow + 1 ) ) / numPaletteRows );
  677. // center position of entry
  678. S32 xCenter = x1 + ( x2 - x1 ) / 2;
  679. S32 yCenter = y1 - ( y1 - y2 ) / 2;
  681. // find a color that works well as a highlight color
  682. LLColor4 hlColor ( getComplimentaryColor ( *mPalette [ highlightEntry ] ) );
  684. // mark a cross for entry that is being hovered
  685. gl_line_2d ( xCenter - 4, yCenter - 4, xCenter + 4, yCenter + 4, hlColor );
  686. gl_line_2d ( xCenter + 4, yCenter - 4, xCenter - 4, yCenter + 4, hlColor );
  687. }
  688. }
  690. //////////////////////////////////////////////////////////////////////////////
  691. // update text entry values for RGB/HSL (can't be done in ::draw () since this overwrites input
  692. void LLFloaterColorPicker::updateTextEntry ()
  693. {
  694. // set values in spinners
  695. childSetValue("rspin", ( getCurR () * 255.0f ) );
  696. childSetValue("gspin", ( getCurG () * 255.0f ) );
  697. childSetValue("bspin", ( getCurB () * 255.0f ) );
  698. childSetValue("hspin", ( getCurH () * 360.0f ) );
  699. childSetValue("sspin", ( getCurS () * 100.0f ) );
  700. childSetValue("lspin", ( getCurL () * 100.0f ) );
  701. }
  703. //////////////////////////////////////////////////////////////////////////////
  704. //
  705. void LLFloaterColorPicker::onTextEntryChanged ( LLUICtrl* ctrl )
  706. {
  707. // value in RGB boxes changed
  708. std::string name = ctrl->getName();
  709. if ( ( name == "rspin" ) || ( name == "gspin" ) || ( name == "bspin" ) )
  710. {
  711. // get current RGB
  712. F32 rVal, gVal, bVal;
  713. getCurRgb ( rVal, gVal, bVal );
  715. // update component value with new value from text
  716. if ( name == "rspin" )
  717. {
  718. rVal = (F32)ctrl->getValue().asReal() / 255.0f;
  719. }
  720. else
  721. if ( name == "gspin" )
  722. {
  723. gVal = (F32)ctrl->getValue().asReal() / 255.0f;
  724. }
  725. else
  726. if ( name == "bspin" )
  727. {
  728. bVal = (F32)ctrl->getValue().asReal() / 255.0f;
  729. }
  731. // update current RGB (and implicitly HSL)
  732. setCurRgb ( rVal, gVal, bVal );
  734. updateTextEntry ();
  735. }
  736. else
  737. // value in HSL boxes changed
  738. if ( ( name == "hspin" ) || ( name == "sspin" ) || ( name == "lspin" ) )
  739. {
  740. // get current HSL
  741. F32 hVal, sVal, lVal;
  742. getCurHsl ( hVal, sVal, lVal );
  744. // update component value with new value from text
  745. if ( name == "hspin" )
  746. hVal = (F32)ctrl->getValue().asReal() / 360.0f;
  747. else
  748. if ( name == "sspin" )
  749. sVal = (F32)ctrl->getValue().asReal() / 100.0f;
  750. else
  751. if ( name == "lspin" )
  752. lVal = (F32)ctrl->getValue().asReal() / 100.0f;
  754. // update current HSL (and implicitly RGB)
  755. setCurHsl ( hVal, sVal, lVal );
  757. updateTextEntry ();
  758. }
  760. if (mApplyImmediateCheck->get())
  761. {
  762. LLColorSwatchCtrl::onColorChanged ( getSwatch (), LLColorSwatchCtrl::COLOR_CHANGE );
  763. }
  764. }
  766. //////////////////////////////////////////////////////////////////////////////
  767. //
  768. BOOL LLFloaterColorPicker::updateRgbHslFromPoint ( S32 xPosIn, S32 yPosIn )
  769. {
  770. if ( xPosIn >= mRGBViewerImageLeft &&
  771.  xPosIn <= mRGBViewerImageLeft + mRGBViewerImageWidth &&
  772.  yPosIn <= mRGBViewerImageTop &&
  773.  yPosIn >= mRGBViewerImageTop - mRGBViewerImageHeight )
  774. {
  775. // update HSL (and therefore RGB) based on new H & S and current L
  776. setCurHsl ( ( ( F32 )xPosIn - ( F32 )mRGBViewerImageLeft ) / ( F32 )mRGBViewerImageWidth,
  777. ( ( F32 )yPosIn - ( ( F32 )mRGBViewerImageTop - ( F32 )mRGBViewerImageHeight ) ) / ( F32 )mRGBViewerImageHeight,
  778. getCurL () );
  780. // indicate a value changed
  781. return TRUE;
  782. }
  783. else
  784. if ( xPosIn >= mLumRegionLeft &&
  785.  xPosIn <= mLumRegionLeft + mLumRegionWidth &&
  786.  yPosIn <= mLumRegionTop &&
  787.  yPosIn >= mLumRegionTop - mLumRegionHeight )
  788. {
  790. // update HSL (and therefore RGB) based on current HS and new L
  791.  setCurHsl ( getCurH (),
  792.  getCurS (),
  793. ( ( F32 )yPosIn - ( ( F32 )mRGBViewerImageTop - ( F32 )mRGBViewerImageHeight ) ) / ( F32 )mRGBViewerImageHeight );
  795. // indicate a value changed
  796. return TRUE;
  797. }
  799. return FALSE;
  800. }
  802. //////////////////////////////////////////////////////////////////////////////
  803. //
  804. BOOL LLFloaterColorPicker::handleMouseDown ( S32 x, S32 y, MASK mask )
  805. {
  806. // make it the frontmost
  807. gFloaterView->bringToFront(this);
  809. // rect containing RGB area
  810. LLRect rgbAreaRect ( mRGBViewerImageLeft,
  811.  mRGBViewerImageTop,
  812.  mRGBViewerImageLeft + mRGBViewerImageWidth,
  813.  mRGBViewerImageTop - mRGBViewerImageHeight );
  815. if ( rgbAreaRect.pointInRect ( x, y ) )
  816. {
  817. gFocusMgr.setMouseCapture(this);
  818. // mouse button down
  819. setMouseDownInHueRegion ( TRUE );
  821. // update all values based on initial click
  822. updateRgbHslFromPoint ( x, y );
  824. // required by base class
  825. return TRUE;
  826. }
  828. // rect containing RGB area
  829. LLRect lumAreaRect ( mLumRegionLeft,
  830.  mLumRegionTop,
  831.  mLumRegionLeft + mLumRegionWidth + mLumMarkerSize,
  832.  mLumRegionTop - mLumRegionHeight );
  834. if ( lumAreaRect.pointInRect ( x, y ) )
  835. {
  836. gFocusMgr.setMouseCapture(this);
  837. // mouse button down
  838. setMouseDownInLumRegion ( TRUE );
  840. // required by base class
  841. return TRUE;
  842. }
  844. // rect containing swatch area
  845. LLRect swatchRect ( mSwatchRegionLeft,
  846. mSwatchRegionTop,
  847. mSwatchRegionLeft + mSwatchRegionWidth,
  848. mSwatchRegionTop - mSwatchRegionHeight );
  850. setMouseDownInSwatch( FALSE );
  851. if ( swatchRect.pointInRect ( x, y ) )
  852. {
  853. setMouseDownInSwatch( TRUE );
  855. // required - dont drag windows here.
  856. return TRUE;
  857. }
  859. // rect containing palette area
  860. LLRect paletteRect ( mPaletteRegionLeft,
  861.  mPaletteRegionTop,
  862.  mPaletteRegionLeft + mPaletteRegionWidth,
  863.  mPaletteRegionTop - mPaletteRegionHeight );
  865. if ( paletteRect.pointInRect ( x, y ) )
  866. {
  867. // release keyboard focus so we can change text values
  868. if (gFocusMgr.childHasKeyboardFocus(this))
  869. {
  870. mSelectBtn->setFocus(TRUE);
  871. }
  873. // calculate which palette index we selected
  874. S32 c = ( ( x - mPaletteRegionLeft ) * numPaletteColumns ) / mPaletteRegionWidth;
  875. S32 r = ( ( y - ( mPaletteRegionTop - mPaletteRegionHeight ) ) * numPaletteRows ) / mPaletteRegionHeight;
  877. U32 index = ( numPaletteRows - r - 1 ) * numPaletteColumns + c;
  879. if ( index <= mPalette.size () )
  880. {
  881. LLColor4 selected = *mPalette [ index ];
  883. setCurRgb ( selected [ 0 ], selected [ 1 ], selected [ 2 ] );
  885. if (mApplyImmediateCheck->get())
  886. {
  887. LLColorSwatchCtrl::onColorChanged ( getSwatch (), LLColorSwatchCtrl::COLOR_CHANGE );
  888. }
  890. updateTextEntry ();
  891. }
  893. return TRUE;
  894. }
  896. // dispatch to base class for the rest of things
  898. return LLFloater::handleMouseDown ( x, y, mask );
  899. }
  901. //////////////////////////////////////////////////////////////////////////////
  902. //
  903. BOOL LLFloaterColorPicker::handleHover ( S32 x, S32 y, MASK mask )
  904. {
  905. // if we're the front most window
  906. if ( isFrontmost () )
  907. {
  908. // mouse was pressed within region
  909. if ( getMouseDownInHueRegion() || getMouseDownInLumRegion())
  910. {
  911. S32 clamped_x, clamped_y;
  912. if (getMouseDownInHueRegion())
  913. {
  914. clamped_x = llclamp(x, mRGBViewerImageLeft, mRGBViewerImageLeft + mRGBViewerImageWidth);
  915. clamped_y = llclamp(y, mRGBViewerImageTop - mRGBViewerImageHeight, mRGBViewerImageTop);
  916. }
  917. else
  918. {
  919. clamped_x = llclamp(x, mLumRegionLeft, mLumRegionLeft + mLumRegionWidth);
  920. clamped_y = llclamp(y, mLumRegionTop - mLumRegionHeight, mLumRegionTop);
  921. }
  923. // update the stored RGB/HSL values using the mouse position - returns TRUE if RGB was updated
  924. if ( updateRgbHslFromPoint ( clamped_x, clamped_y ) )
  925. {
  926. // update text entry fields
  927. updateTextEntry ();
  929. // RN: apparently changing color when dragging generates too much traffic and results in sporadic updates
  930. //// commit changed color to swatch subject
  931. //// REVIEW: this gets sent each time a color changes - is this okay ?
  932. //if (mApplyImmediateCheck->get())
  933. //{
  934. // LLColorSwatchCtrl::onColorChanged ( getSwatch () );
  935. //}
  936. }
  937. }
  939. highlightEntry = -1;
  941. if ( mMouseDownInSwatch )
  942. {
  943. getWindow()->setCursor ( UI_CURSOR_ARROWDRAG );
  945. // if cursor if over a palette entry
  946. LLRect paletteRect ( mPaletteRegionLeft,
  947. mPaletteRegionTop,
  948. mPaletteRegionLeft + mPaletteRegionWidth,
  949. mPaletteRegionTop - mPaletteRegionHeight );
  951. if ( paletteRect.pointInRect ( x, y ) )
  952. {
  953. // find row/column in palette
  954. S32 xOffset = ( ( x - mPaletteRegionLeft ) * numPaletteColumns ) / mPaletteRegionWidth;
  955. S32 yOffset = ( ( mPaletteRegionTop - y - 1 ) * numPaletteRows ) / mPaletteRegionHeight;
  957. // calculate the entry 0..n-1 to highlight and set variable to next draw() picks it up
  958. highlightEntry = xOffset + yOffset * numPaletteColumns;
  959. }
  961. return TRUE;
  962. }
  963. }
  965. // dispatch to base class for the rest of things
  966. return LLFloater::handleHover ( x, y, mask );
  967. }
  969. //////////////////////////////////////////////////////////////////////////////
  970. // reverts state once mouse button is released
  971. BOOL LLFloaterColorPicker::handleMouseUp ( S32 x, S32 y, MASK mask )
  972. {
  973. getWindow()->setCursor ( UI_CURSOR_ARROW );
  975. if (getMouseDownInHueRegion() || getMouseDownInLumRegion())
  976. {
  977. if (mApplyImmediateCheck->get())
  978. {
  979. LLColorSwatchCtrl::onColorChanged ( getSwatch (), LLColorSwatchCtrl::COLOR_CHANGE );
  980. }
  981. }
  983. // rect containing palette area
  984. LLRect paletteRect ( mPaletteRegionLeft,
  985. mPaletteRegionTop,
  986. mPaletteRegionLeft + mPaletteRegionWidth,
  987. mPaletteRegionTop - mPaletteRegionHeight );
  989. if ( paletteRect.pointInRect ( x, y ) )
  990. {
  991. if ( mMouseDownInSwatch )
  992. {
  993. S32 curEntry = 0;
  994. for ( S32 row = 0; row < numPaletteRows; ++row )
  995. {
  996. for ( S32 column = 0; column < numPaletteColumns; ++column )
  997. {
  998. S32 left = mPaletteRegionLeft + ( mPaletteRegionWidth * column ) / numPaletteColumns;
  999. S32 top = mPaletteRegionTop - ( mPaletteRegionHeight * row ) / numPaletteRows;
  1000. S32 right = ( mPaletteRegionLeft + ( mPaletteRegionWidth * ( column + 1 ) ) / numPaletteColumns );
  1001. S32 bottom = ( mPaletteRegionTop - ( mPaletteRegionHeight * ( row + 1 ) ) / numPaletteRows );
  1003. // rect is flipped vertically when testing here
  1004. LLRect dropRect ( left, top, right, bottom );
  1006. if ( dropRect.pointInRect ( x, y ) )
  1007. {
  1008. if ( mPalette [ curEntry ] )
  1009. {
  1010. delete mPalette [ curEntry ];
  1012. mPalette [ curEntry ] = new LLColor4 ( getCurR (), getCurG (), getCurB (), 1.0f );
  1014. // save off color
  1015. std::ostringstream codec;
  1016. codec << "ColorPaletteEntry" << std::setfill ( '0' ) << std::setw ( 2 ) << curEntry + 1;
  1017. const std::string s ( codec.str () );
  1018. LLUIColorTable::instance().setColor(s, *mPalette [ curEntry ] );
  1019. }
  1020. }
  1022. ++curEntry;
  1023. }
  1024. }
  1025. }
  1026. }
  1028. // mouse button not down anymore
  1029. setMouseDownInHueRegion ( FALSE );
  1030. setMouseDownInLumRegion ( FALSE );
  1032. // mouse button not down in color swatch anymore
  1033. mMouseDownInSwatch = false;
  1035. if (hasMouseCapture())
  1036. {
  1037. gFocusMgr.setMouseCapture(NULL);
  1038. }
  1040. // dispatch to base class for the rest of things
  1041. return LLFloater::handleMouseUp ( x, y, mask );
  1042. }
  1044. //////////////////////////////////////////////////////////////////////////////
  1045. // cancel current color selection, revert to original and close picker
  1046. void LLFloaterColorPicker::cancelSelection ()
  1047. {
  1048. // restore the previous color selection
  1049. setCurRgb ( getOrigR (), getOrigG (), getOrigB () );
  1051. // update in world item with original color via current swatch
  1052. LLColorSwatchCtrl::onColorChanged( getSwatch(), LLColorSwatchCtrl::COLOR_CANCEL );
  1054. // hide picker dialog
  1055. this->setVisible ( FALSE );
  1056. }
  1058. void LLFloaterColorPicker::setMouseDownInHueRegion ( BOOL mouse_down_in_region )
  1059. {
  1060. mMouseDownInHueRegion = mouse_down_in_region;
  1061. if (mouse_down_in_region)
  1062. {
  1063. if (gFocusMgr.childHasKeyboardFocus(this))
  1064. {
  1065. // get focus out of spinners so that they can update freely
  1066. mSelectBtn->setFocus(TRUE);
  1067. }
  1068. }
  1069. }
  1071. void LLFloaterColorPicker::setMouseDownInLumRegion ( BOOL mouse_down_in_region )
  1072. {
  1073. mMouseDownInLumRegion = mouse_down_in_region;
  1074. if (mouse_down_in_region)
  1075. {
  1076. if (gFocusMgr.childHasKeyboardFocus(this))
  1077. {
  1078. // get focus out of spinners so that they can update freely
  1079. mSelectBtn->setFocus(TRUE);
  1080. }
  1081. }
  1082. }
  1084. void LLFloaterColorPicker::setMouseDownInSwatch (BOOL mouse_down_in_swatch)
  1085. {
  1086. mMouseDownInSwatch = mouse_down_in_swatch;
  1087. if (mouse_down_in_swatch)
  1088. {
  1089. if (gFocusMgr.childHasKeyboardFocus(this))
  1090. {
  1091. // get focus out of spinners so that they can update freely
  1092. mSelectBtn->setFocus(TRUE);
  1093. }
  1094. }
  1095. }
  1097. void LLFloaterColorPicker::setActive(BOOL active) 
  1098. { 
  1099. // shut down pipette tool if active
  1100. if (!active && mPipetteBtn->getToggleState())
  1101. {
  1102. stopUsingPipette();
  1103. }
  1104. mActive = active; 
  1105. }
  1107. void LLFloaterColorPicker::stopUsingPipette()
  1108. {
  1109. if (LLToolMgr::getInstance()->getCurrentTool() == LLToolPipette::getInstance())
  1110. {
  1111. LLToolMgr::getInstance()->clearTransientTool();
  1112. }
  1113. }