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

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

游戏引擎

开发平台：

C++ Builder

lllineeditor.cpp：源码内容
  1. /** 
  2.  * @file lllineeditor.cpp
  3.  * @brief LLLineEditor base class
  4.  *
  5.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  6.  * 
  7.  * Copyright (c) 2001-2010, Linden Research, Inc.
  8.  * 
  9.  * Second Life Viewer Source Code
  10.  * The source code in this file ("Source Code") is provided by Linden Lab
  11.  * to you under the terms of the GNU General Public License, version 2.0
  12.  * ("GPL"), unless you have obtained a separate licensing agreement
  13.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  14.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  15.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  16.  * 
  17.  * There are special exceptions to the terms and conditions of the GPL as
  18.  * it is applied to this Source Code. View the full text of the exception
  19.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  20.  * online at
  21.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  22.  * 
  23.  * By copying, modifying or distributing this software, you acknowledge
  24.  * that you have read and understood your obligations described above,
  25.  * and agree to abide by those obligations.
  26.  * 
  27.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  28.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  29.  * COMPLETENESS OR PERFORMANCE.
  30.  * $/LicenseInfo$
  31.  */
  33. // Text editor widget to let users enter a single line.
  35. #include "linden_common.h"
  36.  
  37. #define LLLINEEDITOR_CPP
  38. #include "lllineeditor.h"
  40. #include "lltexteditor.h"
  41. #include "llmath.h"
  42. #include "llfontgl.h"
  43. #include "llgl.h"
  44. #include "lltimer.h"
  46. //#include "llclipboard.h"
  47. #include "llcontrol.h"
  48. #include "llbutton.h"
  49. #include "llfocusmgr.h"
  50. #include "llkeyboard.h"
  51. #include "llrect.h"
  52. #include "llresmgr.h"
  53. #include "llstring.h"
  54. #include "llwindow.h"
  55. #include "llui.h"
  56. #include "lluictrlfactory.h"
  57. #include "llclipboard.h"
  58. #include "llmenugl.h"
  60. //
  61. // Imported globals
  62. //
  64. //
  65. // Constants
  66. //
  68. const F32 CURSOR_FLASH_DELAY = 1.0f;  // in seconds
  69. const S32 SCROLL_INCREMENT_ADD = 0; // make space for typing
  70. const S32   SCROLL_INCREMENT_DEL = 4; // make space for baskspacing
  71. const F32   AUTO_SCROLL_TIME = 0.05f;
  72. const F32 TRIPLE_CLICK_INTERVAL = 0.3f; // delay between double and triple click. *TODO: make this equal to the double click interval?
  74. const std::string PASSWORD_ASTERISK( "xE2x80xA2" ); // U+2022 BULLET
  76. static LLDefaultChildRegistry::Register<LLLineEditor> r1("line_editor");
  78. // Compiler optimization, generate extern template
  79. template class LLLineEditor* LLView::getChild<class LLLineEditor>(
  80. const std::string& name, BOOL recurse) const;
  82. //
  83. // Member functions
  84. //
  86. LLLineEditor::Params::Params()
  87. : max_length_bytes("max_length", 254),
  88.     keystroke_callback("keystroke_callback"),
  89. prevalidate_callback("prevalidate_callback"),
  90. background_image("background_image"),
  91. background_image_disabled("background_image_disabled"),
  92. background_image_focused("background_image_focused"),
  93. select_on_focus("select_on_focus", false),
  94. handle_edit_keys_directly("handle_edit_keys_directly", false),
  95. revert_on_esc("revert_on_esc", true),
  96. commit_on_focus_lost("commit_on_focus_lost", true),
  97. ignore_tab("ignore_tab", true),
  98. cursor_color("cursor_color"),
  99. text_color("text_color"),
  100. text_readonly_color("text_readonly_color"),
  101. text_tentative_color("text_tentative_color"),
  102. highlight_color("highlight_color"),
  103. preedit_bg_color("preedit_bg_color"),
  104. border(""),
  105. bg_visible("bg_visible"),
  106. text_pad_left("text_pad_left"),
  107. text_pad_right("text_pad_right"),
  108. default_text("default_text")
  109. {
  110. mouse_opaque = true;
  111. addSynonym(select_on_focus, "select_all_on_focus_received");
  112. addSynonym(border, "border");
  113. addSynonym(label, "watermark_text");
  114. }
  116. LLLineEditor::LLLineEditor(const LLLineEditor::Params& p)
  117. : LLUICtrl(p),
  118. mMaxLengthBytes(p.max_length_bytes),
  119. mCursorPos( 0 ),
  120. mScrollHPos( 0 ),
  121. mTextPadLeft(p.text_pad_left),
  122. mTextPadRight(p.text_pad_right),
  123. mTextLeftEdge(0), // computed in updateTextPadding() below
  124. mTextRightEdge(0), // computed in updateTextPadding() below
  125. mCommitOnFocusLost( p.commit_on_focus_lost ),
  126. mRevertOnEsc( p.revert_on_esc ),
  127. mKeystrokeCallback( p.keystroke_callback() ),
  128. mIsSelecting( FALSE ),
  129. mSelectionStart( 0 ),
  130. mSelectionEnd( 0 ),
  131. mLastSelectionX(-1),
  132. mLastSelectionY(-1),
  133. mLastSelectionStart(-1),
  134. mLastSelectionEnd(-1),
  135. mBorderThickness( 0 ),
  136. mIgnoreArrowKeys( FALSE ),
  137. mIgnoreTab( p.ignore_tab ),
  138. mDrawAsterixes( FALSE ),
  139. mHandleEditKeysDirectly(p.handle_edit_keys_directly),
  140. mSelectAllonFocusReceived( p.select_on_focus ),
  141. mPassDelete(FALSE),
  142. mReadOnly(FALSE),
  143. mBgImage( p.background_image ),
  144. mBgImageDisabled( p.background_image_disabled ),
  145. mBgImageFocused( p.background_image_focused ),
  146. mHaveHistory(FALSE),
  147. mReplaceNewlinesWithSpaces( TRUE ),
  148. mLabel(p.label),
  149. mCursorColor(p.cursor_color()),
  150. mFgColor(p.text_color()),
  151. mReadOnlyFgColor(p.text_readonly_color()),
  152. mTentativeFgColor(p.text_tentative_color()),
  153. mHighlightColor(p.highlight_color()),
  154. mPreeditBgColor(p.preedit_bg_color()),
  155. mGLFont(p.font),
  156. mContextMenuHandle()
  157. {
  158. llassert( mMaxLengthBytes > 0 );
  160. mScrollTimer.reset();
  161. mTripleClickTimer.reset();
  162. setText(p.default_text());
  164. // Initialize current history line iterator
  165. mCurrentHistoryLine = mLineHistory.begin();
  167. LLRect border_rect(getLocalRect());
  168. // adjust for gl line drawing glitch
  169. border_rect.mTop -= 1;
  170. border_rect.mRight -=1;
  171. LLViewBorder::Params border_p(p.border);
  172. border_p.rect = border_rect;
  173. border_p.follows.flags = FOLLOWS_ALL;
  174. border_p.bevel_style = LLViewBorder::BEVEL_IN;
  175. mBorder = LLUICtrlFactory::create<LLViewBorder>(border_p);
  176. addChild( mBorder );
  178. // clamp text padding to current editor size
  179. updateTextPadding();
  180. setCursor(mText.length());
  182. setPrevalidate(p.prevalidate_callback());
  184. LLContextMenu* menu = LLUICtrlFactory::instance().createFromFile<LLContextMenu>
  185. ("menu_text_editor.xml",
  186.  LLMenuGL::sMenuContainer,
  187.  LLMenuHolderGL::child_registry_t::instance());
  188. setContextMenu(menu);
  189. }
  190.  
  191. LLLineEditor::~LLLineEditor()
  192. {
  193. mCommitOnFocusLost = FALSE;
  195. gFocusMgr.releaseFocusIfNeeded( this );
  197. if( gEditMenuHandler == this )
  198. {
  199. gEditMenuHandler = NULL;
  200. }
  201. }
  204. void LLLineEditor::onFocusReceived()
  205. {
  206. LLUICtrl::onFocusReceived();
  207. updateAllowingLanguageInput();
  208. }
  210. void LLLineEditor::onFocusLost()
  211. {
  212. // The call to updateAllowLanguageInput()
  213. // when loosing the keyboard focus *may*
  214. // indirectly invoke handleUnicodeCharHere(), 
  215. // so it must be called before onCommit.
  216. updateAllowingLanguageInput();
  218. if( mCommitOnFocusLost && mText.getString() != mPrevText) 
  219. {
  220. onCommit();
  221. }
  223. if( gEditMenuHandler == this )
  224. {
  225. gEditMenuHandler = NULL;
  226. }
  228. getWindow()->showCursorFromMouseMove();
  230. LLUICtrl::onFocusLost();
  231. }
  233. // virtual
  234. void LLLineEditor::onCommit()
  235. {
  236. // put current line into the line history
  237. updateHistory();
  239. setControlValue(getValue());
  240. LLUICtrl::onCommit();
  241. selectAll();
  242. }
  244. // Returns TRUE if user changed value at all
  245. // virtual
  246. BOOL LLLineEditor::isDirty() const
  247. {
  248. return mText.getString() != mPrevText;
  249. }
  251. // Clear dirty state
  252. // virtual
  253. void LLLineEditor::resetDirty()
  254. {
  255. mPrevText = mText.getString();
  256. }
  258. // assumes UTF8 text
  259. // virtual
  260. void LLLineEditor::setValue(const LLSD& value )
  261. {
  262. setText(value.asString());
  263. }
  265. //virtual
  266. LLSD LLLineEditor::getValue() const
  267. {
  268. return LLSD(getText());
  269. }
  272. // line history support
  273. void LLLineEditor::updateHistory()
  274. {
  275. // On history enabled line editors, remember committed line and
  276. // reset current history line number.
  277. // Be sure only to remember lines that are not empty and that are
  278. // different from the last on the list.
  279. if( mHaveHistory && getLength() )
  280. {
  281. if( !mLineHistory.empty() )
  282. {
  283. // When not empty, last line of history should always be blank.
  284. if( mLineHistory.back().empty() )
  285. {
  286. // discard the empty line
  287. mLineHistory.pop_back();
  288. }
  289. else
  290. {
  291. LL_WARNS("") << "Last line of history was not blank." << LL_ENDL;
  292. }
  293. }
  295. // Add text to history, ignoring duplicates
  296. if( mLineHistory.empty() || getText() != mLineHistory.back() )
  297. {
  298. mLineHistory.push_back( getText() );
  299. }
  301. // Restore the blank line and set mCurrentHistoryLine to point at it
  302. mLineHistory.push_back( "" );
  303. mCurrentHistoryLine = mLineHistory.end() - 1;
  304. }
  305. }
  307. void LLLineEditor::reshape(S32 width, S32 height, BOOL called_from_parent)
  308. {
  309. LLUICtrl::reshape(width, height, called_from_parent);
  310. updateTextPadding(); // For clamping side-effect.
  311. setCursor(mCursorPos); // For clamping side-effect.
  312. }
  314. void LLLineEditor::setEnabled(BOOL enabled)
  315. {
  316. mReadOnly = !enabled;
  317. setTabStop(!mReadOnly);
  318. updateAllowingLanguageInput();
  319. }
  322. void LLLineEditor::setMaxTextLength(S32 max_text_length)
  323. {
  324. S32 max_len = llmax(0, max_text_length);
  325. mMaxLengthBytes = max_len;
  326. } 
  328. void LLLineEditor::getTextPadding(S32 *left, S32 *right)
  329. {
  330. *left = mTextPadLeft;
  331. *right = mTextPadRight;
  332. }
  334. void LLLineEditor::setTextPadding(S32 left, S32 right)
  335. {
  336. mTextPadLeft = left;
  337. mTextPadRight = right;
  338. updateTextPadding();
  339. }
  341. void LLLineEditor::updateTextPadding()
  342. {
  343. mTextLeftEdge = llclamp(mTextPadLeft, 0, getRect().getWidth());
  344. mTextRightEdge = getRect().getWidth() - llclamp(mTextPadRight, 0, getRect().getWidth());
  345. }
  348. void LLLineEditor::setText(const LLStringExplicit &new_text)
  349. {
  350. // If new text is identical, don't copy and don't move insertion point
  351. if (mText.getString() == new_text)
  352. {
  353. return;
  354. }
  356. // Check to see if entire field is selected.
  357. S32 len = mText.length();
  358. BOOL all_selected = (len > 0)
  359. && (( mSelectionStart == 0 && mSelectionEnd == len ) 
  360. || ( mSelectionStart == len && mSelectionEnd == 0 ));
  362. // Do safe truncation so we don't split multi-byte characters
  363. // also consider entire string selected when mSelectAllonFocusReceived is set on an empty, focused line editor
  364. all_selected = all_selected || (len == 0 && hasFocus() && mSelectAllonFocusReceived);
  366. std::string truncated_utf8 = new_text;
  367. if (truncated_utf8.size() > (U32)mMaxLengthBytes)
  368. {
  369. truncated_utf8 = utf8str_truncate(new_text, mMaxLengthBytes);
  370. }
  371. mText.assign(truncated_utf8);
  373. if (all_selected)
  374. {
  375. // ...keep whole thing selected
  376. selectAll();
  377. }
  378. else
  379. {
  380. // try to preserve insertion point, but deselect text
  381. deselect();
  382. }
  383. setCursor(llmin((S32)mText.length(), getCursor()));
  385. // Set current history line to end of history.
  386. mCurrentHistoryLine = mLineHistory.end() - 1;
  388. mPrevText = mText;
  389. }
  392. // Picks a new cursor position based on the actual screen size of text being drawn.
  393. void LLLineEditor::setCursorAtLocalPos( S32 local_mouse_x )
  394. {
  395. const llwchar* wtext = mText.getWString().c_str();
  396. LLWString asterix_text;
  397. if (mDrawAsterixes)
  398. {
  399. for (S32 i = 0; i < mText.length(); i++)
  400. {
  401. asterix_text += utf8str_to_wstring(PASSWORD_ASTERISK);
  402. }
  403. wtext = asterix_text.c_str();
  404. }
  406. S32 cursor_pos =
  407. mScrollHPos + 
  408. mGLFont->charFromPixelOffset(
  409. wtext, mScrollHPos,
  410. (F32)(local_mouse_x - mTextLeftEdge),
  411. (F32)(mTextRightEdge - mTextLeftEdge + 1)); // min-max range is inclusive
  412. setCursor(cursor_pos);
  413. }
  415. void LLLineEditor::setCursor( S32 pos )
  416. {
  417. S32 old_cursor_pos = getCursor();
  418. mCursorPos = llclamp( pos, 0, mText.length());
  420. // position of end of next character after cursor
  421. S32 pixels_after_scroll = findPixelNearestPos();
  422. if( pixels_after_scroll > mTextRightEdge )
  423. {
  424. S32 width_chars_to_left = mGLFont->getWidth(mText.getWString().c_str(), 0, mScrollHPos);
  425. S32 last_visible_char = mGLFont->maxDrawableChars(mText.getWString().c_str(), llmax(0.f, (F32)(mTextRightEdge - mTextLeftEdge + width_chars_to_left))); 
  426. // character immediately to left of cursor should be last one visible (SCROLL_INCREMENT_ADD will scroll in more characters)
  427. // or first character if cursor is at beginning
  428. S32 new_last_visible_char = llmax(0, getCursor() - 1);
  429. S32 min_scroll = mGLFont->firstDrawableChar(mText.getWString().c_str(), (F32)(mTextRightEdge - mTextLeftEdge), mText.length(), new_last_visible_char);
  430. if (old_cursor_pos == last_visible_char)
  431. {
  432. mScrollHPos = llmin(mText.length(), llmax(min_scroll, mScrollHPos + SCROLL_INCREMENT_ADD));
  433. }
  434. else
  435. {
  436. mScrollHPos = min_scroll;
  437. }
  438. }
  439. else if (getCursor() < mScrollHPos)
  440. {
  441. if (old_cursor_pos == mScrollHPos)
  442. {
  443. mScrollHPos = llmax(0, llmin(getCursor(), mScrollHPos - SCROLL_INCREMENT_DEL));
  444. }
  445. else
  446. {
  447. mScrollHPos = getCursor();
  448. }
  449. }
  450. }
  453. void LLLineEditor::setCursorToEnd()
  454. {
  455. setCursor(mText.length());
  456. deselect();
  457. }
  459. BOOL LLLineEditor::canDeselect() const
  460. {
  461. return hasSelection();
  462. }
  464. void LLLineEditor::deselect()
  465. {
  466. mSelectionStart = 0;
  467. mSelectionEnd = 0;
  468. mIsSelecting = FALSE;
  469. }
  472. void LLLineEditor::startSelection()
  473. {
  474. mIsSelecting = TRUE;
  475. mSelectionStart = getCursor();
  476. mSelectionEnd = getCursor();
  477. }
  479. void LLLineEditor::endSelection()
  480. {
  481. if( mIsSelecting )
  482. {
  483. mIsSelecting = FALSE;
  484. mSelectionEnd = getCursor();
  485. }
  486. }
  488. BOOL LLLineEditor::canSelectAll() const
  489. {
  490. return TRUE;
  491. }
  493. void LLLineEditor::selectAll()
  494. {
  495. mSelectionStart = mText.length();
  496. mSelectionEnd = 0;
  497. setCursor(mSelectionEnd);
  498. //mScrollHPos = 0;
  499. mIsSelecting = TRUE;
  500. }
  503. BOOL LLLineEditor::handleDoubleClick(S32 x, S32 y, MASK mask)
  504. {
  505. setFocus( TRUE );
  506. mTripleClickTimer.setTimerExpirySec(TRIPLE_CLICK_INTERVAL);
  508. if (mSelectionEnd == 0 && mSelectionStart == mText.length())
  509. {
  510. // if everything is selected, handle this as a normal click to change insertion point
  511. handleMouseDown(x, y, mask);
  512. }
  513. else
  514. {
  515. const LLWString& wtext = mText.getWString();
  517. BOOL doSelectAll = TRUE;
  519. // Select the word we're on
  520. if( LLWStringUtil::isPartOfWord( wtext[mCursorPos] ) )
  521. {
  522. S32 old_selection_start = mLastSelectionStart;
  523. S32 old_selection_end = mLastSelectionEnd;
  525. // Select word the cursor is over
  526. while ((mCursorPos > 0) && LLWStringUtil::isPartOfWord( wtext[mCursorPos-1] ))
  527. { // Find the start of the word
  528. mCursorPos--;
  529. }
  530. startSelection();
  532. while ((mCursorPos < (S32)wtext.length()) && LLWStringUtil::isPartOfWord( wtext[mCursorPos] ) )
  533. { // Find the end of the word
  534. mCursorPos++;
  535. }
  536. mSelectionEnd = mCursorPos;
  538. // If nothing changed, then the word was already selected.  Select the whole line.
  539. doSelectAll = (old_selection_start == mSelectionStart) &&  
  540.   (old_selection_end   == mSelectionEnd);
  541. }
  543. if ( doSelectAll )
  544. { // Select everything
  545. selectAll();
  546. }
  547. }
  549. // We don't want handleMouseUp() to "finish" the selection (and thereby
  550. // set mSelectionEnd to where the mouse is), so we finish the selection 
  551. // here.
  552. mIsSelecting = FALSE;  
  554. // delay cursor flashing
  555. mKeystrokeTimer.reset();
  557. // take selection to 'primary' clipboard
  558. updatePrimary();
  560. return TRUE;
  561. }
  563. BOOL LLLineEditor::handleMouseDown(S32 x, S32 y, MASK mask)
  564. {
  565. // Check first whether the "clear search" button wants to deal with this.
  566. if(childrenHandleMouseDown(x, y, mask) != NULL) 
  567. {
  568. return TRUE;
  569. }
  571. if (!mSelectAllonFocusReceived
  572. || gFocusMgr.getKeyboardFocus() == this)
  573. {
  574. mLastSelectionStart = -1;
  575. mLastSelectionStart = -1;
  577. if (mask & MASK_SHIFT)
  578. {
  579. // Handle selection extension
  580. S32 old_cursor_pos = getCursor();
  581. setCursorAtLocalPos(x);
  583. if (hasSelection())
  584. {
  585. /* Mac-like behavior - extend selection towards the cursor
  586. if (getCursor() < mSelectionStart
  587. && getCursor() < mSelectionEnd)
  588. {
  589. // ...left of selection
  590. mSelectionStart = llmax(mSelectionStart, mSelectionEnd);
  591. mSelectionEnd = getCursor();
  592. }
  593. else if (getCursor() > mSelectionStart
  594. && getCursor() > mSelectionEnd)
  595. {
  596. // ...right of selection
  597. mSelectionStart = llmin(mSelectionStart, mSelectionEnd);
  598. mSelectionEnd = getCursor();
  599. }
  600. else
  601. {
  602. mSelectionEnd = getCursor();
  603. }
  604. */
  605. // Windows behavior
  606. mSelectionEnd = getCursor();
  607. }
  608. else
  609. {
  610. mSelectionStart = old_cursor_pos;
  611. mSelectionEnd = getCursor();
  612. }
  613. // assume we're starting a drag select
  614. mIsSelecting = TRUE;
  615. }
  616. else
  617. {
  618. if (mTripleClickTimer.hasExpired())
  619. {
  620. // Save selection for word/line selecting on double-click
  621. mLastSelectionStart = mSelectionStart;
  622. mLastSelectionEnd = mSelectionEnd;
  624. // Move cursor and deselect for regular click
  625. setCursorAtLocalPos( x );
  626. deselect();
  627. startSelection();
  628. }
  629. else // handle triple click
  630. {
  631. selectAll();
  632. // We don't want handleMouseUp() to "finish" the selection (and thereby
  633. // set mSelectionEnd to where the mouse is), so we finish the selection 
  634. // here.
  635. mIsSelecting = FALSE;
  636. }
  637. }
  639. gFocusMgr.setMouseCapture( this );
  640. }
  642. setFocus(TRUE);
  644. // delay cursor flashing
  645. mKeystrokeTimer.reset();
  647. if (mMouseDownSignal)
  648. (*mMouseDownSignal)(this,x,y,mask);
  650. return TRUE;
  651. }
  653. BOOL LLLineEditor::handleMiddleMouseDown(S32 x, S32 y, MASK mask)
  654. {
  655.         // llinfos << "MiddleMouseDown" << llendl;
  656. setFocus( TRUE );
  657. if( canPastePrimary() )
  658. {
  659. setCursorAtLocalPos(x);
  660. pastePrimary();
  661. }
  662. return TRUE;
  663. }
  665. BOOL LLLineEditor::handleRightMouseDown(S32 x, S32 y, MASK mask)
  666. {
  667. setFocus(TRUE);
  668. if (!LLUICtrl::handleRightMouseDown(x, y, mask))
  669. {
  670. showContextMenu(x, y);
  671. }
  672. return TRUE;
  673. }
  675. BOOL LLLineEditor::handleHover(S32 x, S32 y, MASK mask)
  676. {
  677. BOOL handled = FALSE;
  678. // Check first whether the "clear search" button wants to deal with this.
  679. if(!hasMouseCapture())
  680. {
  681. if(childrenHandleHover(x, y, mask) != NULL) 
  682. {
  683. return TRUE;
  684. }
  685. }
  687. if( (hasMouseCapture()) && mIsSelecting )
  688. {
  689. if (x != mLastSelectionX || y != mLastSelectionY)
  690. {
  691. mLastSelectionX = x;
  692. mLastSelectionY = y;
  693. }
  694. // Scroll if mouse cursor outside of bounds
  695. if (mScrollTimer.hasExpired())
  696. {
  697. S32 increment = llround(mScrollTimer.getElapsedTimeF32() / AUTO_SCROLL_TIME);
  698. mScrollTimer.reset();
  699. mScrollTimer.setTimerExpirySec(AUTO_SCROLL_TIME);
  700. if( (x < mTextLeftEdge) && (mScrollHPos > 0 ) )
  701. {
  702. // Scroll to the left
  703. mScrollHPos = llclamp(mScrollHPos - increment, 0, mText.length());
  704. }
  705. else
  706. if( (x > mTextRightEdge) && (mCursorPos < (S32)mText.length()) )
  707. {
  708. // If scrolling one pixel would make a difference...
  709. S32 pixels_after_scrolling_one_char = findPixelNearestPos(1);
  710. if( pixels_after_scrolling_one_char >= mTextRightEdge )
  711. {
  712. // ...scroll to the right
  713. mScrollHPos = llclamp(mScrollHPos + increment, 0, mText.length());
  714. }
  715. }
  716. }
  718. setCursorAtLocalPos( x );
  719. mSelectionEnd = getCursor();
  721. // delay cursor flashing
  722. mKeystrokeTimer.reset();
  724. getWindow()->setCursor(UI_CURSOR_IBEAM);
  725. lldebugst(LLERR_USER_INPUT) << "hover handled by " << getName() << " (active)" << llendl;
  726. handled = TRUE;
  727. }
  729. if( !handled  )
  730. {
  731. getWindow()->setCursor(UI_CURSOR_IBEAM);
  732. lldebugst(LLERR_USER_INPUT) << "hover handled by " << getName() << " (inactive)" << llendl;
  733. handled = TRUE;
  734. }
  736. return handled;
  737. }
  740. BOOL LLLineEditor::handleMouseUp(S32 x, S32 y, MASK mask)
  741. {
  742. BOOL handled = FALSE;
  744. if( hasMouseCapture() )
  745. {
  746. gFocusMgr.setMouseCapture( NULL );
  747. handled = TRUE;
  748. }
  750. // Check first whether the "clear search" button wants to deal with this.
  751. if(!handled && childrenHandleMouseUp(x, y, mask) != NULL) 
  752. {
  753. return TRUE;
  754. }
  756. if( mIsSelecting )
  757. {
  758. setCursorAtLocalPos( x );
  759. mSelectionEnd = getCursor();
  761. handled = TRUE;
  762. }
  764. if( handled )
  765. {
  766. // delay cursor flashing
  767. mKeystrokeTimer.reset();
  769. // take selection to 'primary' clipboard
  770. updatePrimary();
  771. }
  773. // We won't call LLUICtrl::handleMouseUp to avoid double calls of  childrenHandleMouseUp().Just invoke the signal manually.
  774. if (mMouseUpSignal)
  775. (*mMouseUpSignal)(this,x,y, mask);
  776. return handled;
  777. }
  780. // Remove a single character from the text
  781. void LLLineEditor::removeChar()
  782. {
  783. if( getCursor() > 0 )
  784. {
  785. mText.erase(getCursor() - 1, 1);
  787. setCursor(getCursor() - 1);
  788. }
  789. else
  790. {
  791. reportBadKeystroke();
  792. }
  793. }
  796. void LLLineEditor::addChar(const llwchar uni_char)
  797. {
  798. llwchar new_c = uni_char;
  799. if (hasSelection())
  800. {
  801. deleteSelection();
  802. }
  803. else if (LL_KIM_OVERWRITE == gKeyboard->getInsertMode())
  804. {
  805. mText.erase(getCursor(), 1);
  806. }
  808. S32 cur_bytes = mText.getString().size();
  809. S32 new_bytes = wchar_utf8_length(new_c);
  811. BOOL allow_char = TRUE;
  813. // Check byte length limit
  814. if ((new_bytes + cur_bytes) > mMaxLengthBytes)
  815. {
  816. allow_char = FALSE;
  817. }
  819. if (allow_char)
  820. {
  821. // Will we need to scroll?
  822. LLWString w_buf;
  823. w_buf.assign(1, new_c);
  825. mText.insert(getCursor(), w_buf);
  826. setCursor(getCursor() + 1);
  827. }
  828. else
  829. {
  830. reportBadKeystroke();
  831. }
  833. getWindow()->hideCursorUntilMouseMove();
  834. }
  836. // Extends the selection box to the new cursor position
  837. void LLLineEditor::extendSelection( S32 new_cursor_pos )
  838. {
  839. if( !mIsSelecting )
  840. {
  841. startSelection();
  842. }
  844. setCursor(new_cursor_pos);
  845. mSelectionEnd = getCursor();
  846. }
  849. void LLLineEditor::setSelection(S32 start, S32 end)
  850. {
  851. S32 len = mText.length();
  853. mIsSelecting = TRUE;
  855. // JC, yes, this seems odd, but I think you have to presume a 
  856. // selection dragged from the end towards the start.
  857. mSelectionStart = llclamp(end, 0, len);
  858. mSelectionEnd = llclamp(start, 0, len);
  859. setCursor(start);
  860. }
  862. void LLLineEditor::setDrawAsterixes(BOOL b)
  863. {
  864. mDrawAsterixes = b;
  865. updateAllowingLanguageInput();
  866. }
  868. S32 LLLineEditor::prevWordPos(S32 cursorPos) const
  869. {
  870. const LLWString& wtext = mText.getWString();
  871. while( (cursorPos > 0) && (wtext[cursorPos-1] == ' ') )
  872. {
  873. cursorPos--;
  874. }
  875. while( (cursorPos > 0) && LLWStringUtil::isPartOfWord( wtext[cursorPos-1] ) )
  876. {
  877. cursorPos--;
  878. }
  879. return cursorPos;
  880. }
  882. S32 LLLineEditor::nextWordPos(S32 cursorPos) const
  883. {
  884. const LLWString& wtext = mText.getWString();
  885. while( (cursorPos < getLength()) && LLWStringUtil::isPartOfWord( wtext[cursorPos] ) )
  886. {
  887. cursorPos++;
  888. } 
  889. while( (cursorPos < getLength()) && (wtext[cursorPos] == ' ') )
  890. {
  891. cursorPos++;
  892. }
  893. return cursorPos;
  894. }
  897. BOOL LLLineEditor::handleSelectionKey(KEY key, MASK mask)
  898. {
  899. BOOL handled = FALSE;
  901. if( mask & MASK_SHIFT )
  902. {
  903. handled = TRUE;
  905. switch( key )
  906. {
  907. case KEY_LEFT:
  908. if( 0 < getCursor() )
  909. {
  910. S32 cursorPos = getCursor() - 1;
  911. if( mask & MASK_CONTROL )
  912. {
  913. cursorPos = prevWordPos(cursorPos);
  914. }
  915. extendSelection( cursorPos );
  916. }
  917. else
  918. {
  919. reportBadKeystroke();
  920. }
  921. break;
  923. case KEY_RIGHT:
  924. if( getCursor() < mText.length())
  925. {
  926. S32 cursorPos = getCursor() + 1;
  927. if( mask & MASK_CONTROL )
  928. {
  929. cursorPos = nextWordPos(cursorPos);
  930. }
  931. extendSelection( cursorPos );
  932. }
  933. else
  934. {
  935. reportBadKeystroke();
  936. }
  937. break;
  939. case KEY_PAGE_UP:
  940. case KEY_HOME:
  941. extendSelection( 0 );
  942. break;
  944. case KEY_PAGE_DOWN:
  945. case KEY_END:
  946. {
  947. S32 len = mText.length();
  948. if( len )
  949. {
  950. extendSelection( len );
  951. }
  952. break;
  953. }
  955. default:
  956. handled = FALSE;
  957. break;
  958. }
  959. }
  961. if (!handled && mHandleEditKeysDirectly)
  962. {
  963. if( (MASK_CONTROL & mask) && ('A' == key) )
  964. {
  965. if( canSelectAll() )
  966. {
  967. selectAll();
  968. }
  969. else
  970. {
  971. reportBadKeystroke();
  972. }
  973. handled = TRUE;
  974. }
  975. }
  977. if(handled)
  978. {
  979. // take selection to 'primary' clipboard
  980. updatePrimary();
  981. }
  982.  
  983. return handled;
  984. }
  986. void LLLineEditor::deleteSelection()
  987. {
  988. if( !mReadOnly && hasSelection() )
  989. {
  990. S32 left_pos = llmin( mSelectionStart, mSelectionEnd );
  991. S32 selection_length = llabs( mSelectionStart - mSelectionEnd );
  993. mText.erase(left_pos, selection_length);
  994. deselect();
  995. setCursor(left_pos);
  996. }
  997. }
  999. BOOL LLLineEditor::canCut() const
  1000. {
  1001. return !mReadOnly && !mDrawAsterixes && hasSelection();
  1002. }
  1004. // cut selection to clipboard
  1005. void LLLineEditor::cut()
  1006. {
  1007. if( canCut() )
  1008. {
  1009. // Prepare for possible rollback
  1010. LLLineEditorRollback rollback( this );
  1013. S32 left_pos = llmin( mSelectionStart, mSelectionEnd );
  1014. S32 length = llabs( mSelectionStart - mSelectionEnd );
  1015. gClipboard.copyFromSubstring( mText.getWString(), left_pos, length );
  1016. deleteSelection();
  1018. // Validate new string and rollback the if needed.
  1019. BOOL need_to_rollback = ( mPrevalidateFunc && !mPrevalidateFunc( mText.getWString() ) );
  1020. if( need_to_rollback )
  1021. {
  1022. rollback.doRollback( this );
  1023. reportBadKeystroke();
  1024. }
  1025. else
  1026. if( mKeystrokeCallback )
  1027. {
  1028. mKeystrokeCallback( this );
  1029. }
  1030. }
  1031. }
  1033. BOOL LLLineEditor::canCopy() const
  1034. {
  1035. return !mDrawAsterixes && hasSelection();
  1036. }
  1039. // copy selection to clipboard
  1040. void LLLineEditor::copy()
  1041. {
  1042. if( canCopy() )
  1043. {
  1044. S32 left_pos = llmin( mSelectionStart, mSelectionEnd );
  1045. S32 length = llabs( mSelectionStart - mSelectionEnd );
  1046. gClipboard.copyFromSubstring( mText.getWString(), left_pos, length );
  1047. }
  1048. }
  1050. BOOL LLLineEditor::canPaste() const
  1051. {
  1052. return !mReadOnly && gClipboard.canPasteString(); 
  1053. }
  1055. void LLLineEditor::paste()
  1056. {
  1057. bool is_primary = false;
  1058. pasteHelper(is_primary);
  1059. }
  1061. void LLLineEditor::pastePrimary()
  1062. {
  1063. bool is_primary = true;
  1064. pasteHelper(is_primary);
  1065. }
  1067. // paste from primary (is_primary==true) or clipboard (is_primary==false)
  1068. void LLLineEditor::pasteHelper(bool is_primary)
  1069. {
  1070. bool can_paste_it;
  1071. if (is_primary)
  1072. {
  1073. can_paste_it = canPastePrimary();
  1074. }
  1075. else
  1076. {
  1077. can_paste_it = canPaste();
  1078. }
  1080. if (can_paste_it)
  1081. {
  1082. LLWString paste;
  1083. if (is_primary)
  1084. {
  1085. paste = gClipboard.getPastePrimaryWString();
  1086. }
  1087. else 
  1088. {
  1089. paste = gClipboard.getPasteWString();
  1090. }
  1092. if (!paste.empty())
  1093. {
  1094. // Prepare for possible rollback
  1095. LLLineEditorRollback rollback(this);
  1097. // Delete any selected characters
  1098. if ((!is_primary) && hasSelection())
  1099. {
  1100. deleteSelection();
  1101. }
  1103. // Clean up string (replace tabs and returns and remove characters that our fonts don't support.)
  1104. LLWString clean_string(paste);
  1105. LLWStringUtil::replaceTabsWithSpaces(clean_string, 1);
  1106. //clean_string = wstring_detabify(paste, 1);
  1107. LLWStringUtil::replaceChar(clean_string, 'n', mReplaceNewlinesWithSpaces ? ' ' : 182); // 182 == paragraph character
  1109. // Insert the string
  1111. // Check to see that the size isn't going to be larger than the max number of bytes
  1112. U32 available_bytes = mMaxLengthBytes - wstring_utf8_length(mText);
  1114. if ( available_bytes < (U32) wstring_utf8_length(clean_string) )
  1115. { // Doesn't all fit
  1116. llwchar current_symbol = clean_string[0];
  1117. U32 wchars_that_fit = 0;
  1118. U32 total_bytes = wchar_utf8_length(current_symbol);
  1120. //loop over the "wide" characters (symbols)
  1121. //and check to see how large (in bytes) each symbol is.
  1122. while ( total_bytes <= available_bytes )
  1123. {
  1124. //while we still have available bytes
  1125. //"accept" the current symbol and check the size
  1126. //of the next one
  1127. current_symbol = clean_string[++wchars_that_fit];
  1128. total_bytes += wchar_utf8_length(current_symbol);
  1129. }
  1130. // Truncate the clean string at the limit of what will fit
  1131. clean_string = clean_string.substr(0, wchars_that_fit);
  1132. reportBadKeystroke();
  1133. }
  1134.  
  1135. mText.insert(getCursor(), clean_string);
  1136. setCursor( getCursor() + (S32)clean_string.length() );
  1137. deselect();
  1139. // Validate new string and rollback the if needed.
  1140. BOOL need_to_rollback = ( mPrevalidateFunc && !mPrevalidateFunc( mText.getWString() ) );
  1141. if( need_to_rollback )
  1142. {
  1143. rollback.doRollback( this );
  1144. reportBadKeystroke();
  1145. }
  1146. else
  1147. if( mKeystrokeCallback )
  1148. {
  1149. mKeystrokeCallback( this );
  1150. }
  1151. }
  1152. }
  1153. }
  1155. // copy selection to primary
  1156. void LLLineEditor::copyPrimary()
  1157. {
  1158. if( canCopy() )
  1159. {
  1160. S32 left_pos = llmin( mSelectionStart, mSelectionEnd );
  1161. S32 length = llabs( mSelectionStart - mSelectionEnd );
  1162. gClipboard.copyFromPrimarySubstring( mText.getWString(), left_pos, length );
  1163. }
  1164. }
  1166. BOOL LLLineEditor::canPastePrimary() const
  1167. {
  1168. return !mReadOnly && gClipboard.canPastePrimaryString(); 
  1169. }
  1171. void LLLineEditor::updatePrimary()
  1172. {
  1173. if(canCopy() )
  1174. {
  1175. copyPrimary();
  1176. }
  1177. }
  1179. BOOL LLLineEditor::handleSpecialKey(KEY key, MASK mask)
  1180. {
  1181. BOOL handled = FALSE;
  1183. switch( key )
  1184. {
  1185. case KEY_INSERT:
  1186. if (mask == MASK_NONE)
  1187. {
  1188. gKeyboard->toggleInsertMode();
  1189. }
  1191. handled = TRUE;
  1192. break;
  1194. case KEY_BACKSPACE:
  1195. if (!mReadOnly)
  1196. {
  1197. //llinfos << "Handling backspace" << llendl;
  1198. if( hasSelection() )
  1199. {
  1200. deleteSelection();
  1201. }
  1202. else
  1203. if( 0 < getCursor() )
  1204. {
  1205. removeChar();
  1206. }
  1207. else
  1208. {
  1209. reportBadKeystroke();
  1210. }
  1211. }
  1212. handled = TRUE;
  1213. break;
  1215. case KEY_PAGE_UP:
  1216. case KEY_HOME:
  1217. if (!mIgnoreArrowKeys)
  1218. {
  1219. setCursor(0);
  1220. handled = TRUE;
  1221. }
  1222. break;
  1224. case KEY_PAGE_DOWN:
  1225. case KEY_END:
  1226. if (!mIgnoreArrowKeys)
  1227. {
  1228. S32 len = mText.length();
  1229. if( len )
  1230. {
  1231. setCursor(len);
  1232. }
  1233. handled = TRUE;
  1234. }
  1235. break;
  1237. case KEY_LEFT:
  1238. if (mIgnoreArrowKeys && mask == MASK_NONE)
  1239. break;
  1240. if ((mask & MASK_ALT) == 0)
  1241. {
  1242. if( hasSelection() )
  1243. {
  1244. setCursor(llmin( getCursor() - 1, mSelectionStart, mSelectionEnd ));
  1245. }
  1246. else
  1247. if( 0 < getCursor() )
  1248. {
  1249. S32 cursorPos = getCursor() - 1;
  1250. if( mask & MASK_CONTROL )
  1251. {
  1252. cursorPos = prevWordPos(cursorPos);
  1253. }
  1254. setCursor(cursorPos);
  1255. }
  1256. else
  1257. {
  1258. reportBadKeystroke();
  1259. }
  1260. handled = TRUE;
  1261. }
  1262. break;
  1264. case KEY_RIGHT:
  1265. if (mIgnoreArrowKeys && mask == MASK_NONE)
  1266. break;
  1267. if ((mask & MASK_ALT) == 0)
  1268. {
  1269. if (hasSelection())
  1270. {
  1271. setCursor(llmax(getCursor() + 1, mSelectionStart, mSelectionEnd));
  1272. }
  1273. else
  1274. if (getCursor() < mText.length())
  1275. {
  1276. S32 cursorPos = getCursor() + 1;
  1277. if( mask & MASK_CONTROL )
  1278. {
  1279. cursorPos = nextWordPos(cursorPos);
  1280. }
  1281. setCursor(cursorPos);
  1282. }
  1283. else
  1284. {
  1285. reportBadKeystroke();
  1286. }
  1287. handled = TRUE;
  1288. }
  1289. break;
  1291. // handle ctrl-uparrow if we have a history enabled line editor.
  1292. case KEY_UP:
  1293. if( mHaveHistory && ( MASK_CONTROL == mask ) )
  1294. {
  1295. if( mCurrentHistoryLine > mLineHistory.begin() )
  1296. {
  1297. mText.assign( *(--mCurrentHistoryLine) );
  1298. setCursor(llmin((S32)mText.length(), getCursor()));
  1299. }
  1300. else
  1301. {
  1302. reportBadKeystroke();
  1303. }
  1304. handled = TRUE;
  1305. }
  1306. break;
  1308. // handle ctrl-downarrow if we have a history enabled line editor
  1309. case KEY_DOWN:
  1310. if( mHaveHistory  && ( MASK_CONTROL == mask ) )
  1311. {
  1312. if( !mLineHistory.empty() && mCurrentHistoryLine < mLineHistory.end() - 1 )
  1313. {
  1314. mText.assign( *(++mCurrentHistoryLine) );
  1315. setCursor(llmin((S32)mText.length(), getCursor()));
  1316. }
  1317. else
  1318. {
  1319. reportBadKeystroke();
  1320. }
  1321. handled = TRUE;
  1322. }
  1323. break;
  1325. case KEY_RETURN:
  1326. // store sent line in history
  1327. updateHistory();
  1328. break;
  1330. case KEY_ESCAPE:
  1331.     if (mRevertOnEsc && mText.getString() != mPrevText)
  1332. {
  1333. setText(mPrevText);
  1334. // Note, don't set handled, still want to loose focus (won't commit becase text is now unchanged)
  1335. }
  1336. break;
  1338. default:
  1339. break;
  1340. }
  1342. if( !handled && mHandleEditKeysDirectly )
  1343. {
  1344. // Standard edit keys (Ctrl-X, Delete, etc,) are handled here instead of routed by the menu system.
  1345. if( KEY_DELETE == key )
  1346. {
  1347. if( canDoDelete() )
  1348. {
  1349. doDelete();
  1350. }
  1351. else
  1352. {
  1353. reportBadKeystroke();
  1354. }
  1355. handled = TRUE;
  1356. }
  1357. else
  1358. if( MASK_CONTROL & mask )
  1359. {
  1360. if( 'C' == key )
  1361. {
  1362. if( canCopy() )
  1363. {
  1364. copy();
  1365. }
  1366. else
  1367. {
  1368. reportBadKeystroke();
  1369. }
  1370. handled = TRUE;
  1371. }
  1372. else
  1373. if( 'V' == key )
  1374. {
  1375. if( canPaste() )
  1376. {
  1377. paste();
  1378. }
  1379. else
  1380. {
  1381. reportBadKeystroke();
  1382. }
  1383. handled = TRUE;
  1384. }
  1385. else
  1386. if( 'X' == key )
  1387. {
  1388. if( canCut() )
  1389. {
  1390. cut();
  1391. }
  1392. else
  1393. {
  1394. reportBadKeystroke();
  1395. }
  1396. handled = TRUE;
  1397. }
  1398. }
  1399. }
  1400. return handled;
  1401. }
  1404. BOOL LLLineEditor::handleKeyHere(KEY key, MASK mask )
  1405. {
  1406. BOOL handled = FALSE;
  1407. BOOL selection_modified = FALSE;
  1409. if ( gFocusMgr.getKeyboardFocus() == this )
  1410. {
  1411. LLLineEditorRollback rollback( this );
  1413. if( !handled )
  1414. {
  1415. handled = handleSelectionKey( key, mask );
  1416. selection_modified = handled;
  1417. }
  1419. // Handle most keys only if the text editor is writeable.
  1420. if ( !mReadOnly )
  1421. {
  1422. if( !handled )
  1423. {
  1424. handled = handleSpecialKey( key, mask );
  1425. }
  1426. }
  1428. if( handled )
  1429. {
  1430. mKeystrokeTimer.reset();
  1432. // Most keystrokes will make the selection box go away, but not all will.
  1433. if( !selection_modified &&
  1434. KEY_SHIFT != key &&
  1435. KEY_CONTROL != key &&
  1436. KEY_ALT != key &&
  1437. KEY_CAPSLOCK )
  1438. {
  1439. deselect();
  1440. }
  1442. BOOL need_to_rollback = FALSE;
  1444. // If read-only, don't allow changes
  1445. need_to_rollback |= (mReadOnly && (mText.getString() == rollback.getText()));
  1447. // Validate new string and rollback the keystroke if needed.
  1448. need_to_rollback |= (mPrevalidateFunc && !mPrevalidateFunc(mText.getWString()));
  1450. if (need_to_rollback)
  1451. {
  1452. rollback.doRollback(this);
  1454. reportBadKeystroke();
  1455. }
  1457. // Notify owner if requested
  1458. if (!need_to_rollback && handled)
  1459. {
  1460. if (mKeystrokeCallback)
  1461. {
  1462. mKeystrokeCallback(this);
  1463. }
  1464. }
  1465. }
  1466. }
  1468. return handled;
  1469. }
  1472. BOOL LLLineEditor::handleUnicodeCharHere(llwchar uni_char)
  1473. {
  1474. if ((uni_char < 0x20) || (uni_char == 0x7F)) // Control character or DEL
  1475. {
  1476. return FALSE;
  1477. }
  1479. BOOL handled = FALSE;
  1481. if ( (gFocusMgr.getKeyboardFocus() == this) && getVisible() && !mReadOnly)
  1482. {
  1483. handled = TRUE;
  1485. LLLineEditorRollback rollback( this );
  1487. addChar(uni_char);
  1489. mKeystrokeTimer.reset();
  1491. deselect();
  1493. BOOL need_to_rollback = FALSE;
  1495. // Validate new string and rollback the keystroke if needed.
  1496. need_to_rollback |= ( mPrevalidateFunc && !mPrevalidateFunc( mText.getWString() ) );
  1498. if( need_to_rollback )
  1499. {
  1500. rollback.doRollback( this );
  1502. reportBadKeystroke();
  1503. }
  1505. // Notify owner if requested
  1506. if( !need_to_rollback && handled )
  1507. {
  1508. if( mKeystrokeCallback )
  1509. {
  1510. // HACK! The only usage of this callback doesn't do anything with the character.
  1511. // We'll have to do something about this if something ever changes! - Doug
  1512. mKeystrokeCallback( this );
  1513. }
  1514. }
  1515. }
  1516. return handled;
  1517. }
  1520. BOOL LLLineEditor::canDoDelete() const
  1521. {
  1522. return ( !mReadOnly && (!mPassDelete || (hasSelection() || (getCursor() < mText.length()))) );
  1523. }
  1525. void LLLineEditor::doDelete()
  1526. {
  1527. if (canDoDelete())
  1528. {
  1529. // Prepare for possible rollback
  1530. LLLineEditorRollback rollback( this );
  1532. if (hasSelection())
  1533. {
  1534. deleteSelection();
  1535. }
  1536. else if ( getCursor() < mText.length())
  1537. {
  1538. setCursor(getCursor() + 1);
  1539. removeChar();
  1540. }
  1542. // Validate new string and rollback the if needed.
  1543. BOOL need_to_rollback = ( mPrevalidateFunc && !mPrevalidateFunc( mText.getWString() ) );
  1544. if( need_to_rollback )
  1545. {
  1546. rollback.doRollback( this );
  1547. reportBadKeystroke();
  1548. }
  1549. else
  1550. {
  1551. if( mKeystrokeCallback )
  1552. {
  1553. mKeystrokeCallback( this );
  1554. }
  1555. }
  1556. }
  1557. }
  1560. void LLLineEditor::drawBackground()
  1561. {
  1562. bool has_focus = hasFocus();
  1563. LLUIImage* image;
  1564. if ( mReadOnly )
  1565. {
  1566. image = mBgImageDisabled;
  1567. }
  1568. else if ( has_focus )
  1569. {
  1570. image = mBgImageFocused;
  1571. }
  1572. else
  1573. {
  1574. image = mBgImage;
  1575. }
  1577. F32 alpha = getDrawContext().mAlpha;
  1578. // optionally draw programmatic border
  1579. if (has_focus)
  1580. {
  1581. LLColor4 tmp_color = gFocusMgr.getFocusColor();
  1582. tmp_color.setAlpha(alpha);
  1583. image->drawBorder(0, 0, getRect().getWidth(), getRect().getHeight(),
  1584.   tmp_color,
  1585.   gFocusMgr.getFocusFlashWidth());
  1586. }
  1587. LLColor4 tmp_color = UI_VERTEX_COLOR;
  1588. tmp_color.setAlpha(alpha);
  1589. image->draw(getLocalRect(), tmp_color);
  1590. }
  1592. void LLLineEditor::draw()
  1593. {
  1594. F32 alpha = getDrawContext().mAlpha;
  1595. S32 text_len = mText.length();
  1596. static LLUICachedControl<S32> lineeditor_cursor_thickness ("UILineEditorCursorThickness", 0);
  1597. static LLUICachedControl<F32> preedit_marker_brightness ("UIPreeditMarkerBrightness", 0);
  1598. static LLUICachedControl<S32> preedit_marker_gap ("UIPreeditMarkerGap", 0);
  1599. static LLUICachedControl<S32> preedit_marker_position ("UIPreeditMarkerPosition", 0);
  1600. static LLUICachedControl<S32> preedit_marker_thickness ("UIPreeditMarkerThickness", 0);
  1601. static LLUICachedControl<F32> preedit_standout_brightness ("UIPreeditStandoutBrightness", 0);
  1602. static LLUICachedControl<S32> preedit_standout_gap ("UIPreeditStandoutGap", 0);
  1603. static LLUICachedControl<S32> preedit_standout_position ("UIPreeditStandoutPosition", 0);
  1604. static LLUICachedControl<S32> preedit_standout_thickness ("UIPreeditStandoutThickness", 0);
  1606. std::string saved_text;
  1607. if (mDrawAsterixes)
  1608. {
  1609. saved_text = mText.getString();
  1610. std::string text;
  1611. for (S32 i = 0; i < mText.length(); i++)
  1612. {
  1613. text += PASSWORD_ASTERISK;
  1614. }
  1615. mText = text;
  1616. }
  1618. // draw rectangle for the background
  1619. LLRect background( 0, getRect().getHeight(), getRect().getWidth(), 0 );
  1620. background.stretch( -mBorderThickness );
  1622. S32 lineeditor_v_pad = llround((background.getHeight() - mGLFont->getLineHeight())/2);
  1624. drawBackground();
  1626. // draw text
  1628. // With viewer-2 art files, input region is 2 pixels up
  1629. S32 cursor_bottom = background.mBottom + 2;
  1630. S32 cursor_top = background.mTop - 1;
  1632. LLColor4 text_color;
  1633. if (!mReadOnly)
  1634. {
  1635. if (!getTentative())
  1636. {
  1637. text_color = mFgColor.get();
  1638. }
  1639. else
  1640. {
  1641. text_color = mTentativeFgColor.get();
  1642. }
  1643. }
  1644. else
  1645. {
  1646. text_color = mReadOnlyFgColor.get();
  1647. }
  1648. text_color.setAlpha(alpha);
  1649. LLColor4 label_color = mTentativeFgColor.get();
  1650. label_color.setAlpha(alpha);
  1652. if (hasPreeditString())
  1653. {
  1654. // Draw preedit markers.  This needs to be before drawing letters.
  1655. for (U32 i = 0; i < mPreeditStandouts.size(); i++)
  1656. {
  1657. const S32 preedit_left = mPreeditPositions[i];
  1658. const S32 preedit_right = mPreeditPositions[i + 1];
  1659. if (preedit_right > mScrollHPos)
  1660. {
  1661. S32 preedit_pixels_left = findPixelNearestPos(llmax(preedit_left, mScrollHPos) - getCursor());
  1662. S32 preedit_pixels_right = llmin(findPixelNearestPos(preedit_right - getCursor()), background.mRight);
  1663. if (preedit_pixels_left >= background.mRight)
  1664. {
  1665. break;
  1666. }
  1667. if (mPreeditStandouts[i])
  1668. {
  1669. gl_rect_2d(preedit_pixels_left + preedit_standout_gap,
  1670. background.mBottom + preedit_standout_position,
  1671. preedit_pixels_right - preedit_standout_gap - 1,
  1672. background.mBottom + preedit_standout_position - preedit_standout_thickness,
  1673. (text_color * preedit_standout_brightness 
  1674.  + mPreeditBgColor * (1 - preedit_standout_brightness)).setAlpha(alpha/*1.0f*/));
  1675. }
  1676. else
  1677. {
  1678. gl_rect_2d(preedit_pixels_left + preedit_marker_gap,
  1679. background.mBottom + preedit_marker_position,
  1680. preedit_pixels_right - preedit_marker_gap - 1,
  1681. background.mBottom + preedit_marker_position - preedit_marker_thickness,
  1682. (text_color * preedit_marker_brightness
  1683.  + mPreeditBgColor * (1 - preedit_marker_brightness)).setAlpha(alpha/*1.0f*/));
  1684. }
  1685. }
  1686. }
  1687. }
  1689. S32 rendered_text = 0;
  1690. F32 rendered_pixels_right = (F32)mTextLeftEdge;
  1691. F32 text_bottom = (F32)background.mBottom + (F32)lineeditor_v_pad;
  1693. if( (gFocusMgr.getKeyboardFocus() == this) && hasSelection() )
  1694. {
  1695. S32 select_left;
  1696. S32 select_right;
  1697. if( mSelectionStart < getCursor() )
  1698. {
  1699. select_left = mSelectionStart;
  1700. select_right = getCursor();
  1701. }
  1702. else
  1703. {
  1704. select_left = getCursor();
  1705. select_right = mSelectionStart;
  1706. }
  1708. if( select_left > mScrollHPos )
  1709. {
  1710. // unselected, left side
  1711. rendered_text = mGLFont->render( 
  1712. mText, mScrollHPos,
  1713. rendered_pixels_right, text_bottom,
  1714. text_color,
  1715. LLFontGL::LEFT, LLFontGL::BOTTOM,
  1716. 0,
  1717. LLFontGL::NO_SHADOW,
  1718. select_left - mScrollHPos,
  1719. mTextRightEdge - llround(rendered_pixels_right),
  1720. &rendered_pixels_right);
  1721. }
  1723. if( (rendered_pixels_right < (F32)mTextRightEdge) && (rendered_text < text_len) )
  1724. {
  1725. LLColor4 color = mHighlightColor;
  1726. color.setAlpha(alpha);
  1727. // selected middle
  1728. S32 width = mGLFont->getWidth(mText.getWString().c_str(), mScrollHPos + rendered_text, select_right - mScrollHPos - rendered_text);
  1729. width = llmin(width, mTextRightEdge - llround(rendered_pixels_right));
  1730. gl_rect_2d(llround(rendered_pixels_right), cursor_top, llround(rendered_pixels_right)+width, cursor_bottom, color);
  1732. LLColor4 tmp_color( 1.f - text_color.mV[0], 1.f - text_color.mV[1], 1.f - text_color.mV[2], alpha );
  1733. rendered_text += mGLFont->render( 
  1734. mText, mScrollHPos + rendered_text,
  1735. rendered_pixels_right, text_bottom,
  1736. tmp_color,
  1737. LLFontGL::LEFT, LLFontGL::BOTTOM,
  1738. 0,
  1739. LLFontGL::NO_SHADOW,
  1740. select_right - mScrollHPos - rendered_text,
  1741. mTextRightEdge - llround(rendered_pixels_right),
  1742. &rendered_pixels_right);
  1743. }
  1745. if( (rendered_pixels_right < (F32)mTextRightEdge) && (rendered_text < text_len) )
  1746. {
  1747. // unselected, right side
  1748. mGLFont->render( 
  1749. mText, mScrollHPos + rendered_text,
  1750. rendered_pixels_right, text_bottom,
  1751. text_color,
  1752. LLFontGL::LEFT, LLFontGL::BOTTOM,
  1753. 0,
  1754. LLFontGL::NO_SHADOW,
  1755. S32_MAX,
  1756. mTextRightEdge - llround(rendered_pixels_right),
  1757. &rendered_pixels_right);
  1758. }
  1759. }
  1760. else
  1761. {
  1762. mGLFont->render( 
  1763. mText, mScrollHPos, 
  1764. rendered_pixels_right, text_bottom,
  1765. text_color,
  1766. LLFontGL::LEFT, LLFontGL::BOTTOM,
  1767. 0,
  1768. LLFontGL::NO_SHADOW,
  1769. S32_MAX,
  1770. mTextRightEdge - llround(rendered_pixels_right),
  1771. &rendered_pixels_right);
  1772. }
  1773. #if 1 // for when we're ready for image art.
  1774. mBorder->setVisible(FALSE); // no more programmatic art.
  1775. #endif
  1777. // If we're editing...
  1778. if( hasFocus())
  1779. {
  1780. //mBorder->setVisible(TRUE); // ok, programmer art just this once.
  1781. // (Flash the cursor every half second)
  1782. if (!mReadOnly && gFocusMgr.getAppHasFocus())
  1783. {
  1784. F32 elapsed = mKeystrokeTimer.getElapsedTimeF32();
  1785. if( (elapsed < CURSOR_FLASH_DELAY ) || (S32(elapsed * 2) & 1) )
  1786. {
  1787. S32 cursor_left = findPixelNearestPos();
  1788. cursor_left -= lineeditor_cursor_thickness / 2;
  1789. S32 cursor_right = cursor_left + lineeditor_cursor_thickness;
  1790. if (LL_KIM_OVERWRITE == gKeyboard->getInsertMode() && !hasSelection())
  1791. {
  1792. const LLWString space(utf8str_to_wstring(std::string(" ")));
  1793. S32 wswidth = mGLFont->getWidth(space.c_str());
  1794. S32 width = mGLFont->getWidth(mText.getWString().c_str(), getCursor(), 1) + 1;
  1795. cursor_right = cursor_left + llmax(wswidth, width);
  1796. }
  1797. // Use same color as text for the Cursor
  1798. gl_rect_2d(cursor_left, cursor_top,
  1799. cursor_right, cursor_bottom, text_color);
  1800. if (LL_KIM_OVERWRITE == gKeyboard->getInsertMode() && !hasSelection())
  1801. {
  1802. LLColor4 tmp_color( 1.f - text_color.mV[0], 1.f - text_color.mV[1], 1.f - text_color.mV[2], alpha );
  1803. mGLFont->render(mText, getCursor(), (F32)(cursor_left + lineeditor_cursor_thickness / 2), text_bottom, 
  1804. tmp_color,
  1805. LLFontGL::LEFT, LLFontGL::BOTTOM,
  1806. 0,
  1807. LLFontGL::NO_SHADOW,
  1808. 1);
  1809. }
  1811. // Make sure the IME is in the right place
  1812. S32 pixels_after_scroll = findPixelNearestPos(); // RCalculcate for IME position
  1813. LLRect screen_pos = calcScreenRect();
  1814. LLCoordGL ime_pos( screen_pos.mLeft + pixels_after_scroll, screen_pos.mTop - lineeditor_v_pad );
  1816. ime_pos.mX = (S32) (ime_pos.mX * LLUI::sGLScaleFactor.mV[VX]);
  1817. ime_pos.mY = (S32) (ime_pos.mY * LLUI::sGLScaleFactor.mV[VY]);
  1818. getWindow()->setLanguageTextInput( ime_pos );
  1819. }
  1820. }
  1822. //draw label if no text is provided
  1823. //but we should draw it in a different color
  1824. //to give indication that it is not text you typed in
  1825. if (0 == mText.length() && mReadOnly)
  1826. {
  1827. mGLFont->render(mLabel.getWString(), 0,
  1828. mTextLeftEdge, (F32)text_bottom,
  1829. label_color,
  1830. LLFontGL::LEFT,
  1831. LLFontGL::BOTTOM,
  1832. 0,
  1833. LLFontGL::NO_SHADOW,
  1834. S32_MAX,
  1835. mTextRightEdge - llround(rendered_pixels_right),
  1836. &rendered_pixels_right, FALSE);
  1837. }
  1840. // Draw children (border)
  1841. //mBorder->setVisible(TRUE);
  1842. mBorder->setKeyboardFocusHighlight( TRUE );
  1843. LLView::draw();
  1844. mBorder->setKeyboardFocusHighlight( FALSE );
  1845. //mBorder->setVisible(FALSE);
  1846. }
  1847. else // does not have keyboard input
  1848. {
  1849. // draw label if no text provided
  1850. if (0 == mText.length())
  1851. {
  1852. mGLFont->render(mLabel.getWString(), 0,
  1853. mTextLeftEdge, (F32)text_bottom,
  1854. label_color,
  1855. LLFontGL::LEFT,
  1856. LLFontGL::BOTTOM,
  1857. 0,
  1858. LLFontGL::NO_SHADOW,
  1859. S32_MAX,
  1860. mTextRightEdge - llround(rendered_pixels_right),
  1861. &rendered_pixels_right, FALSE);
  1862. }
  1863. // Draw children (border)
  1864. LLView::draw();
  1865. }
  1867. if (mDrawAsterixes)
  1868. {
  1869. mText = saved_text;
  1870. }
  1871. }
  1874. // Returns the local screen space X coordinate associated with the text cursor position.
  1875. S32 LLLineEditor::findPixelNearestPos(const S32 cursor_offset) const
  1876. {
  1877. S32 dpos = getCursor() - mScrollHPos + cursor_offset;
  1878. S32 result = mGLFont->getWidth(mText.getWString().c_str(), mScrollHPos, dpos) + mTextLeftEdge;
  1879. return result;
  1880. }
  1882. void LLLineEditor::reportBadKeystroke()
  1883. {
  1884. make_ui_sound("UISndBadKeystroke");
  1885. }
  1887. //virtual
  1888. void LLLineEditor::clear()
  1889. {
  1890. mText.clear();
  1891. setCursor(0);
  1892. }
  1894. //virtual
  1895. void LLLineEditor::onTabInto()
  1896. {
  1897. selectAll();
  1898. }
  1900. //virtual
  1901. BOOL LLLineEditor::acceptsTextInput() const
  1902. {
  1903. return TRUE;
  1904. }
  1906. // Start or stop the editor from accepting text-editing keystrokes
  1907. void LLLineEditor::setFocus( BOOL new_state )
  1908. {
  1909. BOOL old_state = hasFocus();
  1911. if (!new_state)
  1912. {
  1913. getWindow()->allowLanguageTextInput(this, FALSE);
  1914. }
  1917. // getting focus when we didn't have it before, and we want to select all
  1918. if (!old_state && new_state && mSelectAllonFocusReceived)
  1919. {
  1920. selectAll();
  1921. // We don't want handleMouseUp() to "finish" the selection (and thereby
  1922. // set mSelectionEnd to where the mouse is), so we finish the selection 
  1923. // here.
  1924. mIsSelecting = FALSE;
  1925. }
  1927. if( new_state )
  1928. {
  1929. gEditMenuHandler = this;
  1931. // Don't start the cursor flashing right away
  1932. mKeystrokeTimer.reset();
  1933. }
  1934. else
  1935. {
  1936. // Not really needed, since loss of keyboard focus should take care of this,
  1937. // but limited paranoia is ok.
  1938. if( gEditMenuHandler == this )
  1939. {
  1940. gEditMenuHandler = NULL;
  1941. }
  1943. endSelection();
  1944. }
  1946. LLUICtrl::setFocus( new_state );
  1948. if (new_state)
  1949. {
  1950. // Allow Language Text Input only when this LineEditor has
  1951. // no prevalidate function attached.  This criterion works
  1952. // fine on 1.15.0.2, since all prevalidate func reject any
  1953. // non-ASCII characters.  I'm not sure on future versions,
  1954. // however.
  1955. getWindow()->allowLanguageTextInput(this, mPrevalidateFunc == NULL);
  1956. }
  1957. }
  1959. //virtual 
  1960. void LLLineEditor::setRect(const LLRect& rect)
  1961. {
  1962. LLUICtrl::setRect(rect);
  1963. if (mBorder)
  1964. {
  1965. LLRect border_rect = mBorder->getRect();
  1966. // Scalable UI somehow made these rectangles off-by-one.
  1967. // I don't know why. JC
  1968. border_rect.setOriginAndSize(border_rect.mLeft, border_rect.mBottom, 
  1969. rect.getWidth()-1, rect.getHeight()-1);
  1970. mBorder->setRect(border_rect);
  1971. }
  1972. }
  1974. void LLLineEditor::setPrevalidate(LLTextValidate::validate_func_t func)
  1975. {
  1976. mPrevalidateFunc = func;
  1977. updateAllowingLanguageInput();
  1978. }
  1980. // static
  1981. BOOL LLLineEditor::postvalidateFloat(const std::string &str)
  1982. {
  1983. LLLocale locale(LLLocale::USER_LOCALE);
  1985. BOOL success = TRUE;
  1986. BOOL has_decimal = FALSE;
  1987. BOOL has_digit = FALSE;
  1989. LLWString trimmed = utf8str_to_wstring(str);
  1990. LLWStringUtil::trim(trimmed);
  1991. S32 len = trimmed.length();
  1992. if( 0 < len )
  1993. {
  1994. S32 i = 0;
  1996. // First character can be a negative sign
  1997. if( '-' == trimmed[0] )
  1998. {
  1999. i++;
  2000. }
  2002. // May be a comma or period, depending on the locale
  2003. llwchar decimal_point = (llwchar)LLResMgr::getInstance()->getDecimalPoint();
  2005. for( ; i < len; i++ )
  2006. {
  2007. if( decimal_point == trimmed[i] )
  2008. {
  2009. if( has_decimal )
  2010. {
  2011. // can't have two
  2012. success = FALSE;
  2013. break;
  2014. }
  2015. else
  2016. {
  2017. has_decimal = TRUE;
  2018. }
  2019. }
  2020. else
  2021. if( LLStringOps::isDigit( trimmed[i] ) )
  2022. {
  2023. has_digit = TRUE;
  2024. }
  2025. else
  2026. {
  2027. success = FALSE;
  2028. break;
  2029. }
  2030. }
  2031. }
  2033. // Gotta have at least one
  2034. success = has_digit;
  2036. return success;
  2037. }
  2039. void LLLineEditor::onMouseCaptureLost()
  2040. {
  2041. endSelection();
  2042. }
  2045. void LLLineEditor::setSelectAllonFocusReceived(BOOL b)
  2046. {
  2047. mSelectAllonFocusReceived = b;
  2048. }
  2051. void LLLineEditor::setKeystrokeCallback(callback_t callback, void* user_data)
  2052. {
  2053. mKeystrokeCallback = boost::bind(callback, _1, user_data);
  2054. }
  2057. BOOL LLLineEditor::setTextArg( const std::string& key, const LLStringExplicit& text )
  2058. {
  2059. mText.setArg(key, text);
  2060. return TRUE;
  2061. }
  2063. BOOL LLLineEditor::setLabelArg( const std::string& key, const LLStringExplicit& text )
  2064. {
  2065. mLabel.setArg(key, text);
  2066. return TRUE;
  2067. }
  2070. void LLLineEditor::updateAllowingLanguageInput()
  2071. {
  2072. // Allow Language Text Input only when this LineEditor has
  2073. // no prevalidate function attached (as long as other criteria
  2074. // common to LLTextEditor).  This criterion works
  2075. // fine on 1.15.0.2, since all prevalidate func reject any
  2076. // non-ASCII characters.  I'm not sure on future versions,
  2077. // however...
  2078. LLWindow* window = getWindow();
  2079. if (!window)
  2080. {
  2081. // test app, no window available
  2082. return;
  2083. }
  2084. if (hasFocus() && !mReadOnly && !mDrawAsterixes && mPrevalidateFunc == NULL)
  2085. {
  2086. window->allowLanguageTextInput(this, TRUE);
  2087. }
  2088. else
  2089. {
  2090. window->allowLanguageTextInput(this, FALSE);
  2091. }
  2092. }
  2094. BOOL LLLineEditor::hasPreeditString() const
  2095. {
  2096. return (mPreeditPositions.size() > 1);
  2097. }
  2099. void LLLineEditor::resetPreedit()
  2100. {
  2101. if (hasSelection())
  2102. {
  2103. if (hasPreeditString())
  2104. {
  2105. llwarns << "Preedit and selection!" << llendl;
  2106. deselect();
  2107. }
  2108. else
  2109. {
  2110. deleteSelection();
  2111. }
  2112. }
  2113. if (hasPreeditString())
  2114. {
  2115. const S32 preedit_pos = mPreeditPositions.front();
  2116. mText.erase(preedit_pos, mPreeditPositions.back() - preedit_pos);
  2117. mText.insert(preedit_pos, mPreeditOverwrittenWString);
  2118. setCursor(preedit_pos);
  2120. mPreeditWString.clear();
  2121. mPreeditOverwrittenWString.clear();
  2122. mPreeditPositions.clear();
  2124. // Don't reset key stroke timer nor invoke keystroke callback,
  2125. // because a call to updatePreedit should be follow soon in 
  2126. // normal course of operation, and timer and callback will be 
  2127. // maintained there.  Doing so here made an odd sound.  (VWR-3410) 
  2128. }
  2129. }
  2131. void LLLineEditor::updatePreedit(const LLWString &preedit_string,
  2132. const segment_lengths_t &preedit_segment_lengths, const standouts_t &preedit_standouts, S32 caret_position)
  2133. {
  2134. // Just in case.
  2135. if (mReadOnly)
  2136. {
  2137. return;
  2138. }
  2140. // Note that call to updatePreedit is always preceeded by resetPreedit,
  2141. // so we have no existing selection/preedit.
  2143. S32 insert_preedit_at = getCursor();
  2145. mPreeditWString = preedit_string;
  2146. mPreeditPositions.resize(preedit_segment_lengths.size() + 1);
  2147. S32 position = insert_preedit_at;
  2148. for (segment_lengths_t::size_type i = 0; i < preedit_segment_lengths.size(); i++)
  2149. {
  2150. mPreeditPositions[i] = position;
  2151. position += preedit_segment_lengths[i];
  2152. }
  2153. mPreeditPositions.back() = position;
  2154. if (LL_KIM_OVERWRITE == gKeyboard->getInsertMode())
  2155. {
  2156. mPreeditOverwrittenWString.assign( LLWString( mText, insert_preedit_at, mPreeditWString.length() ) );
  2157. mText.erase(insert_preedit_at, mPreeditWString.length());
  2158. }
  2159. else
  2160. {
  2161. mPreeditOverwrittenWString.clear();
  2162. }
  2163. mText.insert(insert_preedit_at, mPreeditWString);
  2165. mPreeditStandouts = preedit_standouts;
  2167. setCursor(position);
  2168. setCursor(mPreeditPositions.front() + caret_position);
  2170. // Update of the preedit should be caused by some key strokes.
  2171. mKeystrokeTimer.reset();
  2172. if( mKeystrokeCallback )
  2173. {
  2174. mKeystrokeCallback( this );
  2175. }
  2176. }
  2178. BOOL LLLineEditor::getPreeditLocation(S32 query_offset, LLCoordGL *coord, LLRect *bounds, LLRect *control) const
  2179. {
  2180. if (control)
  2181. {
  2182. LLRect control_rect_screen;
  2183. localRectToScreen(getRect(), &control_rect_screen);
  2184. LLUI::screenRectToGL(control_rect_screen, control);
  2185. }
  2187. S32 preedit_left_column, preedit_right_column;
  2188. if (hasPreeditString())
  2189. {
  2190. preedit_left_column = mPreeditPositions.front();
  2191. preedit_right_column = mPreeditPositions.back();
  2192. }
  2193. else
  2194. {
  2195. preedit_left_column = preedit_right_column = getCursor();
  2196. }
  2197. if (preedit_right_column < mScrollHPos)
  2198. {
  2199. // This should not occure...
  2200. return FALSE;
  2201. }
  2203. const S32 query = (query_offset >= 0 ? preedit_left_column + query_offset : getCursor());
  2204. if (query < mScrollHPos || query < preedit_left_column || query > preedit_right_column)
  2205. {
  2206. return FALSE;
  2207. }
  2209. if (coord)
  2210. {
  2211. S32 query_local = findPixelNearestPos(query - getCursor());
  2212. S32 query_screen_x, query_screen_y;
  2213. localPointToScreen(query_local, getRect().getHeight() / 2, &query_screen_x, &query_screen_y);
  2214. LLUI::screenPointToGL(query_screen_x, query_screen_y, &coord->mX, &coord->mY);
  2215. }
  2217. if (bounds)
  2218. {
  2219. S32 preedit_left_local = findPixelNearestPos(llmax(preedit_left_column, mScrollHPos) - getCursor());
  2220. S32 preedit_right_local = llmin(findPixelNearestPos(preedit_right_column - getCursor()), getRect().getWidth() - mBorderThickness);
  2221. if (preedit_left_local > preedit_right_local)
  2222. {
  2223. // Is this condition possible?
  2224. preedit_right_local = preedit_left_local;
  2225. }
  2227. LLRect preedit_rect_local(preedit_left_local, getRect().getHeight(), preedit_right_local, 0);
  2228. LLRect preedit_rect_screen;
  2229. localRectToScreen(preedit_rect_local, &preedit_rect_screen);
  2230. LLUI::screenRectToGL(preedit_rect_screen, bounds);
  2231. }
  2233. return TRUE;
  2234. }
  2236. void LLLineEditor::getPreeditRange(S32 *position, S32 *length) const
  2237. {
  2238. if (hasPreeditString())
  2239. {
  2240. *position = mPreeditPositions.front();
  2241. *length = mPreeditPositions.back() - mPreeditPositions.front();
  2242. }
  2243. else
  2244. {
  2245. *position = mCursorPos;
  2246. *length = 0;
  2247. }
  2248. }
  2250. void LLLineEditor::getSelectionRange(S32 *position, S32 *length) const
  2251. {
  2252. if (hasSelection())
  2253. {
  2254. *position = llmin(mSelectionStart, mSelectionEnd);
  2255. *length = llabs(mSelectionStart - mSelectionEnd);
  2256. }
  2257. else
  2258. {
  2259. *position = mCursorPos;
  2260. *length = 0;
  2261. }
  2262. }
  2264. void LLLineEditor::markAsPreedit(S32 position, S32 length)
  2265. {
  2266. deselect();
  2267. setCursor(position);
  2268. if (hasPreeditString())
  2269. {
  2270. llwarns << "markAsPreedit invoked when hasPreeditString is true." << llendl;
  2271. }
  2272. mPreeditWString.assign( LLWString( mText.getWString(), position, length ) );
  2273. if (length > 0)
  2274. {
  2275. mPreeditPositions.resize(2);
  2276. mPreeditPositions[0] = position;
  2277. mPreeditPositions[1] = position + length;
  2278. mPreeditStandouts.resize(1);
  2279. mPreeditStandouts[0] = FALSE;
  2280. }
  2281. else
  2282. {
  2283. mPreeditPositions.clear();
  2284. mPreeditStandouts.clear();
  2285. }
  2286. if (LL_KIM_OVERWRITE == gKeyboard->getInsertMode())
  2287. {
  2288. mPreeditOverwrittenWString = mPreeditWString;
  2289. }
  2290. else
  2291. {
  2292. mPreeditOverwrittenWString.clear();
  2293. }
  2294. }
  2296. S32 LLLineEditor::getPreeditFontSize() const
  2297. {
  2298. return llround(mGLFont->getLineHeight() * LLUI::sGLScaleFactor.mV[VY]);
  2299. }
  2301. void LLLineEditor::setReplaceNewlinesWithSpaces(BOOL replace)
  2302. {
  2303. mReplaceNewlinesWithSpaces = replace;
  2304. }
  2306. LLWString LLLineEditor::getConvertedText() const
  2307. {
  2308. LLWString text = getWText();
  2309. LLWStringUtil::trim(text);
  2310. if (!mReplaceNewlinesWithSpaces)
  2311. {
  2312. LLWStringUtil::replaceChar(text,182,'n'); // Convert paragraph symbols back into newlines.
  2313. }
  2314. return text;
  2315. }
  2317. void LLLineEditor::showContextMenu(S32 x, S32 y)
  2318. {
  2319. LLContextMenu* menu = static_cast<LLContextMenu*>(mContextMenuHandle.get());
  2321. if (menu)
  2322. {
  2323. gEditMenuHandler = this;
  2325. S32 screen_x, screen_y;
  2326. localPointToScreen(x, y, &screen_x, &screen_y);
  2327. menu->show(screen_x, screen_y);
  2328. }
  2329. }
  2331. void LLLineEditor::setContextMenu(LLContextMenu* new_context_menu)
  2332. {
  2333. if (new_context_menu)
  2334. mContextMenuHandle = new_context_menu->getHandle();
  2335. else
  2336. mContextMenuHandle.markDead();
  2337. }