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

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

游戏引擎

开发平台：

C++ Builder

lltexteditor.cpp：源码内容
  1. /** 
  2.  * @file lltexteditor.cpp
  3.  *
  4.  * $LicenseInfo:firstyear=2001&license=viewergpl$
  5.  * 
  6.  * Copyright (c) 2001-2010, Linden Research, Inc.
  7.  * 
  8.  * Second Life Viewer Source Code
  9.  * The source code in this file ("Source Code") is provided by Linden Lab
  10.  * to you under the terms of the GNU General Public License, version 2.0
  11.  * ("GPL"), unless you have obtained a separate licensing agreement
  12.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  13.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  14.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  15.  * 
  16.  * There are special exceptions to the terms and conditions of the GPL as
  17.  * it is applied to this Source Code. View the full text of the exception
  18.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  19.  * online at
  20.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  21.  * 
  22.  * By copying, modifying or distributing this software, you acknowledge
  23.  * that you have read and understood your obligations described above,
  24.  * and agree to abide by those obligations.
  25.  * 
  26.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  27.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  28.  * COMPLETENESS OR PERFORMANCE.
  29.  * $/LicenseInfo$
  30.  */
  32. // Text editor widget to let users enter a a multi-line ASCII document.
  34. #include "linden_common.h"
  36. #define LLTEXTEDITOR_CPP
  37. #include "lltexteditor.h"
  39. #include "llfontfreetype.h" // for LLFontFreetype::FIRST_CHAR
  40. #include "llfontgl.h"
  41. #include "llgl.h" // LLGLSUIDefault()
  42. #include "lllocalcliprect.h"
  43. #include "llrender.h"
  44. #include "llui.h"
  45. #include "lluictrlfactory.h"
  46. #include "llrect.h"
  47. #include "llfocusmgr.h"
  48. #include "lltimer.h"
  49. #include "llmath.h"
  51. #include "llclipboard.h"
  52. #include "llscrollbar.h"
  53. #include "llstl.h"
  54. #include "llstring.h"
  55. #include "llkeyboard.h"
  56. #include "llkeywords.h"
  57. #include "llundo.h"
  58. #include "llviewborder.h"
  59. #include "llcontrol.h"
  60. #include "llwindow.h"
  61. #include "lltextparser.h"
  62. #include "llscrollcontainer.h"
  63. #include "llpanel.h"
  64. #include "llurlregistry.h"
  65. #include "lltooltip.h"
  66. #include "llmenugl.h"
  68. #include <queue>
  69. #include "llcombobox.h"
  71. // 
  72. // Globals
  73. //
  74. static LLDefaultChildRegistry::Register<LLTextEditor> r("simple_text_editor");
  76. // Compiler optimization, generate extern template
  77. template class LLTextEditor* LLView::getChild<class LLTextEditor>(
  78. const std::string& name, BOOL recurse) const;
  80. //
  81. // Constants
  82. //
  83. const S32 UI_TEXTEDITOR_LINE_NUMBER_MARGIN = 32;
  84. const S32 UI_TEXTEDITOR_LINE_NUMBER_DIGITS = 4;
  85. const S32 SPACES_PER_TAB = 4;
  87. ///////////////////////////////////////////////////////////////////
  89. class LLTextEditor::TextCmdInsert : public LLTextBase::TextCmd
  90. {
  91. public:
  92. TextCmdInsert(S32 pos, BOOL group_with_next, const LLWString &ws, LLTextSegmentPtr segment)
  93. : TextCmd(pos, group_with_next, segment), mWString(ws)
  94. {
  95. }
  96. virtual ~TextCmdInsert() {}
  97. virtual BOOL execute( LLTextBase* editor, S32* delta )
  98. {
  99. *delta = insert(editor, getPosition(), mWString );
  100. LLWStringUtil::truncate(mWString, *delta);
  101. //mWString = wstring_truncate(mWString, *delta);
  102. return (*delta != 0);
  103. }
  104. virtual S32 undo( LLTextBase* editor )
  105. {
  106. remove(editor, getPosition(), mWString.length() );
  107. return getPosition();
  108. }
  109. virtual S32 redo( LLTextBase* editor )
  110. {
  111. insert(editor, getPosition(), mWString );
  112. return getPosition() + mWString.length();
  113. }
  115. private:
  116. LLWString mWString;
  117. };
  119. ///////////////////////////////////////////////////////////////////
  120. class LLTextEditor::TextCmdAddChar : public LLTextBase::TextCmd
  121. {
  122. public:
  123. TextCmdAddChar( S32 pos, BOOL group_with_next, llwchar wc, LLTextSegmentPtr segment)
  124. : TextCmd(pos, group_with_next, segment), mWString(1, wc), mBlockExtensions(FALSE)
  125. {
  126. }
  127. virtual void blockExtensions()
  128. {
  129. mBlockExtensions = TRUE;
  130. }
  131. virtual BOOL canExtend(S32 pos) const
  132. {
  133. // cannot extend text with custom segments
  134. if (!mSegments.empty()) return FALSE;
  136. return !mBlockExtensions && (pos == getPosition() + (S32)mWString.length());
  137. }
  138. virtual BOOL execute( LLTextBase* editor, S32* delta )
  139. {
  140. *delta = insert(editor, getPosition(), mWString);
  141. LLWStringUtil::truncate(mWString, *delta);
  142. //mWString = wstring_truncate(mWString, *delta);
  143. return (*delta != 0);
  144. }
  145. virtual BOOL extendAndExecute( LLTextBase* editor, S32 pos, llwchar wc, S32* delta )
  146. { 
  147. LLWString ws;
  148. ws += wc;
  150. *delta = insert(editor, pos, ws);
  151. if( *delta > 0 )
  152. {
  153. mWString += wc;
  154. }
  155. return (*delta != 0);
  156. }
  157. virtual S32 undo( LLTextBase* editor )
  158. {
  159. remove(editor, getPosition(), mWString.length() );
  160. return getPosition();
  161. }
  162. virtual S32 redo( LLTextBase* editor )
  163. {
  164. insert(editor, getPosition(), mWString );
  165. return getPosition() + mWString.length();
  166. }
  168. private:
  169. LLWString mWString;
  170. BOOL mBlockExtensions;
  172. };
  174. ///////////////////////////////////////////////////////////////////
  176. class LLTextEditor::TextCmdOverwriteChar : public LLTextBase::TextCmd
  177. {
  178. public:
  179. TextCmdOverwriteChar( S32 pos, BOOL group_with_next, llwchar wc)
  180. : TextCmd(pos, group_with_next), mChar(wc), mOldChar(0) {}
  182. virtual BOOL execute( LLTextBase* editor, S32* delta )
  183. { 
  184. mOldChar = editor->getWText()[getPosition()];
  185. overwrite(editor, getPosition(), mChar);
  186. *delta = 0;
  187. return TRUE;
  188. }
  189. virtual S32 undo( LLTextBase* editor )
  190. {
  191. overwrite(editor, getPosition(), mOldChar);
  192. return getPosition();
  193. }
  194. virtual S32 redo( LLTextBase* editor )
  195. {
  196. overwrite(editor, getPosition(), mChar);
  197. return getPosition()+1;
  198. }
  200. private:
  201. llwchar mChar;
  202. llwchar mOldChar;
  203. };
  205. ///////////////////////////////////////////////////////////////////
  207. class LLTextEditor::TextCmdRemove : public LLTextBase::TextCmd
  208. {
  209. public:
  210. TextCmdRemove( S32 pos, BOOL group_with_next, S32 len, segment_vec_t& segments ) :
  211. TextCmd(pos, group_with_next), mLen(len)
  212. {
  213. std::swap(mSegments, segments);
  214. }
  215. virtual BOOL execute( LLTextBase* editor, S32* delta )
  216. { 
  217. mWString = editor->getWText().substr(getPosition(), mLen);
  218. *delta = remove(editor, getPosition(), mLen );
  219. return (*delta != 0);
  220. }
  221. virtual S32 undo( LLTextBase* editor )
  222. {
  223. insert(editor, getPosition(), mWString);
  224. return getPosition() + mWString.length();
  225. }
  226. virtual S32 redo( LLTextBase* editor )
  227. {
  228. remove(editor, getPosition(), mLen );
  229. return getPosition();
  230. }
  231. private:
  232. LLWString mWString;
  233. S32 mLen;
  234. };
  237. ///////////////////////////////////////////////////////////////////
  238. LLTextEditor::Params::Params()
  239. : default_text("default_text"),
  240. prevalidate_callback("prevalidate_callback"),
  241. embedded_items("embedded_items", false),
  242. ignore_tab("ignore_tab", true),
  243. handle_edit_keys_directly("handle_edit_keys_directly", false),
  244. show_line_numbers("show_line_numbers", false),
  245. default_color("default_color"),
  246.     commit_on_focus_lost("commit_on_focus_lost", false),
  247. show_context_menu("show_context_menu")
  248. {
  249. addSynonym(prevalidate_callback, "text_type");
  250. }
  252. LLTextEditor::LLTextEditor(const LLTextEditor::Params& p) :
  253. LLTextBase(p),
  254. mBaseDocIsPristine(TRUE),
  255. mPristineCmd( NULL ),
  256. mLastCmd( NULL ),
  257. mDefaultColor( p.default_color() ),
  258. mShowLineNumbers ( p.show_line_numbers ),
  259. mCommitOnFocusLost( p.commit_on_focus_lost),
  260. mAllowEmbeddedItems( p.embedded_items ),
  261. mHandleEditKeysDirectly( p.handle_edit_keys_directly ),
  262. mMouseDownX(0),
  263. mMouseDownY(0),
  264. mTabsToNextField(p.ignore_tab),
  265. mPrevalidateFunc(p.prevalidate_callback()),
  266. mContextMenu(NULL),
  267. mShowContextMenu(p.show_context_menu)
  268. {
  269. mDefaultFont = p.font;
  271. mSourceID.generate();
  273. //FIXME: use image?
  274. LLViewBorder::Params params;
  275. params.name = "text ed border";
  276. params.rect = getLocalRect();
  277. params.bevel_style = LLViewBorder::BEVEL_IN;
  278. params.border_thickness = 1;
  279. params.visible = p.border_visible;
  280. mBorder = LLUICtrlFactory::create<LLViewBorder> (params);
  281. addChild( mBorder );
  283. setText(p.default_text());
  285. if (mShowLineNumbers)
  286. {
  287. mHPad += UI_TEXTEDITOR_LINE_NUMBER_MARGIN;
  288. updateRects();
  289. }
  290. }
  292. void LLTextEditor::initFromParams( const LLTextEditor::Params& p)
  293. {
  294. LLTextBase::initFromParams(p);
  296. if (p.commit_on_focus_lost.isProvided())
  297. {
  298. mCommitOnFocusLost = p.commit_on_focus_lost;
  299. }
  301. updateAllowingLanguageInput();
  302. }
  304. LLTextEditor::~LLTextEditor()
  305. {
  306. gFocusMgr.releaseFocusIfNeeded( this ); // calls onCommit() while LLTextEditor still valid
  308. // Route menu back to the default
  309. if( gEditMenuHandler == this )
  310. {
  311. gEditMenuHandler = NULL;
  312. }
  314. // Scrollbar is deleted by LLView
  315. std::for_each(mUndoStack.begin(), mUndoStack.end(), DeletePointer());
  317. // context menu is owned by menu holder, not us
  318. //delete mContextMenu;
  319. }
  321. ////////////////////////////////////////////////////////////
  322. // LLTextEditor
  323. // Public methods
  325. void LLTextEditor::setText(const LLStringExplicit &utf8str, const LLStyle::Params& input_params)
  326. {
  327. // validate incoming text if necessary
  328. if (mPrevalidateFunc)
  329. {
  330. LLWString test_text = utf8str_to_wstring(utf8str);
  331. if (!mPrevalidateFunc(test_text))
  332. {
  333. // not valid text, nothing to do
  334. return;
  335. }
  336. }
  338. blockUndo();
  339. deselect();
  341. LLTextBase::setText(utf8str, input_params);
  343. resetDirty();
  344. }
  346. void LLTextEditor::selectNext(const std::string& search_text_in, BOOL case_insensitive, BOOL wrap)
  347. {
  348. if (search_text_in.empty())
  349. {
  350. return;
  351. }
  353. LLWString text = getWText();
  354. LLWString search_text = utf8str_to_wstring(search_text_in);
  355. if (case_insensitive)
  356. {
  357. LLWStringUtil::toLower(text);
  358. LLWStringUtil::toLower(search_text);
  359. }
  361. if (mIsSelecting)
  362. {
  363. LLWString selected_text = text.substr(mSelectionEnd, mSelectionStart - mSelectionEnd);
  365. if (selected_text == search_text)
  366. {
  367. // We already have this word selected, we are searching for the next.
  368. setCursorPos(mCursorPos + search_text.size());
  369. }
  370. }
  372. S32 loc = text.find(search_text,mCursorPos);
  374. // If Maybe we wrapped, search again
  375. if (wrap && (-1 == loc))
  376. {
  377. loc = text.find(search_text);
  378. }
  380. // If still -1, then search_text just isn't found.
  381.     if (-1 == loc)
  382. {
  383. mIsSelecting = FALSE;
  384. mSelectionEnd = 0;
  385. mSelectionStart = 0;
  386. return;
  387. }
  389. setCursorPos(loc);
  391. mIsSelecting = TRUE;
  392. mSelectionEnd = mCursorPos;
  393. mSelectionStart = llmin((S32)getLength(), (S32)(mCursorPos + search_text.size()));
  394. }
  396. BOOL LLTextEditor::replaceText(const std::string& search_text_in, const std::string& replace_text,
  397.    BOOL case_insensitive, BOOL wrap)
  398. {
  399. BOOL replaced = FALSE;
  401. if (search_text_in.empty())
  402. {
  403. return replaced;
  404. }
  406. LLWString search_text = utf8str_to_wstring(search_text_in);
  407. if (mIsSelecting)
  408. {
  409. LLWString text = getWText();
  410. LLWString selected_text = text.substr(mSelectionEnd, mSelectionStart - mSelectionEnd);
  412. if (case_insensitive)
  413. {
  414. LLWStringUtil::toLower(selected_text);
  415. LLWStringUtil::toLower(search_text);
  416. }
  418. if (selected_text == search_text)
  419. {
  420. insertText(replace_text);
  421. replaced = TRUE;
  422. }
  423. }
  425. selectNext(search_text_in, case_insensitive, wrap);
  426. return replaced;
  427. }
  429. void LLTextEditor::replaceTextAll(const std::string& search_text, const std::string& replace_text, BOOL case_insensitive)
  430. {
  431. startOfDoc();
  432. selectNext(search_text, case_insensitive, FALSE);
  434. BOOL replaced = TRUE;
  435. while ( replaced )
  436. {
  437. replaced = replaceText(search_text,replace_text, case_insensitive, FALSE);
  438. }
  439. }
  441. S32 LLTextEditor::prevWordPos(S32 cursorPos) const
  442. {
  443. LLWString wtext(getWText());
  444. while( (cursorPos > 0) && (wtext[cursorPos-1] == ' ') )
  445. {
  446. cursorPos--;
  447. }
  448. while( (cursorPos > 0) && LLWStringUtil::isPartOfWord( wtext[cursorPos-1] ) )
  449. {
  450. cursorPos--;
  451. }
  452. return cursorPos;
  453. }
  455. S32 LLTextEditor::nextWordPos(S32 cursorPos) const
  456. {
  457. LLWString wtext(getWText());
  458. while( (cursorPos < getLength()) && LLWStringUtil::isPartOfWord( wtext[cursorPos] ) )
  459. {
  460. cursorPos++;
  461. } 
  462. while( (cursorPos < getLength()) && (wtext[cursorPos] == ' ') )
  463. {
  464. cursorPos++;
  465. }
  466. return cursorPos;
  467. }
  469. const LLTextSegmentPtr LLTextEditor::getPreviousSegment() const
  470. {
  471. // find segment index at character to left of cursor (or rightmost edge of selection)
  472. segment_set_t::const_iterator it = mSegments.lower_bound(new LLIndexSegment(mCursorPos));
  474. if (it != mSegments.end())
  475. {
  476. return *it;
  477. }
  478. else
  479. {
  480. return LLTextSegmentPtr();
  481. }
  482. }
  484. void LLTextEditor::getSelectedSegments(LLTextEditor::segment_vec_t& segments) const
  485. {
  486. S32 left = hasSelection() ? llmin(mSelectionStart, mSelectionEnd) : mCursorPos;
  487. S32 right = hasSelection() ? llmax(mSelectionStart, mSelectionEnd) : mCursorPos;
  489. return getSegmentsInRange(segments, left, right, true);
  490. }
  492. void LLTextEditor::getSegmentsInRange(LLTextEditor::segment_vec_t& segments_out, S32 start, S32 end, bool include_partial) const
  493. {
  494. segment_set_t::const_iterator first_it = getSegIterContaining(start);
  495. segment_set_t::const_iterator end_it = getSegIterContaining(end - 1);
  496. if (end_it != mSegments.end()) ++end_it;
  498. for (segment_set_t::const_iterator it = first_it; it != end_it; ++it)
  499. {
  500. LLTextSegmentPtr segment = *it;
  501. if (include_partial
  502. || (segment->getStart() >= start
  503. && segment->getEnd() <= end))
  504. {
  505. segments_out.push_back(segment);
  506. }
  507. }
  508. }
  510. // virtual
  511. BOOL LLTextEditor::canDeselect() const
  512. {
  513. return hasSelection(); 
  514. }
  517. void LLTextEditor::deselect()
  518. {
  519. mSelectionStart = 0;
  520. mSelectionEnd = 0;
  521. mIsSelecting = FALSE;
  522. }
  525. BOOL LLTextEditor::selectionContainsLineBreaks()
  526. {
  527. if (hasSelection())
  528. {
  529. S32 left = llmin(mSelectionStart, mSelectionEnd);
  530. S32 right = left + llabs(mSelectionStart - mSelectionEnd);
  532. LLWString wtext = getWText();
  533. for( S32 i = left; i < right; i++ )
  534. {
  535. if (wtext[i] == 'n')
  536. {
  537. return TRUE;
  538. }
  539. }
  540. }
  541. return FALSE;
  542. }
  545. S32 LLTextEditor::indentLine( S32 pos, S32 spaces )
  546. {
  547. // Assumes that pos is at the start of the line
  548. // spaces may be positive (indent) or negative (unindent).
  549. // Returns the actual number of characters added or removed.
  551. llassert(pos >= 0);
  552. llassert(pos <= getLength() );
  554. S32 delta_spaces = 0;
  556. if (spaces >= 0)
  557. {
  558. // Indent
  559. for(S32 i=0; i < spaces; i++)
  560. {
  561. delta_spaces += addChar(pos, ' ');
  562. }
  563. }
  564. else
  565. {
  566. // Unindent
  567. for(S32 i=0; i < -spaces; i++)
  568. {
  569. LLWString wtext = getWText();
  570. if (wtext[pos] == ' ')
  571. {
  572. delta_spaces += remove( pos, 1, FALSE );
  573. }
  574.   }
  575. }
  577. return delta_spaces;
  578. }
  580. void LLTextEditor::indentSelectedLines( S32 spaces )
  581. {
  582. if( hasSelection() )
  583. {
  584. LLWString text = getWText();
  585. S32 left = llmin( mSelectionStart, mSelectionEnd );
  586. S32 right = left + llabs( mSelectionStart - mSelectionEnd );
  587. BOOL cursor_on_right = (mSelectionEnd > mSelectionStart);
  588. S32 cur = left;
  590. // Expand left to start of line
  591. while( (cur > 0) && (text[cur] != 'n') )
  592. {
  593. cur--;
  594. }
  595. left = cur;
  596. if( cur > 0 )
  597. {
  598. left++;
  599. }
  601. // Expand right to end of line
  602. if( text[right - 1] == 'n' )
  603. {
  604. right--;
  605. }
  606. else
  607. {
  608. while( (text[right] != 'n') && (right <= getLength() ) )
  609. {
  610. right++;
  611. }
  612. }
  614. // Find each start-of-line and indent it
  615. do
  616. {
  617. if( text[cur] == 'n' )
  618. {
  619. cur++;
  620. }
  622. S32 delta_spaces = indentLine( cur, spaces );
  623. if( delta_spaces > 0 )
  624. {
  625. cur += delta_spaces;
  626. }
  627. right += delta_spaces;
  629. text = getWText();
  631. // Find the next new line
  632. while( (cur < right) && (text[cur] != 'n') )
  633. {
  634. cur++;
  635. }
  636. }
  637. while( cur < right );
  639. if( (right < getLength()) && (text[right] == 'n') )
  640. {
  641. right++;
  642. }
  644. // Set the selection and cursor
  645. if( cursor_on_right )
  646. {
  647. mSelectionStart = left;
  648. mSelectionEnd = right;
  649. }
  650. else
  651. {
  652. mSelectionStart = right;
  653. mSelectionEnd = left;
  654. }
  655. setCursorPos(mSelectionEnd);
  656. }
  657. }
  659. //virtual
  660. BOOL LLTextEditor::canSelectAll() const
  661. {
  662. return TRUE;
  663. }
  665. // virtual
  666. void LLTextEditor::selectAll()
  667. {
  668. mSelectionStart = getLength();
  669. mSelectionEnd = 0;
  670. setCursorPos(mSelectionEnd);
  671. }
  673. BOOL LLTextEditor::handleMouseDown(S32 x, S32 y, MASK mask)
  674. {
  675. BOOL handled = FALSE;
  677. // set focus first, in case click callbacks want to change it
  678. // RN: do we really need to have a tab stop?
  679. if (hasTabStop())
  680. {
  681. setFocus( TRUE );
  682. }
  684. // Let scrollbar have first dibs
  685. handled = LLTextBase::handleMouseDown(x, y, mask);
  687. if( !handled )
  688. {
  689. if (!(mask & MASK_SHIFT))
  690. {
  691. deselect();
  692. }
  694. BOOL start_select = TRUE;
  695. if( start_select )
  696. {
  697. // If we're not scrolling (handled by child), then we're selecting
  698. if (mask & MASK_SHIFT)
  699. {
  700. S32 old_cursor_pos = mCursorPos;
  701. setCursorAtLocalPos( x, y, true );
  703. if (hasSelection())
  704. {
  705. mSelectionEnd = mCursorPos;
  706. }
  707. else
  708. {
  709. mSelectionStart = old_cursor_pos;
  710. mSelectionEnd = mCursorPos;
  711. }
  712. // assume we're starting a drag select
  713. mIsSelecting = TRUE;
  714. }
  715. else
  716. {
  717. setCursorAtLocalPos( x, y, true );
  718. startSelection();
  719. }
  720. gFocusMgr.setMouseCapture( this );
  721. }
  723. handled = TRUE;
  724. }
  726. // Delay cursor flashing
  727. resetCursorBlink();
  729. return handled;
  730. }
  732. BOOL LLTextEditor::handleRightMouseDown(S32 x, S32 y, MASK mask)
  733. {
  734. if (hasTabStop())
  735. {
  736. setFocus(TRUE);
  737. }
  738. if (!LLTextBase::handleRightMouseDown(x, y, mask))
  739. {
  740. if(getShowContextMenu())
  741. {
  742. showContextMenu(x, y);
  743. }
  744. }
  745. return TRUE;
  746. }
  750. BOOL LLTextEditor::handleMiddleMouseDown(S32 x, S32 y, MASK mask)
  751. {
  752. if (hasTabStop())
  753. {
  754. setFocus(TRUE);
  755. }
  757. if (!LLTextBase::handleMouseDown(x, y, mask))
  758. {
  759. if( canPastePrimary() )
  760. {
  761. setCursorAtLocalPos( x, y, true );
  762. // does not rely on focus being set
  763. pastePrimary();
  764. }
  765. }
  766. return TRUE;
  767. }
  770. BOOL LLTextEditor::handleHover(S32 x, S32 y, MASK mask)
  771. {
  772. BOOL handled = FALSE;
  774. if(hasMouseCapture() )
  775. {
  776. if( mIsSelecting ) 
  777. {
  778. if(mScroller)
  779. {
  780. mScroller->autoScroll(x, y);
  781. }
  782. S32 clamped_x = llclamp(x, mVisibleTextRect.mLeft, mVisibleTextRect.mRight);
  783. S32 clamped_y = llclamp(y, mVisibleTextRect.mBottom, mVisibleTextRect.mTop);
  784. setCursorAtLocalPos( clamped_x, clamped_y, true );
  785. mSelectionEnd = mCursorPos;
  786. }
  787. lldebugst(LLERR_USER_INPUT) << "hover handled by " << getName() << " (active)" << llendl;
  788. getWindow()->setCursor(UI_CURSOR_IBEAM);
  789. handled = TRUE;
  790. }
  792. if( !handled )
  793. {
  794. // Pass to children
  795. handled = LLTextBase::handleHover(x, y, mask);
  796. }
  798. if( handled )
  799. {
  800. // Delay cursor flashing
  801. resetCursorBlink();
  802. }
  804. if( !handled )
  805. {
  806. getWindow()->setCursor(UI_CURSOR_IBEAM);
  807. handled = TRUE;
  808. }
  810. return handled;
  811. }
  814. BOOL LLTextEditor::handleMouseUp(S32 x, S32 y, MASK mask)
  815. {
  816. BOOL handled = FALSE;
  818. // if I'm not currently selecting text
  819. if (!(hasSelection() && hasMouseCapture()))
  820. {
  821. // let text segments handle mouse event
  822. handled = LLTextBase::handleMouseUp(x, y, mask);
  823. }
  825. if( !handled )
  826. {
  827. if( mIsSelecting )
  828. {
  829. if(mScroller)
  830. {
  831. mScroller->autoScroll(x, y);
  832. }
  833. S32 clamped_x = llclamp(x, mVisibleTextRect.mLeft, mVisibleTextRect.mRight);
  834. S32 clamped_y = llclamp(y, mVisibleTextRect.mBottom, mVisibleTextRect.mTop);
  835. setCursorAtLocalPos( clamped_x, clamped_y, true );
  836. endSelection();
  837. }
  839. // take selection to 'primary' clipboard
  840. updatePrimary();
  842. handled = TRUE;
  843. }
  845. // Delay cursor flashing
  846. resetCursorBlink();
  848. if( hasMouseCapture()  )
  849. {
  850. gFocusMgr.setMouseCapture( NULL );
  852. handled = TRUE;
  853. }
  855. return handled;
  856. }
  859. BOOL LLTextEditor::handleDoubleClick(S32 x, S32 y, MASK mask)
  860. {
  861. BOOL handled = FALSE;
  863. // let scrollbar and text segments have first dibs
  864. handled = LLTextBase::handleDoubleClick(x, y, mask);
  866. if( !handled )
  867. {
  868. setCursorAtLocalPos( x, y, false );
  869. deselect();
  871. LLWString text = getWText();
  873. if( LLWStringUtil::isPartOfWord( text[mCursorPos] ) )
  874. {
  875. // Select word the cursor is over
  876. while ((mCursorPos > 0) && LLWStringUtil::isPartOfWord(text[mCursorPos-1]))
  877. {
  878. if (!setCursorPos(mCursorPos - 1)) break;
  879. }
  880. startSelection();
  882. while ((mCursorPos < (S32)text.length()) && LLWStringUtil::isPartOfWord( text[mCursorPos] ) )
  883. {
  884. if (!setCursorPos(mCursorPos + 1)) break;
  885. }
  887. mSelectionEnd = mCursorPos;
  888. }
  889. else if ((mCursorPos < (S32)text.length()) && !iswspace( text[mCursorPos]) )
  890. {
  891. // Select the character the cursor is over
  892. startSelection();
  893. setCursorPos(mCursorPos + 1);
  894. mSelectionEnd = mCursorPos;
  895. }
  897. // We don't want handleMouseUp() to "finish" the selection (and thereby
  898. // set mSelectionEnd to where the mouse is), so we finish the selection here.
  899. mIsSelecting = FALSE;  
  901. // delay cursor flashing
  902. resetCursorBlink();
  904. // take selection to 'primary' clipboard
  905. updatePrimary();
  907. handled = TRUE;
  908. }
  910. return handled;
  911. }
  914. //----------------------------------------------------------------------------
  915. // Returns change in number of characters in mText
  917. S32 LLTextEditor::execute( TextCmd* cmd )
  918. {
  919. S32 delta = 0;
  920. if( cmd->execute(this, &delta) )
  921. {
  922. // Delete top of undo stack
  923. undo_stack_t::iterator enditer = std::find(mUndoStack.begin(), mUndoStack.end(), mLastCmd);
  924. std::for_each(mUndoStack.begin(), enditer, DeletePointer());
  925. mUndoStack.erase(mUndoStack.begin(), enditer);
  926. // Push the new command is now on the top (front) of the undo stack.
  927. mUndoStack.push_front(cmd);
  928. mLastCmd = cmd;
  930. bool need_to_rollback = mPrevalidateFunc 
  931. && !mPrevalidateFunc(getViewModel()->getDisplay());
  932. if (need_to_rollback)
  933. {
  934. // get rid of this last command and clean up undo stack
  935. undo();
  937. // remove any evidence of this command from redo history
  938. mUndoStack.pop_front();
  939. delete cmd;
  941. // failure, nothing changed
  942. delta = 0;
  943. }
  944. }
  945. else
  946. {
  947. // Operation failed, so don't put it on the undo stack.
  948. delete cmd;
  949. }
  951. return delta;
  952. }
  954. S32 LLTextEditor::insert(S32 pos, const LLWString &wstr, bool group_with_next_op, LLTextSegmentPtr segment)
  955. {
  956. return execute( new TextCmdInsert( pos, group_with_next_op, wstr, segment ) );
  957. }
  959. S32 LLTextEditor::remove(S32 pos, S32 length, bool group_with_next_op)
  960. {
  961. S32 end_pos = getEditableIndex(pos + length, true);
  963. segment_vec_t segments_to_remove;
  964. // store text segments
  965. getSegmentsInRange(segments_to_remove, pos, pos + length, false);
  967. return execute( new TextCmdRemove( pos, group_with_next_op, end_pos - pos, segments_to_remove ) );
  968. }
  970. S32 LLTextEditor::overwriteChar(S32 pos, llwchar wc)
  971. {
  972. if ((S32)getLength() == pos)
  973. {
  974. return addChar(pos, wc);
  975. }
  976. else
  977. {
  978. return execute(new TextCmdOverwriteChar(pos, FALSE, wc));
  979. }
  980. }
  982. // Remove a single character from the text.  Tries to remove
  983. // a pseudo-tab (up to for spaces in a row)
  984. void LLTextEditor::removeCharOrTab()
  985. {
  986. if( !getEnabled() )
  987. {
  988. return;
  989. }
  990. if( mCursorPos > 0 )
  991. {
  992. S32 chars_to_remove = 1;
  994. LLWString text = getWText();
  995. if (text[mCursorPos - 1] == ' ')
  996. {
  997. // Try to remove a "tab"
  998. S32 offset = getLineOffsetFromDocIndex(mCursorPos);
  999. if (offset > 0)
  1000. {
  1001. chars_to_remove = offset % SPACES_PER_TAB;
  1002. if( chars_to_remove == 0 )
  1003. {
  1004. chars_to_remove = SPACES_PER_TAB;
  1005. }
  1007. for( S32 i = 0; i < chars_to_remove; i++ )
  1008. {
  1009. if (text[ mCursorPos - i - 1] != ' ')
  1010. {
  1011. // Fewer than a full tab's worth of spaces, so
  1012. // just delete a single character.
  1013. chars_to_remove = 1;
  1014. break;
  1015. }
  1016. }
  1017. }
  1018. }
  1020. for (S32 i = 0; i < chars_to_remove; i++)
  1021. {
  1022. setCursorPos(mCursorPos - 1);
  1023. remove( mCursorPos, 1, FALSE );
  1024. }
  1025. }
  1026. else
  1027. {
  1028. reportBadKeystroke();
  1029. }
  1030. }
  1032. // Remove a single character from the text
  1033. S32 LLTextEditor::removeChar(S32 pos)
  1034. {
  1035. return remove( pos, 1, FALSE );
  1036. }
  1038. void LLTextEditor::removeChar()
  1039. {
  1040. if (!getEnabled())
  1041. {
  1042. return;
  1043. }
  1044. if (mCursorPos > 0)
  1045. {
  1046. setCursorPos(mCursorPos - 1);
  1047. removeChar(mCursorPos);
  1048. }
  1049. else
  1050. {
  1051. reportBadKeystroke();
  1052. }
  1053. }
  1055. // Add a single character to the text
  1056. S32 LLTextEditor::addChar(S32 pos, llwchar wc)
  1057. {
  1058. if ( (wstring_utf8_length( getWText() ) + wchar_utf8_length( wc ))  > mMaxTextByteLength)
  1059. {
  1060. make_ui_sound("UISndBadKeystroke");
  1061. return 0;
  1062. }
  1064. if (mLastCmd && mLastCmd->canExtend(pos))
  1065. {
  1066. S32 delta = 0;
  1067. if (mPrevalidateFunc)
  1068. {
  1069. // get a copy of current text contents
  1070. LLWString test_string(getViewModel()->getDisplay());
  1072. // modify text contents as if this addChar succeeded
  1073. llassert(pos <= (S32)test_string.size());
  1074. test_string.insert(pos, 1, wc);
  1075. if (!mPrevalidateFunc( test_string))
  1076. {
  1077. return 0;
  1078. }
  1079. }
  1080. mLastCmd->extendAndExecute(this, pos, wc, &delta);
  1082. return delta;
  1083. }
  1084. else
  1085. {
  1086. return execute(new TextCmdAddChar(pos, FALSE, wc, LLTextSegmentPtr()));
  1087. }
  1088. }
  1090. void LLTextEditor::addChar(llwchar wc)
  1091. {
  1092. if( !getEnabled() )
  1093. {
  1094. return;
  1095. }
  1096. if( hasSelection() )
  1097. {
  1098. deleteSelection(TRUE);
  1099. }
  1100. else if (LL_KIM_OVERWRITE == gKeyboard->getInsertMode())
  1101. {
  1102. removeChar(mCursorPos);
  1103. }
  1105. setCursorPos(mCursorPos + addChar( mCursorPos, wc ));
  1106. }
  1109. BOOL LLTextEditor::handleSelectionKey(const KEY key, const MASK mask)
  1110. {
  1111. BOOL handled = FALSE;
  1113. if( mask & MASK_SHIFT )
  1114. {
  1115. handled = TRUE;
  1117. switch( key )
  1118. {
  1119. case KEY_LEFT:
  1120. if( 0 < mCursorPos )
  1121. {
  1122. startSelection();
  1123. setCursorPos(mCursorPos - 1);
  1124. if( mask & MASK_CONTROL )
  1125. {
  1126. setCursorPos(prevWordPos(mCursorPos));
  1127. }
  1128. mSelectionEnd = mCursorPos;
  1129. }
  1130. break;
  1132. case KEY_RIGHT:
  1133. if( mCursorPos < getLength() )
  1134. {
  1135. startSelection();
  1136. setCursorPos(mCursorPos + 1);
  1137. if( mask & MASK_CONTROL )
  1138. {
  1139. setCursorPos(nextWordPos(mCursorPos));
  1140. }
  1141. mSelectionEnd = mCursorPos;
  1142. }
  1143. break;
  1145. case KEY_UP:
  1146. startSelection();
  1147. changeLine( -1 );
  1148. mSelectionEnd = mCursorPos;
  1149. break;
  1151. case KEY_PAGE_UP:
  1152. startSelection();
  1153. changePage( -1 );
  1154. mSelectionEnd = mCursorPos;
  1155. break;
  1157. case KEY_HOME:
  1158. startSelection();
  1159. if( mask & MASK_CONTROL )
  1160. {
  1161. setCursorPos(0);
  1162. }
  1163. else
  1164. {
  1165. startOfLine();
  1166. }
  1167. mSelectionEnd = mCursorPos;
  1168. break;
  1170. case KEY_DOWN:
  1171. startSelection();
  1172. changeLine( 1 );
  1173. mSelectionEnd = mCursorPos;
  1174. break;
  1176. case KEY_PAGE_DOWN:
  1177. startSelection();
  1178. changePage( 1 );
  1179. mSelectionEnd = mCursorPos;
  1180. break;
  1182. case KEY_END:
  1183. startSelection();
  1184. if( mask & MASK_CONTROL )
  1185. {
  1186. setCursorPos(getLength());
  1187. }
  1188. else
  1189. {
  1190. endOfLine();
  1191. }
  1192. mSelectionEnd = mCursorPos;
  1193. break;
  1195. default:
  1196. handled = FALSE;
  1197. break;
  1198. }
  1199. }
  1201. if( !handled && mHandleEditKeysDirectly )
  1202. {
  1203. if( (MASK_CONTROL & mask) && ('A' == key) )
  1204. {
  1205. if( canSelectAll() )
  1206. {
  1207. selectAll();
  1208. }
  1209. else
  1210. {
  1211. reportBadKeystroke();
  1212. }
  1213. handled = TRUE;
  1214. }
  1215. }
  1217. if( handled )
  1218. {
  1219. // take selection to 'primary' clipboard
  1220. updatePrimary();
  1221. }
  1222.  
  1223. return handled;
  1224. }
  1226. BOOL LLTextEditor::handleNavigationKey(const KEY key, const MASK mask)
  1227. {
  1228. BOOL handled = FALSE;
  1230. // Ignore capslock key
  1231. if( MASK_NONE == mask )
  1232. {
  1233. handled = TRUE;
  1234. switch( key )
  1235. {
  1236. case KEY_UP:
  1237. changeLine( -1 );
  1238. break;
  1240. case KEY_PAGE_UP:
  1241. changePage( -1 );
  1242. break;
  1244. case KEY_HOME:
  1245. startOfLine();
  1246. break;
  1248. case KEY_DOWN:
  1249. changeLine( 1 );
  1250. break;
  1252. case KEY_PAGE_DOWN:
  1253. changePage( 1 );
  1254. break;
  1255.  
  1256. case KEY_END:
  1257. endOfLine();
  1258. break;
  1260. case KEY_LEFT:
  1261. if( hasSelection() )
  1262. {
  1263. setCursorPos(llmin( mCursorPos - 1, mSelectionStart, mSelectionEnd ));
  1264. }
  1265. else
  1266. {
  1267. if( 0 < mCursorPos )
  1268. {
  1269. setCursorPos(mCursorPos - 1);
  1270. }
  1271. else
  1272. {
  1273. reportBadKeystroke();
  1274. }
  1275. }
  1276. break;
  1278. case KEY_RIGHT:
  1279. if( hasSelection() )
  1280. {
  1281. setCursorPos(llmax( mCursorPos + 1, mSelectionStart, mSelectionEnd ));
  1282. }
  1283. else
  1284. {
  1285. if( mCursorPos < getLength() )
  1286. {
  1287. setCursorPos(mCursorPos + 1);
  1288. }
  1289. else
  1290. {
  1291. reportBadKeystroke();
  1292. }
  1293. }
  1294. break;
  1296. default:
  1297. handled = FALSE;
  1298. break;
  1299. }
  1300. }
  1302. return handled;
  1303. }
  1305. void LLTextEditor::deleteSelection(BOOL group_with_next_op )
  1306. {
  1307. if( getEnabled() && hasSelection() )
  1308. {
  1309. S32 pos = llmin( mSelectionStart, mSelectionEnd );
  1310. S32 length = llabs( mSelectionStart - mSelectionEnd );
  1312. remove( pos, length, group_with_next_op );
  1314. deselect();
  1315. setCursorPos(pos);
  1316. }
  1317. }
  1319. // virtual
  1320. BOOL LLTextEditor::canCut() const
  1321. {
  1322. return !mReadOnly && hasSelection();
  1323. }
  1325. // cut selection to clipboard
  1326. void LLTextEditor::cut()
  1327. {
  1328. if( !canCut() )
  1329. {
  1330. return;
  1331. }
  1332. S32 left_pos = llmin( mSelectionStart, mSelectionEnd );
  1333. S32 length = llabs( mSelectionStart - mSelectionEnd );
  1334. gClipboard.copyFromSubstring( getWText(), left_pos, length, mSourceID );
  1335. deleteSelection( FALSE );
  1337. onKeyStroke();
  1338. }
  1340. BOOL LLTextEditor::canCopy() const
  1341. {
  1342. return hasSelection();
  1343. }
  1345. // copy selection to clipboard
  1346. void LLTextEditor::copy()
  1347. {
  1348. if( !canCopy() )
  1349. {
  1350. return;
  1351. }
  1352. S32 left_pos = llmin( mSelectionStart, mSelectionEnd );
  1353. S32 length = llabs( mSelectionStart - mSelectionEnd );
  1354. gClipboard.copyFromSubstring(getWText(), left_pos, length, mSourceID);
  1355. }
  1357. BOOL LLTextEditor::canPaste() const
  1358. {
  1359. return !mReadOnly && gClipboard.canPasteString();
  1360. }
  1362. // paste from clipboard
  1363. void LLTextEditor::paste()
  1364. {
  1365. bool is_primary = false;
  1366. pasteHelper(is_primary);
  1367. }
  1369. // paste from primary
  1370. void LLTextEditor::pastePrimary()
  1371. {
  1372. bool is_primary = true;
  1373. pasteHelper(is_primary);
  1374. }
  1376. // paste from primary (itsprimary==true) or clipboard (itsprimary==false)
  1377. void LLTextEditor::pasteHelper(bool is_primary)
  1378. {
  1379. bool can_paste_it;
  1380. if (is_primary)
  1381. {
  1382. can_paste_it = canPastePrimary();
  1383. }
  1384. else
  1385. {
  1386. can_paste_it = canPaste();
  1387. }
  1389. if (!can_paste_it)
  1390. {
  1391. return;
  1392. }
  1394. LLUUID source_id;
  1395. LLWString paste;
  1396. if (is_primary)
  1397. {
  1398. paste = gClipboard.getPastePrimaryWString(&source_id);
  1399. }
  1400. else 
  1401. {
  1402. paste = gClipboard.getPasteWString(&source_id);
  1403. }
  1405. if (paste.empty())
  1406. {
  1407. return;
  1408. }
  1410. // Delete any selected characters (the paste replaces them)
  1411. if( (!is_primary) && hasSelection() )
  1412. {
  1413. deleteSelection(TRUE);
  1414. }
  1416. // Clean up string (replace tabs and remove characters that our fonts don't support).
  1417. LLWString clean_string(paste);
  1418. LLWStringUtil::replaceTabsWithSpaces(clean_string, SPACES_PER_TAB);
  1419. if( mAllowEmbeddedItems )
  1420. {
  1421. const llwchar LF = 10;
  1422. S32 len = clean_string.length();
  1423. for( S32 i = 0; i < len; i++ )
  1424. {
  1425. llwchar wc = clean_string[i];
  1426. if( (wc < LLFontFreetype::FIRST_CHAR) && (wc != LF) )
  1427. {
  1428. clean_string[i] = LL_UNKNOWN_CHAR;
  1429. }
  1430. else if (wc >= FIRST_EMBEDDED_CHAR && wc <= LAST_EMBEDDED_CHAR)
  1431. {
  1432. clean_string[i] = pasteEmbeddedItem(wc);
  1433. }
  1434. }
  1435. }
  1437. // Insert the new text into the existing text.
  1438. setCursorPos(mCursorPos + insert(mCursorPos, clean_string, FALSE, LLTextSegmentPtr()));
  1439. deselect();
  1441. onKeyStroke();
  1442. }
  1446. // copy selection to primary
  1447. void LLTextEditor::copyPrimary()
  1448. {
  1449. if( !canCopy() )
  1450. {
  1451. return;
  1452. }
  1453. S32 left_pos = llmin( mSelectionStart, mSelectionEnd );
  1454. S32 length = llabs( mSelectionStart - mSelectionEnd );
  1455. gClipboard.copyFromPrimarySubstring(getWText(), left_pos, length, mSourceID);
  1456. }
  1458. BOOL LLTextEditor::canPastePrimary() const
  1459. {
  1460. return !mReadOnly && gClipboard.canPastePrimaryString();
  1461. }
  1463. void LLTextEditor::updatePrimary()
  1464. {
  1465. if (canCopy())
  1466. {
  1467. copyPrimary();
  1468. }
  1469. }
  1471. BOOL LLTextEditor::handleControlKey(const KEY key, const MASK mask)
  1472. {
  1473. BOOL handled = FALSE;
  1475. if( mask & MASK_CONTROL )
  1476. {
  1477. handled = TRUE;
  1479. switch( key )
  1480. {
  1481. case KEY_HOME:
  1482. if( mask & MASK_SHIFT )
  1483. {
  1484. startSelection();
  1485. setCursorPos(0);
  1486. mSelectionEnd = mCursorPos;
  1487. }
  1488. else
  1489. {
  1490. // Ctrl-Home, Ctrl-Left, Ctrl-Right, Ctrl-Down
  1491. // all move the cursor as if clicking, so should deselect.
  1492. deselect();
  1493. startOfDoc();
  1494. }
  1495. break;
  1497. case KEY_END:
  1498. {
  1499. if( mask & MASK_SHIFT )
  1500. {
  1501. startSelection();
  1502. }
  1503. else
  1504. {
  1505. // Ctrl-Home, Ctrl-Left, Ctrl-Right, Ctrl-Down
  1506. // all move the cursor as if clicking, so should deselect.
  1507. deselect();
  1508. }
  1509. endOfDoc();
  1510. if( mask & MASK_SHIFT )
  1511. {
  1512. mSelectionEnd = mCursorPos;
  1513. }
  1514. break;
  1515. }
  1517. case KEY_RIGHT:
  1518. if( mCursorPos < getLength() )
  1519. {
  1520. // Ctrl-Home, Ctrl-Left, Ctrl-Right, Ctrl-Down
  1521. // all move the cursor as if clicking, so should deselect.
  1522. deselect();
  1524. setCursorPos(nextWordPos(mCursorPos + 1));
  1525. }
  1526. break;
  1529. case KEY_LEFT:
  1530. if( mCursorPos > 0 )
  1531. {
  1532. // Ctrl-Home, Ctrl-Left, Ctrl-Right, Ctrl-Down
  1533. // all move the cursor as if clicking, so should deselect.
  1534. deselect();
  1536. setCursorPos(prevWordPos(mCursorPos - 1));
  1537. }
  1538. break;
  1540. default:
  1541. handled = FALSE;
  1542. break;
  1543. }
  1544. }
  1546. if (handled)
  1547. {
  1548. updatePrimary();
  1549. }
  1551. return handled;
  1552. }
  1554. BOOL LLTextEditor::handleEditKey(const KEY key, const MASK mask)
  1555. {
  1556. BOOL handled = FALSE;
  1558. // Standard edit keys (Ctrl-X, Delete, etc,) are handled here instead of routed by the menu system.
  1559. if( KEY_DELETE == key )
  1560. {
  1561. if( canDoDelete() )
  1562. {
  1563. doDelete();
  1564. }
  1565. else
  1566. {
  1567. reportBadKeystroke();
  1568. }
  1569. handled = TRUE;
  1570. }
  1571. else
  1572. if( MASK_CONTROL & mask )
  1573. {
  1574. if( 'C' == key )
  1575. {
  1576. if( canCopy() )
  1577. {
  1578. copy();
  1579. }
  1580. else
  1581. {
  1582. reportBadKeystroke();
  1583. }
  1584. handled = TRUE;
  1585. }
  1586. else
  1587. if( 'V' == key )
  1588. {
  1589. if( canPaste() )
  1590. {
  1591. paste();
  1592. }
  1593. else
  1594. {
  1595. reportBadKeystroke();
  1596. }
  1597. handled = TRUE;
  1598. }
  1599. else
  1600. if( 'X' == key )
  1601. {
  1602. if( canCut() )
  1603. {
  1604. cut();
  1605. }
  1606. else
  1607. {
  1608. reportBadKeystroke();
  1609. }
  1610. handled = TRUE;
  1611. }
  1612. }
  1614. return handled;
  1615. }
  1618. BOOL LLTextEditor::handleSpecialKey(const KEY key, const MASK mask, BOOL* return_key_hit)
  1619. {
  1620. *return_key_hit = FALSE;
  1621. BOOL handled = TRUE;
  1623. switch( key )
  1624. {
  1625. case KEY_INSERT:
  1626. if (mask == MASK_NONE)
  1627. {
  1628. gKeyboard->toggleInsertMode();
  1629. }
  1630. break;
  1632. case KEY_BACKSPACE:
  1633. if( hasSelection() )
  1634. {
  1635. deleteSelection(FALSE);
  1636. }
  1637. else
  1638. if( 0 < mCursorPos )
  1639. {
  1640. removeCharOrTab();
  1641. }
  1642. else
  1643. {
  1644. reportBadKeystroke();
  1645. }
  1646. break;
  1649. case KEY_RETURN:
  1650. if (mask == MASK_NONE)
  1651. {
  1652. if( hasSelection() )
  1653. {
  1654. deleteSelection(FALSE);
  1655. }
  1656. autoIndent(); // TODO: make this optional
  1657. }
  1658. else
  1659. {
  1660. handled = FALSE;
  1661. break;
  1662. }
  1663. break;
  1665. case KEY_TAB:
  1666. if (mask & MASK_CONTROL)
  1667. {
  1668. handled = FALSE;
  1669. break;
  1670. }
  1671. if( hasSelection() && selectionContainsLineBreaks() )
  1672. {
  1673. indentSelectedLines( (mask & MASK_SHIFT) ? -SPACES_PER_TAB : SPACES_PER_TAB );
  1674. }
  1675. else
  1676. {
  1677. if( hasSelection() )
  1678. {
  1679. deleteSelection(FALSE);
  1680. }
  1682. S32 offset = getLineOffsetFromDocIndex(mCursorPos);
  1684. S32 spaces_needed = SPACES_PER_TAB - (offset % SPACES_PER_TAB);
  1685. for( S32 i=0; i < spaces_needed; i++ )
  1686. {
  1687. addChar( ' ' );
  1688. }
  1689. }
  1690. break;
  1692. default:
  1693. handled = FALSE;
  1694. break;
  1695. }
  1697. return handled;
  1698. }
  1701. void LLTextEditor::unindentLineBeforeCloseBrace()
  1702. {
  1703. if( mCursorPos >= 1 )
  1704. {
  1705. LLWString text = getWText();
  1706. if( ' ' == text[ mCursorPos - 1 ] )
  1707. {
  1708. removeCharOrTab();
  1709. }
  1710. }
  1711. }
  1714. BOOL LLTextEditor::handleKeyHere(KEY key, MASK mask )
  1715. {
  1716. BOOL handled = FALSE;
  1717. BOOL selection_modified = FALSE;
  1718. BOOL return_key_hit = FALSE;
  1719. BOOL text_may_have_changed = TRUE;
  1721. // Special case for TAB.  If want to move to next field, report
  1722. // not handled and let the parent take care of field movement.
  1723. if (KEY_TAB == key && mTabsToNextField)
  1724. {
  1725. return FALSE;
  1726. }
  1727. /*
  1728. if (KEY_F10 == key)
  1729. {
  1730. LLComboBox::Params cp;
  1731. cp.name = "combo box";
  1732. cp.label = "my combo";
  1733. cp.rect.width = 100;
  1734. cp.rect.height = 20;
  1735. cp.items.add().label = "item 1";
  1736. cp.items.add().label = "item 2";
  1737. cp.items.add().label = "item 3";
  1739. appendWidget(LLUICtrlFactory::create<LLComboBox>(cp), "combo", true, false);
  1740. }
  1741. if (KEY_F11 == key)
  1742. {
  1743. LLButton::Params bp;
  1744. bp.name = "text button";
  1745. bp.label = "Click me";
  1746. bp.rect.width = 100;
  1747. bp.rect.height = 20;
  1749. appendWidget(LLUICtrlFactory::create<LLButton>(bp), "button", true, false);
  1750. }
  1751. */
  1752. if (mReadOnly)
  1753. {
  1754. if(mScroller)
  1755. {
  1756. handled = mScroller->handleKeyHere( key, mask );
  1757. }
  1758. else 
  1759. {
  1760. handled = handleNavigationKey( key, mask );
  1761. }
  1763. }
  1764. else
  1765. {
  1766. // handle navigation keys ourself
  1767. handled = handleNavigationKey( key, mask );
  1768. }
  1771. if( handled )
  1772. {
  1773. text_may_have_changed = FALSE;
  1774. }
  1776. if( !handled )
  1777. {
  1778. handled = handleSelectionKey( key, mask );
  1779. if( handled )
  1780. {
  1781. selection_modified = TRUE;
  1782. }
  1783. }
  1785. if( !handled )
  1786. {
  1787. handled = handleControlKey( key, mask );
  1788. if( handled )
  1789. {
  1790. selection_modified = TRUE;
  1791. }
  1792. }
  1794. if( !handled && mHandleEditKeysDirectly )
  1795. {
  1796. handled = handleEditKey( key, mask );
  1797. if( handled )
  1798. {
  1799. selection_modified = TRUE;
  1800. text_may_have_changed = TRUE;
  1801. }
  1802. }
  1804. // Handle most keys only if the text editor is writeable.
  1805. if( !mReadOnly )
  1806. {
  1807. if( !handled )
  1808. {
  1809. handled = handleSpecialKey( key, mask, &return_key_hit );
  1810. if( handled )
  1811. {
  1812. selection_modified = TRUE;
  1813. text_may_have_changed = TRUE;
  1814. }
  1815. }
  1817. }
  1819. if( handled )
  1820. {
  1821. resetCursorBlink();
  1823. // Most keystrokes will make the selection box go away, but not all will.
  1824. if( !selection_modified &&
  1825. KEY_SHIFT != key &&
  1826. KEY_CONTROL != key &&
  1827. KEY_ALT != key &&
  1828. KEY_CAPSLOCK )
  1829. {
  1830. deselect();
  1831. }
  1833. if(text_may_have_changed)
  1834. {
  1835. onKeyStroke();
  1836. }
  1837. needsScroll();
  1838. }
  1840. return handled;
  1841. }
  1844. BOOL LLTextEditor::handleUnicodeCharHere(llwchar uni_char)
  1845. {
  1846. if ((uni_char < 0x20) || (uni_char == 0x7F)) // Control character or DEL
  1847. {
  1848. return FALSE;
  1849. }
  1851. BOOL handled = FALSE;
  1853. // Handle most keys only if the text editor is writeable.
  1854. if( !mReadOnly )
  1855. {
  1856. if( '}' == uni_char )
  1857. {
  1858. unindentLineBeforeCloseBrace();
  1859. }
  1861. // TODO: KLW Add auto show of tool tip on (
  1862. addChar( uni_char );
  1864. // Keys that add characters temporarily hide the cursor
  1865. getWindow()->hideCursorUntilMouseMove();
  1867. handled = TRUE;
  1868. }
  1870. if( handled )
  1871. {
  1872. resetCursorBlink();
  1874. // Most keystrokes will make the selection box go away, but not all will.
  1875. deselect();
  1877. onKeyStroke();
  1878. }
  1880. return handled;
  1881. }
  1884. // virtual
  1885. BOOL LLTextEditor::canDoDelete() const
  1886. {
  1887. return !mReadOnly && ( hasSelection() || (mCursorPos < getLength()) );
  1888. }
  1890. void LLTextEditor::doDelete()
  1891. {
  1892. if( !canDoDelete() )
  1893. {
  1894. return;
  1895. }
  1896. if( hasSelection() )
  1897. {
  1898. deleteSelection(FALSE);
  1899. }
  1900. else
  1901. if( mCursorPos < getLength() )
  1902. {
  1903. S32 i;
  1904. S32 chars_to_remove = 1;
  1905. LLWString text = getWText();
  1906. if( (text[ mCursorPos ] == ' ') && (mCursorPos + SPACES_PER_TAB < getLength()) )
  1907. {
  1908. // Try to remove a full tab's worth of spaces
  1909. S32 offset = getLineOffsetFromDocIndex(mCursorPos);
  1910. chars_to_remove = SPACES_PER_TAB - (offset % SPACES_PER_TAB);
  1911. if( chars_to_remove == 0 )
  1912. {
  1913. chars_to_remove = SPACES_PER_TAB;
  1914. }
  1916. for( i = 0; i < chars_to_remove; i++ )
  1917. {
  1918. if( text[mCursorPos + i] != ' ' )
  1919. {
  1920. chars_to_remove = 1;
  1921. break;
  1922. }
  1923. }
  1924. }
  1926. for( i = 0; i < chars_to_remove; i++ )
  1927. {
  1928. setCursorPos(mCursorPos + 1);
  1929. removeChar();
  1930. }
  1932. }
  1934. onKeyStroke();
  1935. }
  1937. //----------------------------------------------------------------------------
  1940. void LLTextEditor::blockUndo()
  1941. {
  1942. mBaseDocIsPristine = FALSE;
  1943. mLastCmd = NULL;
  1944. std::for_each(mUndoStack.begin(), mUndoStack.end(), DeletePointer());
  1945. mUndoStack.clear();
  1946. }
  1948. // virtual
  1949. BOOL LLTextEditor::canUndo() const
  1950. {
  1951. return !mReadOnly && mLastCmd != NULL;
  1952. }
  1954. void LLTextEditor::undo()
  1955. {
  1956. if( !canUndo() )
  1957. {
  1958. return;
  1959. }
  1960. deselect();
  1961. S32 pos = 0;
  1962. do
  1963. {
  1964. pos = mLastCmd->undo(this);
  1965. undo_stack_t::iterator iter = std::find(mUndoStack.begin(), mUndoStack.end(), mLastCmd);
  1966. if (iter != mUndoStack.end())
  1967. ++iter;
  1968. if (iter != mUndoStack.end())
  1969. mLastCmd = *iter;
  1970. else
  1971. mLastCmd = NULL;
  1973. } while( mLastCmd && mLastCmd->groupWithNext() );
  1975. setCursorPos(pos);
  1977. onKeyStroke();
  1978. }
  1980. BOOL LLTextEditor::canRedo() const
  1981. {
  1982. return !mReadOnly && (mUndoStack.size() > 0) && (mLastCmd != mUndoStack.front());
  1983. }
  1985. void LLTextEditor::redo()
  1986. {
  1987. if( !canRedo() )
  1988. {
  1989. return;
  1990. }
  1991. deselect();
  1992. S32 pos = 0;
  1993. do
  1994. {
  1995. if( !mLastCmd )
  1996. {
  1997. mLastCmd = mUndoStack.back();
  1998. }
  1999. else
  2000. {
  2001. undo_stack_t::iterator iter = std::find(mUndoStack.begin(), mUndoStack.end(), mLastCmd);
  2002. if (iter != mUndoStack.begin())
  2003. mLastCmd = *(--iter);
  2004. else
  2005. mLastCmd = NULL;
  2006. }
  2008. if( mLastCmd )
  2009. {
  2010. pos = mLastCmd->redo(this);
  2011. }
  2012. } while( 
  2013. mLastCmd &&
  2014. mLastCmd->groupWithNext() &&
  2015. (mLastCmd != mUndoStack.front()) );
  2017. setCursorPos(pos);
  2019. onKeyStroke();
  2020. }
  2022. void LLTextEditor::onFocusReceived()
  2023. {
  2024. LLTextBase::onFocusReceived();
  2025. updateAllowingLanguageInput();
  2026. }
  2028. // virtual, from LLView
  2029. void LLTextEditor::onFocusLost()
  2030. {
  2031. updateAllowingLanguageInput();
  2033. // Route menu back to the default
  2034.   if( gEditMenuHandler == this )
  2035. {
  2036. gEditMenuHandler = NULL;
  2037. }
  2039. if (mCommitOnFocusLost)
  2040. {
  2041. onCommit();
  2042. }
  2044. // Make sure cursor is shown again
  2045. getWindow()->showCursorFromMouseMove();
  2047. LLTextBase::onFocusLost();
  2048. }
  2050. void LLTextEditor::onCommit()
  2051. {
  2052. setControlValue(getValue()); 
  2053. LLTextBase::onCommit(); 
  2054. }
  2056. void LLTextEditor::setEnabled(BOOL enabled)
  2057. {
  2058. // just treat enabled as read-only flag
  2059. bool read_only = !enabled;
  2060. if (read_only != mReadOnly)
  2061. {
  2062. //mReadOnly = read_only;
  2063. LLTextBase::setReadOnly(read_only);
  2064. updateSegments();
  2065. updateAllowingLanguageInput();
  2066. }
  2067. }
  2069. void LLTextEditor::showContextMenu(S32 x, S32 y)
  2070. {
  2071. if (!mContextMenu)
  2072. {
  2073. mContextMenu = LLUICtrlFactory::instance().createFromFile<LLContextMenu>("menu_text_editor.xml", 
  2074. LLMenuGL::sMenuContainer, 
  2075. LLMenuHolderGL::child_registry_t::instance());
  2076. }
  2078. // Route menu to this class
  2079. // previously this was done in ::handleRightMoseDown:
  2080. //if(hasTabStop())
  2081. // setFocus(TRUE)  - why? weird...
  2082. // and then inside setFocus
  2083. // ....
  2084. //    gEditMenuHandler = this;
  2085. // ....
  2086. // but this didn't work in all cases and just weird...
  2087.     //why not here? 
  2088. // (all this was done for EXT-4443)
  2090. gEditMenuHandler = this;
  2092. S32 screen_x, screen_y;
  2093. localPointToScreen(x, y, &screen_x, &screen_y);
  2094. mContextMenu->show(screen_x, screen_y);
  2095. }
  2098. void LLTextEditor::drawPreeditMarker()
  2099. {
  2100. static LLUICachedControl<F32> preedit_marker_brightness ("UIPreeditMarkerBrightness", 0);
  2101. static LLUICachedControl<S32> preedit_marker_gap ("UIPreeditMarkerGap", 0);
  2102. static LLUICachedControl<S32> preedit_marker_position ("UIPreeditMarkerPosition", 0);
  2103. static LLUICachedControl<S32> preedit_marker_thickness ("UIPreeditMarkerThickness", 0);
  2104. static LLUICachedControl<F32> preedit_standout_brightness ("UIPreeditStandoutBrightness", 0);
  2105. static LLUICachedControl<S32> preedit_standout_gap ("UIPreeditStandoutGap", 0);
  2106. static LLUICachedControl<S32> preedit_standout_position ("UIPreeditStandoutPosition", 0);
  2107. static LLUICachedControl<S32> preedit_standout_thickness ("UIPreeditStandoutThickness", 0);
  2109. if (!hasPreeditString())
  2110. {
  2111. return;
  2112. }
  2114.     const LLWString textString(getWText());
  2115. const llwchar *text = textString.c_str();
  2116. const S32 text_len = getLength();
  2117. const S32 num_lines = getLineCount();
  2119. S32 cur_line = getFirstVisibleLine();
  2120. if (cur_line >= num_lines)
  2121. {
  2122. return;
  2123. }
  2125. const S32 line_height = llround( mDefaultFont->getLineHeight() );
  2127. S32 line_start = getLineStart(cur_line);
  2128. S32 line_y = mVisibleTextRect.mTop - line_height;
  2129. while((mVisibleTextRect.mBottom <= line_y) && (num_lines > cur_line))
  2130. {
  2131. S32 next_start = -1;
  2132. S32 line_end = text_len;
  2134. if ((cur_line + 1) < num_lines)
  2135. {
  2136. next_start = getLineStart(cur_line + 1);
  2137. line_end = next_start;
  2138. }
  2139. if ( text[line_end-1] == 'n' )
  2140. {
  2141. --line_end;
  2142. }
  2144. // Does this line contain preedits?
  2145. if (line_start >= mPreeditPositions.back())
  2146. {
  2147. // We have passed the preedits.
  2148. break;
  2149. }
  2150. if (line_end > mPreeditPositions.front())
  2151. {
  2152. for (U32 i = 0; i < mPreeditStandouts.size(); i++)
  2153. {
  2154. S32 left = mPreeditPositions[i];
  2155. S32 right = mPreeditPositions[i + 1];
  2156. if (right <= line_start || left >= line_end)
  2157. {
  2158. continue;
  2159. }
  2161. S32 preedit_left = mVisibleTextRect.mLeft;
  2162. if (left > line_start)
  2163. {
  2164. preedit_left += mDefaultFont->getWidth(text, line_start, left - line_start);
  2165. }
  2166. S32 preedit_right = mVisibleTextRect.mLeft;
  2167. if (right < line_end)
  2168. {
  2169. preedit_right += mDefaultFont->getWidth(text, line_start, right - line_start);
  2170. }
  2171. else
  2172. {
  2173. preedit_right += mDefaultFont->getWidth(text, line_start, line_end - line_start);
  2174. }
  2176. if (mPreeditStandouts[i])
  2177. {
  2178. gl_rect_2d(preedit_left + preedit_standout_gap,
  2179. line_y + preedit_standout_position,
  2180. preedit_right - preedit_standout_gap - 1,
  2181. line_y + preedit_standout_position - preedit_standout_thickness,
  2182. (mCursorColor.get() * preedit_standout_brightness + mWriteableBgColor.get() * (1 - preedit_standout_brightness)).setAlpha(1.0f));
  2183. }
  2184. else
  2185. {
  2186. gl_rect_2d(preedit_left + preedit_marker_gap,
  2187. line_y + preedit_marker_position,
  2188. preedit_right - preedit_marker_gap - 1,
  2189. line_y + preedit_marker_position - preedit_marker_thickness,
  2190. (mCursorColor.get() * preedit_marker_brightness + mWriteableBgColor.get() * (1 - preedit_marker_brightness)).setAlpha(1.0f));
  2191. }
  2192. }
  2193. }
  2195. // move down one line
  2196. line_y -= line_height;
  2197. line_start = next_start;
  2198. cur_line++;
  2199. }
  2200. }
  2203. void LLTextEditor::drawLineNumbers()
  2204. {
  2205. LLGLSUIDefault gls_ui;
  2206. LLRect scrolled_view_rect = getVisibleDocumentRect();
  2207. LLRect content_rect = getVisibleTextRect();
  2208. LLLocalClipRect clip(content_rect);
  2209. S32 first_line = getFirstVisibleLine();
  2210. S32 num_lines = getLineCount();
  2211. if (first_line >= num_lines)
  2212. {
  2213. return;
  2214. }
  2216. S32 cursor_line = mLineInfoList[getLineNumFromDocIndex(mCursorPos)].mLineNum;
  2218. if (mShowLineNumbers)
  2219. {
  2220. S32 left = 0;
  2221. S32 top = getRect().getHeight();
  2222. S32 bottom = 0;
  2224. gl_rect_2d(left, top, UI_TEXTEDITOR_LINE_NUMBER_MARGIN, bottom, mReadOnlyBgColor.get() ); // line number area always read-only
  2225. gl_rect_2d(UI_TEXTEDITOR_LINE_NUMBER_MARGIN, top, UI_TEXTEDITOR_LINE_NUMBER_MARGIN-1, bottom, LLColor4::grey3); // separator
  2227. S32 last_line_num = -1;
  2229. for (S32 cur_line = first_line; cur_line < num_lines; cur_line++)
  2230. {
  2231. line_info& line = mLineInfoList[cur_line];
  2233. if ((line.mRect.mTop - scrolled_view_rect.mBottom) < mVisibleTextRect.mBottom) 
  2234. {
  2235. break;
  2236. }
  2238. S32 line_bottom = line.mRect.mBottom - scrolled_view_rect.mBottom + mVisibleTextRect.mBottom;
  2239. // draw the line numbers
  2240. if(line.mLineNum != last_line_num && line.mRect.mTop <= scrolled_view_rect.mTop) 
  2241. {
  2242. const LLFontGL *num_font = LLFontGL::getFontMonospace();
  2243. const LLWString ltext = utf8str_to_wstring(llformat("%d", line.mLineNum ));
  2244. BOOL is_cur_line = cursor_line == line.mLineNum;
  2245. const U8 style = is_cur_line ? LLFontGL::BOLD : LLFontGL::NORMAL;
  2246. const LLColor4 fg_color = is_cur_line ? mCursorColor : mReadOnlyFgColor;
  2247. num_font->render( 
  2248. ltext, // string to draw
  2249. 0, // begin offset
  2250. UI_TEXTEDITOR_LINE_NUMBER_MARGIN - 2, // x
  2251. line_bottom, // y
  2252. fg_color, 
  2253. LLFontGL::RIGHT, // horizontal alignment
  2254. LLFontGL::BOTTOM, // vertical alignment
  2255. style,
  2256. LLFontGL::NO_SHADOW,
  2257. S32_MAX, // max chars
  2258. UI_TEXTEDITOR_LINE_NUMBER_MARGIN - 2); // max pixels
  2259. last_line_num = line.mLineNum;
  2260. }
  2261. }
  2262. }
  2263. }
  2265. void LLTextEditor::draw()
  2266. {
  2267. {
  2268. // pad clipping rectangle so that cursor can draw at full width
  2269. // when at left edge of mVisibleTextRect
  2270. LLRect clip_rect(mVisibleTextRect);
  2271. clip_rect.stretch(1);
  2272. LLLocalClipRect clip(clip_rect);
  2273. drawPreeditMarker();
  2274. }
  2276. LLTextBase::draw();
  2277. drawLineNumbers();
  2279. //RN: the decision was made to always show the orange border for keyboard focus but do not put an insertion caret
  2280. // when in readonly mode
  2281. mBorder->setKeyboardFocusHighlight( hasFocus() );// && !mReadOnly);
  2282. }
  2284. // Start or stop the editor from accepting text-editing keystrokes
  2285. // see also LLLineEditor
  2286. void LLTextEditor::setFocus( BOOL new_state )
  2287. {
  2288. BOOL old_state = hasFocus();
  2290. // Don't change anything if the focus state didn't change
  2291. if (new_state == old_state) return;
  2293. // Notify early if we are losing focus.
  2294. if (!new_state)
  2295. {
  2296. getWindow()->allowLanguageTextInput(this, FALSE);
  2297. }
  2299. LLTextBase::setFocus( new_state );
  2301. if( new_state )
  2302. {
  2303. // Route menu to this class
  2304. gEditMenuHandler = this;
  2306. // Don't start the cursor flashing right away
  2307. resetCursorBlink();
  2308. }
  2309. else
  2310. {
  2311. // Route menu back to the default
  2312. if( gEditMenuHandler == this )
  2313. {
  2314. gEditMenuHandler = NULL;
  2315. }
  2317. endSelection();
  2318. }
  2319. }
  2321. // public
  2322. void LLTextEditor::setCursorAndScrollToEnd()
  2323. {
  2324. deselect();
  2325. endOfDoc();
  2326. }
  2328. void LLTextEditor::getCurrentLineAndColumn( S32* line, S32* col, BOOL include_wordwrap ) 
  2329. { 
  2330. *line = getLineNumFromDocIndex(mCursorPos, include_wordwrap);
  2331. *col = getLineOffsetFromDocIndex(mCursorPos, include_wordwrap);
  2332. }
  2334. void LLTextEditor::autoIndent()
  2335. {
  2336. // Count the number of spaces in the current line
  2337. S32 line = getLineNumFromDocIndex(mCursorPos);
  2338. S32 line_start = getLineStart(line);
  2339. S32 space_count = 0;
  2340. S32 i;
  2342. LLWString text = getWText();
  2343. while( ' ' == text[line_start] )
  2344. {
  2345. space_count++;
  2346. line_start++;
  2347. }
  2349. // If we're starting a braced section, indent one level.
  2350. if( (mCursorPos > 0) && (text[mCursorPos -1] == '{') )
  2351. {
  2352. space_count += SPACES_PER_TAB;
  2353. }
  2355. // Insert that number of spaces on the new line
  2356. addChar( 'n' );
  2357. for( i = 0; i < space_count; i++ )
  2358. {
  2359. addChar( ' ' );
  2360. }
  2361. }
  2363. // Inserts new text at the cursor position
  2364. void LLTextEditor::insertText(const std::string &new_text)
  2365. {
  2366. BOOL enabled = getEnabled();
  2367. setEnabled( TRUE );
  2369. // Delete any selected characters (the insertion replaces them)
  2370. if( hasSelection() )
  2371. {
  2372. deleteSelection(TRUE);
  2373. }
  2375. setCursorPos(mCursorPos + insert( mCursorPos, utf8str_to_wstring(new_text), FALSE, LLTextSegmentPtr() ));
  2377. setEnabled( enabled );
  2378. }
  2380. void LLTextEditor::appendWidget(const LLInlineViewSegment::Params& params, const std::string& text, bool allow_undo)
  2381. {
  2382. // Save old state
  2383. S32 selection_start = mSelectionStart;
  2384. S32 selection_end = mSelectionEnd;
  2385. BOOL was_selecting = mIsSelecting;
  2386. S32 cursor_pos = mCursorPos;
  2387. S32 old_length = getLength();
  2388. BOOL cursor_was_at_end = (mCursorPos == old_length);
  2390. deselect();
  2392. setCursorPos(old_length);
  2394. LLWString widget_wide_text = utf8str_to_wstring(text);
  2396. LLTextSegmentPtr segment = new LLInlineViewSegment(params, old_length, old_length + widget_wide_text.size());
  2397. insert(getLength(), widget_wide_text, FALSE, segment);
  2399. // Set the cursor and scroll position
  2400. if( selection_start != selection_end )
  2401. {
  2402. mSelectionStart = selection_start;
  2403. mSelectionEnd = selection_end;
  2405. mIsSelecting = was_selecting;
  2406. setCursorPos(cursor_pos);
  2407. }
  2408. else if( cursor_was_at_end )
  2409. {
  2410. setCursorPos(getLength());
  2411. }
  2412. else
  2413. {
  2414. setCursorPos(cursor_pos);
  2415. }
  2417. if (!allow_undo)
  2418. {
  2419. blockUndo();
  2420. }
  2421. }
  2423. void LLTextEditor::removeTextFromEnd(S32 num_chars)
  2424. {
  2425. if (num_chars <= 0) return;
  2427. remove(getLength() - num_chars, num_chars, FALSE);
  2429. S32 len = getLength();
  2430. setCursorPos (llclamp(mCursorPos, 0, len));
  2431. mSelectionStart = llclamp(mSelectionStart, 0, len);
  2432. mSelectionEnd = llclamp(mSelectionEnd, 0, len);
  2434. needsScroll();
  2435. }
  2437. //----------------------------------------------------------------------------
  2439. void LLTextEditor::makePristine()
  2440. {
  2441. mPristineCmd = mLastCmd;
  2442. mBaseDocIsPristine = !mLastCmd;
  2444. // Create a clean partition in the undo stack.  We don't want a single command to extend from
  2445. // the "pre-pristine" state to the "post-pristine" state.
  2446. if( mLastCmd )
  2447. {
  2448. mLastCmd->blockExtensions();
  2449. }
  2450. }
  2452. BOOL LLTextEditor::isPristine() const
  2453. {
  2454. if( mPristineCmd )
  2455. {
  2456. return (mPristineCmd == mLastCmd);
  2457. }
  2458. else
  2459. {
  2460. // No undo stack, so check if the version before and commands were done was the original version
  2461. return !mLastCmd && mBaseDocIsPristine;
  2462. }
  2463. }
  2465. BOOL LLTextEditor::tryToRevertToPristineState()
  2466. {
  2467. if( !isPristine() )
  2468. {
  2469. deselect();
  2470. S32 i = 0;
  2471. while( !isPristine() && canUndo() )
  2472. {
  2473. undo();
  2474. i--;
  2475. }
  2477. while( !isPristine() && canRedo() )
  2478. {
  2479. redo();
  2480. i++;
  2481. }
  2483. if( !isPristine() )
  2484. {
  2485. // failed, so go back to where we started
  2486. while( i > 0 )
  2487. {
  2488. undo();
  2489. i--;
  2490. }
  2491. }
  2492. }
  2494. return isPristine(); // TRUE => success
  2495. }
  2498. static LLFastTimer::DeclareTimer FTM_SYNTAX_HIGHLIGHTING("Syntax Highlighting");
  2499. void LLTextEditor::loadKeywords(const std::string& filename,
  2500. const std::vector<std::string>& funcs,
  2501. const std::vector<std::string>& tooltips,
  2502. const LLColor3& color)
  2503. {
  2504. LLFastTimer ft(FTM_SYNTAX_HIGHLIGHTING);
  2505. if(mKeywords.loadFromFile(filename))
  2506. {
  2507. S32 count = llmin(funcs.size(), tooltips.size());
  2508. for(S32 i = 0; i < count; i++)
  2509. {
  2510. std::string name = utf8str_trim(funcs[i]);
  2511. mKeywords.addToken(LLKeywordToken::WORD, name, color, tooltips[i] );
  2512. }
  2513. segment_vec_t segment_list;
  2514. mKeywords.findSegments(&segment_list, getWText(), mDefaultColor.get(), *this);
  2516. mSegments.clear();
  2517. segment_set_t::iterator insert_it = mSegments.begin();
  2518. for (segment_vec_t::iterator list_it = segment_list.begin(); list_it != segment_list.end(); ++list_it)
  2519. {
  2520. insert_it = mSegments.insert(insert_it, *list_it);
  2521. }
  2522. }
  2523. }
  2525. void LLTextEditor::updateSegments()
  2526. {
  2527. if (mReflowIndex < S32_MAX && mKeywords.isLoaded())
  2528. {
  2529. LLFastTimer ft(FTM_SYNTAX_HIGHLIGHTING);
  2530. // HACK:  No non-ascii keywords for now
  2531. segment_vec_t segment_list;
  2532. mKeywords.findSegments(&segment_list, getWText(), mDefaultColor.get(), *this);
  2534. clearSegments();
  2535. segment_set_t::iterator insert_it = mSegments.begin();
  2536. for (segment_vec_t::iterator list_it = segment_list.begin(); list_it != segment_list.end(); ++list_it)
  2537. {
  2538. insertSegment(*list_it);
  2539. }
  2540. }
  2542. LLTextBase::updateSegments();
  2543. }
  2545. void LLTextEditor::updateLinkSegments()
  2546. {
  2547. LLWString wtext = getWText();
  2549. // update any segments that contain a link
  2550. for (segment_set_t::iterator it = mSegments.begin(); it != mSegments.end(); ++it)
  2551. {
  2552. LLTextSegment *segment = *it;
  2553. if (segment && segment->getStyle() && segment->getStyle()->isLink())
  2554. {
  2555. // if the link's label (what the user can edit) is a valid Url,
  2556. // then update the link's HREF to be the same as the label text.
  2557. // This lets users edit Urls in-place.
  2558. LLStyleConstSP style = segment->getStyle();
  2559. LLStyleSP new_style(new LLStyle(*style));
  2560. LLWString url_label = wtext.substr(segment->getStart(), segment->getEnd()-segment->getStart());
  2561. if (LLUrlRegistry::instance().hasUrl(url_label))
  2562. {
  2563. std::string new_url = wstring_to_utf8str(url_label);
  2564. LLStringUtil::trim(new_url);
  2565. new_style->setLinkHREF(new_url);
  2566. LLStyleConstSP sp(new_style);
  2567. segment->setStyle(sp);
  2568. }
  2569. }
  2570. }
  2571. }
  2575. void LLTextEditor::onMouseCaptureLost()
  2576. {
  2577. endSelection();
  2578. }
  2580. ///////////////////////////////////////////////////////////////////
  2581. // Hack for Notecards
  2583. BOOL LLTextEditor::importBuffer(const char* buffer, S32 length )
  2584. {
  2585. std::istringstream instream(buffer);
  2587. // Version 1 format:
  2588. // Linden text version 1n
  2589. // {n
  2590. // <EmbeddedItemList chunk>
  2591. // Text length <bytes without >n
  2592. // <text without > (text may contain ext_char_values)
  2593. // }n
  2595. char tbuf[MAX_STRING]; /* Flawfinder: ignore */
  2597. S32 version = 0;
  2598. instream.getline(tbuf, MAX_STRING);
  2599. if( 1 != sscanf(tbuf, "Linden text version %d", &version) )
  2600. {
  2601. llwarns << "Invalid Linden text file header " << llendl;
  2602. return FALSE;
  2603. }
  2605. if( 1 != version )
  2606. {
  2607. llwarns << "Invalid Linden text file version: " << version << llendl;
  2608. return FALSE;
  2609. }
  2611. instream.getline(tbuf, MAX_STRING);
  2612. if( 0 != sscanf(tbuf, "{") )
  2613. {
  2614. llwarns << "Invalid Linden text file format" << llendl;
  2615. return FALSE;
  2616. }
  2618. S32 text_len = 0;
  2619. instream.getline(tbuf, MAX_STRING);
  2620. if( 1 != sscanf(tbuf, "Text length %d", &text_len) )
  2621. {
  2622. llwarns << "Invalid Linden text length field" << llendl;
  2623. return FALSE;
  2624. }
  2626. if( text_len > mMaxTextByteLength )
  2627. {
  2628. llwarns << "Invalid Linden text length: " << text_len << llendl;
  2629. return FALSE;
  2630. }
  2632. BOOL success = TRUE;
  2634. char* text = new char[ text_len + 1];
  2635. if (text == NULL)
  2636. {
  2637. llerrs << "Memory allocation failure." << llendl;
  2638. return FALSE;
  2639. }
  2640. instream.get(text, text_len + 1, '');
  2641. text[text_len] = '';
  2642. if( text_len != (S32)strlen(text) )/* Flawfinder: ignore */
  2643. {
  2644. llwarns << llformat("Invalid text length: %d != %d ",strlen(text),text_len) << llendl;/* Flawfinder: ignore */
  2645. success = FALSE;
  2646. }
  2648. instream.getline(tbuf, MAX_STRING);
  2649. if( success && (0 != sscanf(tbuf, "}")) )
  2650. {
  2651. llwarns << "Invalid Linden text file format: missing terminal }" << llendl;
  2652. success = FALSE;
  2653. }
  2655. if( success )
  2656. {
  2657. // Actually set the text
  2658. setText( LLStringExplicit(text) );
  2659. }
  2661. delete[] text;
  2663. startOfDoc();
  2664. deselect();
  2666. return success;
  2667. }
  2669. BOOL LLTextEditor::exportBuffer(std::string &buffer )
  2670. {
  2671. std::ostringstream outstream(buffer);
  2673. outstream << "Linden text version 1n";
  2674. outstream << "{n";
  2676. outstream << llformat("Text length %dn", getLength() );
  2677. outstream << getText();
  2678. outstream << "}n";
  2680. return TRUE;
  2681. }
  2683. void LLTextEditor::updateAllowingLanguageInput()
  2684. {
  2685. LLWindow* window = getWindow();
  2686. if (!window)
  2687. {
  2688. // test app, no window available
  2689. return;
  2690. }
  2691. if (hasFocus() && !mReadOnly)
  2692. {
  2693. window->allowLanguageTextInput(this, TRUE);
  2694. }
  2695. else
  2696. {
  2697. window->allowLanguageTextInput(this, FALSE);
  2698. }
  2699. }
  2701. // Preedit is managed off the undo/redo command stack.
  2703. BOOL LLTextEditor::hasPreeditString() const
  2704. {
  2705. return (mPreeditPositions.size() > 1);
  2706. }
  2708. void LLTextEditor::resetPreedit()
  2709. {
  2710. if (hasPreeditString())
  2711. {
  2712. if (hasSelection())
  2713. {
  2714. llwarns << "Preedit and selection!" << llendl;
  2715. deselect();
  2716. }
  2718. setCursorPos(mPreeditPositions.front());
  2719. removeStringNoUndo(mCursorPos, mPreeditPositions.back() - mCursorPos);
  2720. insertStringNoUndo(mCursorPos, mPreeditOverwrittenWString);
  2722. mPreeditWString.clear();
  2723. mPreeditOverwrittenWString.clear();
  2724. mPreeditPositions.clear();
  2726. // A call to updatePreedit should soon follow under a
  2727. // normal course of operation, so we don't need to 
  2728. // maintain internal variables such as line start 
  2729. // positions now.
  2730. }
  2731. }
  2733. void LLTextEditor::updatePreedit(const LLWString &preedit_string,
  2734. const segment_lengths_t &preedit_segment_lengths, const standouts_t &preedit_standouts, S32 caret_position)
  2735. {
  2736. // Just in case.
  2737. if (mReadOnly)
  2738. {
  2739. return;
  2740. }
  2742. getWindow()->hideCursorUntilMouseMove();
  2744. S32 insert_preedit_at = mCursorPos;
  2746. mPreeditWString = preedit_string;
  2747. mPreeditPositions.resize(preedit_segment_lengths.size() + 1);
  2748. S32 position = insert_preedit_at;
  2749. for (segment_lengths_t::size_type i = 0; i < preedit_segment_lengths.size(); i++)
  2750. {
  2751. mPreeditPositions[i] = position;
  2752. position += preedit_segment_lengths[i];
  2753. }
  2754. mPreeditPositions.back() = position;
  2756. if (LL_KIM_OVERWRITE == gKeyboard->getInsertMode())
  2757. {
  2758. mPreeditOverwrittenWString = getWText().substr(insert_preedit_at, mPreeditWString.length());
  2759. removeStringNoUndo(insert_preedit_at, mPreeditWString.length());
  2760. }
  2761. else
  2762. {
  2763. mPreeditOverwrittenWString.clear();
  2764. }
  2765. insertStringNoUndo(insert_preedit_at, mPreeditWString);
  2767. mPreeditStandouts = preedit_standouts;
  2769. setCursorPos(insert_preedit_at + caret_position);
  2771. // Update of the preedit should be caused by some key strokes.
  2772. resetCursorBlink();
  2774. onKeyStroke();
  2775. }
  2777. BOOL LLTextEditor::getPreeditLocation(S32 query_offset, LLCoordGL *coord, LLRect *bounds, LLRect *control) const
  2778. {
  2779. if (control)
  2780. {
  2781. LLRect control_rect_screen;
  2782. localRectToScreen(mVisibleTextRect, &control_rect_screen);
  2783. LLUI::screenRectToGL(control_rect_screen, control);
  2784. }
  2786. S32 preedit_left_position, preedit_right_position;
  2787. if (hasPreeditString())
  2788. {
  2789. preedit_left_position = mPreeditPositions.front();
  2790. preedit_right_position = mPreeditPositions.back();
  2791. }
  2792. else
  2793. {
  2794. preedit_left_position = preedit_right_position = mCursorPos;
  2795. }
  2797. const S32 query = (query_offset >= 0 ? preedit_left_position + query_offset : mCursorPos);
  2798. if (query < preedit_left_position || query > preedit_right_position)
  2799. {
  2800. return FALSE;
  2801. }
  2803. const S32 first_visible_line = getFirstVisibleLine();
  2804. if (query < getLineStart(first_visible_line))
  2805. {
  2806. return FALSE;
  2807. }
  2809. S32 current_line = first_visible_line;
  2810. S32 current_line_start, current_line_end;
  2811. for (;;)
  2812. {
  2813. current_line_start = getLineStart(current_line);
  2814. current_line_end = getLineStart(current_line + 1);
  2815. if (query >= current_line_start && query < current_line_end)
  2816. {
  2817. break;
  2818. }
  2819. if (current_line_start == current_line_end)
  2820. {
  2821. // We have reached on the last line.  The query position must be here.
  2822. break;
  2823. }
  2824. current_line++;
  2825. }
  2827.     const LLWString textString(getWText());
  2828. const llwchar * const text = textString.c_str();
  2829. const S32 line_height = llround(mDefaultFont->getLineHeight());
  2831. if (coord)
  2832. {
  2833. const S32 query_x = mVisibleTextRect.mLeft + mDefaultFont->getWidth(text, current_line_start, query - current_line_start);
  2834. const S32 query_y = mVisibleTextRect.mTop - (current_line - first_visible_line) * line_height - line_height / 2;
  2835. S32 query_screen_x, query_screen_y;
  2836. localPointToScreen(query_x, query_y, &query_screen_x, &query_screen_y);
  2837. LLUI::screenPointToGL(query_screen_x, query_screen_y, &coord->mX, &coord->mY);
  2838. }
  2840. if (bounds)
  2841. {
  2842. S32 preedit_left = mVisibleTextRect.mLeft;
  2843. if (preedit_left_position > current_line_start)
  2844. {
  2845. preedit_left += mDefaultFont->getWidth(text, current_line_start, preedit_left_position - current_line_start);
  2846. }
  2848. S32 preedit_right = mVisibleTextRect.mLeft;
  2849. if (preedit_right_position < current_line_end)
  2850. {
  2851. preedit_right += mDefaultFont->getWidth(text, current_line_start, preedit_right_position - current_line_start);
  2852. }
  2853. else
  2854. {
  2855. preedit_right += mDefaultFont->getWidth(text, current_line_start, current_line_end - current_line_start);
  2856. }
  2858. const S32 preedit_top = mVisibleTextRect.mTop - (current_line - first_visible_line) * line_height;
  2859. const S32 preedit_bottom = preedit_top - line_height;
  2861. const LLRect preedit_rect_local(preedit_left, preedit_top, preedit_right, preedit_bottom);
  2862. LLRect preedit_rect_screen;
  2863. localRectToScreen(preedit_rect_local, &preedit_rect_screen);
  2864. LLUI::screenRectToGL(preedit_rect_screen, bounds);
  2865. }
  2867. return TRUE;
  2868. }
  2870. void LLTextEditor::getSelectionRange(S32 *position, S32 *length) const
  2871. {
  2872. if (hasSelection())
  2873. {
  2874. *position = llmin(mSelectionStart, mSelectionEnd);
  2875. *length = llabs(mSelectionStart - mSelectionEnd);
  2876. }
  2877. else
  2878. {
  2879. *position = mCursorPos;
  2880. *length = 0;
  2881. }
  2882. }
  2884. void LLTextEditor::getPreeditRange(S32 *position, S32 *length) const
  2885. {
  2886. if (hasPreeditString())
  2887. {
  2888. *position = mPreeditPositions.front();
  2889. *length = mPreeditPositions.back() - mPreeditPositions.front();
  2890. }
  2891. else
  2892. {
  2893. *position = mCursorPos;
  2894. *length = 0;
  2895. }
  2896. }
  2898. void LLTextEditor::markAsPreedit(S32 position, S32 length)
  2899. {
  2900. deselect();
  2901. setCursorPos(position);
  2902. if (hasPreeditString())
  2903. {
  2904. llwarns << "markAsPreedit invoked when hasPreeditString is true." << llendl;
  2905. }
  2906. mPreeditWString = LLWString( getWText(), position, length );
  2907. if (length > 0)
  2908. {
  2909. mPreeditPositions.resize(2);
  2910. mPreeditPositions[0] = position;
  2911. mPreeditPositions[1] = position + length;
  2912. mPreeditStandouts.resize(1);
  2913. mPreeditStandouts[0] = FALSE;
  2914. }
  2915. else
  2916. {
  2917. mPreeditPositions.clear();
  2918. mPreeditStandouts.clear();
  2919. }
  2920. if (LL_KIM_OVERWRITE == gKeyboard->getInsertMode())
  2921. {
  2922. mPreeditOverwrittenWString = mPreeditWString;
  2923. }
  2924. else
  2925. {
  2926. mPreeditOverwrittenWString.clear();
  2927. }
  2928. }
  2930. S32 LLTextEditor::getPreeditFontSize() const
  2931. {
  2932. return llround(mDefaultFont->getLineHeight() * LLUI::sGLScaleFactor.mV[VY]);
  2933. }
  2935. BOOL LLTextEditor::isDirty() const
  2936. {
  2937. if(mReadOnly)
  2938. {
  2939. return FALSE;
  2940. }
  2942. if( mPristineCmd )
  2943. {
  2944. return ( mPristineCmd == mLastCmd );
  2945. }
  2946. else
  2947. {
  2948. return ( NULL != mLastCmd );
  2949. }
  2950. }
  2952. void LLTextEditor::setKeystrokeCallback(const keystroke_signal_t::slot_type& callback)
  2953. {
  2954. mKeystrokeSignal.connect(callback);
  2955. }
  2957. void LLTextEditor::onKeyStroke()
  2958. {
  2959. mKeystrokeSignal(this);
  2960. }
  2962. //virtual
  2963. void LLTextEditor::clear()
  2964. {
  2965. getViewModel()->setDisplay(LLWStringUtil::null);
  2966. clearSegments();
  2967. }