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

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

游戏引擎

开发平台：

C++ Builder

lltextbase.h：源码内容
  1. /** 
  2.  * @file lltextbase.h
  3.  * @author Martin Reddy
  4.  * @brief The base class of text box/editor, providing Url handling support
  5.  *
  6.  * $LicenseInfo:firstyear=2009&license=viewergpl$
  7.  * 
  8.  * Copyright (c) 2009-2010, Linden Research, Inc.
  9.  * 
  10.  * Second Life Viewer Source Code
  11.  * The source code in this file ("Source Code") is provided by Linden Lab
  12.  * to you under the terms of the GNU General Public License, version 2.0
  13.  * ("GPL"), unless you have obtained a separate licensing agreement
  14.  * ("Other License"), formally executed by you and Linden Lab.  Terms of
  15.  * the GPL can be found in doc/GPL-license.txt in this distribution, or
  16.  * online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
  17.  * 
  18.  * There are special exceptions to the terms and conditions of the GPL as
  19.  * it is applied to this Source Code. View the full text of the exception
  20.  * in the file doc/FLOSS-exception.txt in this software distribution, or
  21.  * online at
  22.  * http://secondlifegrid.net/programs/open_source/licensing/flossexception
  23.  * 
  24.  * By copying, modifying or distributing this software, you acknowledge
  25.  * that you have read and understood your obligations described above,
  26.  * and agree to abide by those obligations.
  27.  * 
  28.  * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
  29.  * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
  30.  * COMPLETENESS OR PERFORMANCE.
  31.  * $/LicenseInfo$
  32.  */
  34. #ifndef LL_LLTEXTBASE_H
  35. #define LL_LLTEXTBASE_H
  37. #include "v4color.h"
  38. #include "lleditmenuhandler.h"
  39. #include "llstyle.h"
  40. #include "llkeywords.h"
  41. #include "llpanel.h"
  43. #include <string>
  44. #include <vector>
  45. #include <set>
  47. #include <boost/signals2.hpp>
  49. class LLContextMenu;
  50. class LLTextSegment;
  51. class LLNormalTextSegment;
  53. typedef LLPointer<LLTextSegment> LLTextSegmentPtr;
  55. ///
  56. /// The LLTextBase class provides a base class for all text fields, such
  57. /// as LLTextEditor and LLTextBox. It implements shared functionality
  58. /// such as Url highlighting and opening.
  59. ///
  60. class LLTextBase 
  61. : public LLUICtrl,
  62. protected LLEditMenuHandler
  63. {
  64. public:
  65. friend class LLTextSegment;
  66. friend class LLNormalTextSegment;
  68. struct LineSpacingParams : public LLInitParam::Choice<LineSpacingParams>
  69. {
  70. Alternative<F32> multiple;
  71. Alternative<S32> pixels;
  72. LineSpacingParams();
  73. };
  75. struct Params : public LLInitParam::Block<Params, LLUICtrl::Params>
  76. {
  77. Optional<LLUIColor> cursor_color,
  78. text_color,
  79. text_readonly_color,
  80. bg_readonly_color,
  81. bg_writeable_color,
  82. bg_focus_color;
  84. Optional<bool> bg_visible,
  85. border_visible,
  86. track_end,
  87. read_only,
  88. allow_scroll,
  89. wrap,
  90. use_ellipses,
  91. allow_html,
  92. parse_highlights,
  93. clip_partial;
  95. Optional<S32> v_pad,
  96. h_pad;
  99. Optional<LineSpacingParams>
  100. line_spacing;
  102. Optional<S32> max_text_length;
  104. Optional<LLFontGL::ShadowType> font_shadow;
  106. Params();
  107. };
  109. // LLMouseHandler interface
  110. /*virtual*/ BOOL handleMouseDown(S32 x, S32 y, MASK mask);
  111. /*virtual*/ BOOL handleMouseUp(S32 x, S32 y, MASK mask);
  112. /*virtual*/ BOOL handleMiddleMouseDown(S32 x, S32 y, MASK mask);
  113. /*virtual*/ BOOL handleMiddleMouseUp(S32 x, S32 y, MASK mask);
  114. /*virtual*/ BOOL handleRightMouseDown(S32 x, S32 y, MASK mask);
  115. /*virtual*/ BOOL handleRightMouseUp(S32 x, S32 y, MASK mask);
  116. /*virtual*/ BOOL handleDoubleClick(S32 x, S32 y, MASK mask);
  117. /*virtual*/ BOOL handleHover(S32 x, S32 y, MASK mask);
  118. /*virtual*/ BOOL handleScrollWheel(S32 x, S32 y, S32 clicks);
  119. /*virtual*/ BOOL handleToolTip(S32 x, S32 y, MASK mask);
  121. // LLView interface
  122. /*virtual*/ void reshape(S32 width, S32 height, BOOL called_from_parent = TRUE);
  123. /*virtual*/ void draw();
  125. // LLUICtrl interface
  126. /*virtual*/ BOOL acceptsTextInput() const { return !mReadOnly; }
  127. /*virtual*/ void setColor( const LLColor4& c );
  128. virtual     void  setReadOnlyColor(const LLColor4 &c);
  129. virtual     void handleVisibilityChange( BOOL new_visibility );
  131. /*virtual*/ void setValue(const LLSD& value );
  132. /*virtual*/ LLTextViewModel* getViewModel() const;
  134. // LLEditMenuHandler interface
  135. /*virtual*/ void deselect();
  137. // used by LLTextSegment layout code
  138. bool getWordWrap() { return mWordWrap; }
  139. bool getUseEllipses() { return mUseEllipses; }
  140. bool truncate(); // returns true of truncation occurred
  142. // TODO: move into LLTextSegment?
  143. void createUrlContextMenu(S32 x, S32 y, const std::string &url); // create a popup context menu for the given Url
  145. // Text accessors
  146. // TODO: add optional style parameter
  147. virtual void setText(const LLStringExplicit &utf8str , const LLStyle::Params& input_params = LLStyle::Params()); // uses default style
  148. virtual std::string getText() const;
  149. void setMaxTextLength(S32 length) { mMaxTextByteLength = length; }
  151. // wide-char versions
  152. void setWText(const LLWString& text);
  153. const LLWString&        getWText() const;
  155. void appendText(const std::string &new_text, bool prepend_newline, const LLStyle::Params& input_params = LLStyle::Params());
  156. // force reflow of text
  157. void needsReflow(S32 index = 0);
  159. S32 getLength() const { return getWText().length(); }
  160. S32 getLineCount() const { return mLineInfoList.size(); }
  162. void addDocumentChild(LLView* view);
  163. void removeDocumentChild(LLView* view);
  164. const LLView* getDocumentView() const { return mDocumentView; }
  165. LLRect getVisibleTextRect() { return mVisibleTextRect; }
  166. LLRect getTextBoundingRect();
  167. LLRect getVisibleDocumentRect() const;
  169. S32 getVPad() { return mVPad; }
  170. S32 getHPad() { return mHPad; }
  172. S32 getDocIndexFromLocalCoord( S32 local_x, S32 local_y, BOOL round, bool hit_past_end_of_line = true) const;
  173. LLRect getLocalRectFromDocIndex(S32 pos) const;
  174. LLRect getDocRectFromDocIndex(S32 pos) const;
  176. void setReadOnly(bool read_only) { mReadOnly = read_only; }
  177. bool getReadOnly() { return mReadOnly; }
  179. // cursor manipulation
  180. bool setCursor(S32 row, S32 column);
  181. bool setCursorPos(S32 cursor_pos, bool keep_cursor_offset = false);
  182. void startOfLine();
  183. void endOfLine();
  184. void startOfDoc();
  185. void endOfDoc();
  186. void changePage( S32 delta );
  187. void changeLine( S32 delta );
  189. bool scrolledToStart();
  190. bool scrolledToEnd();
  192. const LLFontGL* getDefaultFont() const { return mDefaultFont; }
  194. public:
  195. // Fired when a URL link is clicked
  196. commit_signal_t mURLClickSignal;
  198. protected:
  199. // helper structs
  200. struct compare_bottom;
  201. struct compare_top;
  202. struct line_end_compare;
  203. typedef std::vector<LLTextSegmentPtr> segment_vec_t;
  205. // Abstract inner base class representing an undoable editor command.
  206. // Concrete sub-classes can be defined for operations such as insert, remove, etc.
  207. // Used as arguments to the execute() method below.
  208. class TextCmd
  209. {
  210. public:
  211. TextCmd( S32 pos, BOOL group_with_next, LLTextSegmentPtr segment = LLTextSegmentPtr() ) 
  212. : mPos(pos), 
  213. mGroupWithNext(group_with_next)
  214. {
  215. if (segment.notNull())
  216. {
  217. mSegments.push_back(segment);
  218. }
  219. }
  220. virtual ~TextCmd() {}
  221. virtual BOOL execute(LLTextBase* editor, S32* delta) = 0;
  222. virtual S32 undo(LLTextBase* editor) = 0;
  223. virtual S32 redo(LLTextBase* editor) = 0;
  224. virtual BOOL canExtend(S32 pos) const { return FALSE; }
  225. virtual void blockExtensions() {}
  226. virtual BOOL extendAndExecute( LLTextBase* editor, S32 pos, llwchar c, S32* delta ) { llassert(0); return 0; }
  227. virtual BOOL hasExtCharValue( llwchar value ) const { return FALSE; }
  229. // Defined here so they can access protected LLTextEditor editing methods
  230. S32 insert(LLTextBase* editor, S32 pos, const LLWString &wstr) { return editor->insertStringNoUndo( pos, wstr, &mSegments ); }
  231. S32  remove(LLTextBase* editor, S32 pos, S32 length) { return editor->removeStringNoUndo( pos, length ); }
  232. S32 overwrite(LLTextBase* editor, S32 pos, llwchar wc) { return editor->overwriteCharNoUndo(pos, wc); }
  234. S32 getPosition() const { return mPos; }
  235. BOOL groupWithNext() const { return mGroupWithNext; }
  237. protected:
  238. const S32 mPos;
  239. BOOL mGroupWithNext;
  240. segment_vec_t mSegments;
  241. };
  243. struct compare_segment_end
  244. {
  245. bool operator()(const LLTextSegmentPtr& a, const LLTextSegmentPtr& b) const;
  246. };
  247. typedef std::multiset<LLTextSegmentPtr, compare_segment_end> segment_set_t;
  249. // protected member variables
  250. // List of offsets and segment index of the start of each line.  Always has at least one node (0).
  251. struct line_info
  252. {
  253. line_info(S32 index_start, S32 index_end, LLRect rect, S32 line_num);
  254. S32 mDocIndexStart;
  255. S32 mDocIndexEnd;
  256. LLRect mRect;
  257. S32 mLineNum; // actual line count (ignoring soft newlines due to word wrap)
  258. };
  259. typedef std::vector<line_info> line_list_t;
  261. // member functions
  262. LLTextBase(const Params &p);
  263. virtual ~LLTextBase();
  264. void initFromParams(const Params& p);
  265. virtual void onValueChange(S32 start, S32 end);
  267. // draw methods
  268. void drawSelectionBackground(); // draws the black box behind the selected text
  269. void drawCursor();
  270. void drawText();
  272. // modify contents
  273. S32 insertStringNoUndo(S32 pos, const LLWString &wstr, segment_vec_t* segments = NULL); // returns num of chars actually inserted
  274. S32  removeStringNoUndo(S32 pos, S32 length);
  275. S32 overwriteCharNoUndo(S32 pos, llwchar wc);
  276. void appendAndHighlightText(const std::string &new_text, bool prepend_newline, S32 highlight_part, const LLStyle::Params& stylep);
  279. // manage segments 
  280. void                 getSegmentAndOffset( S32 startpos, segment_set_t::const_iterator* seg_iter, S32* offsetp ) const;
  281. void                 getSegmentAndOffset( S32 startpos, segment_set_t::iterator* seg_iter, S32* offsetp );
  282. LLTextSegmentPtr     getSegmentAtLocalPos( S32 x, S32 y, bool hit_past_end_of_line = true);
  283. segment_set_t::iterator getSegIterContaining(S32 index);
  284. segment_set_t::const_iterator getSegIterContaining(S32 index) const;
  285. void                 clearSegments();
  286. void createDefaultSegment();
  287. virtual void updateSegments();
  288. void insertSegment(LLTextSegmentPtr segment_to_insert);
  289. LLStyle::Params getDefaultStyleParams();
  291. //  manage lines
  292. S32 getLineStart( S32 line ) const;
  293. S32 getLineEnd( S32 line ) const;
  294. S32 getLineNumFromDocIndex( S32 doc_index, bool include_wordwrap = true) const;
  295. S32 getLineOffsetFromDocIndex( S32 doc_index, bool include_wordwrap = true) const;
  296. S32 getFirstVisibleLine() const;
  297. std::pair<S32, S32> getVisibleLines(bool fully_visible = false);
  298. S32 getLeftOffset(S32 width);
  299. void reflow();
  301. // cursor
  302. void updateCursorXPos();
  303. void setCursorAtLocalPos( S32 local_x, S32 local_y, bool round, bool keep_cursor_offset=false );
  304. S32 getEditableIndex(S32 index, bool increasing_direction); // constraint cursor to editable segments of document
  305. void resetCursorBlink() { mCursorBlinkTimer.reset(); }
  306. void updateScrollFromCursor();
  308. // text selection
  309. bool hasSelection() const { return (mSelectionStart !=mSelectionEnd); }
  310. void  startSelection();
  311. void  endSelection();
  313. // misc
  314. void updateRects();
  315. void needsScroll() { mScrollNeeded = TRUE; }
  316. void replaceUrlLabel(const std::string &url, const std::string &label);
  318. protected:
  319. // text segmentation and flow
  320. segment_set_t        mSegments;
  321. line_list_t mLineInfoList;
  322. LLRect mVisibleTextRect; // The rect in which text is drawn.  Excludes borders.
  323. LLRect mTextBoundingRect;
  325. // colors
  326. LLUIColor mCursorColor;
  327. LLUIColor mFgColor;
  328. LLUIColor mReadOnlyFgColor;
  329. LLUIColor mWriteableBgColor;
  330. LLUIColor mReadOnlyBgColor;
  331. LLUIColor mFocusBgColor;
  333. // cursor
  334. S32 mCursorPos; // I-beam is just after the mCursorPos-th character.
  335. S32 mDesiredXPixel; // X pixel position where the user wants the cursor to be
  336. LLFrameTimer mCursorBlinkTimer;  // timer that controls cursor blinking
  338. // selection
  339. S32 mSelectionStart;
  340. S32 mSelectionEnd;
  342. BOOL mIsSelecting; // Are we in the middle of a drag-select? 
  344. // configuration
  345. S32 mHPad; // padding on left of text
  346. S32 mVPad; // padding above text
  347. LLFontGL::HAlign mHAlign;
  348. F32 mLineSpacingMult; // multiple of line height used as space for a single line of text (e.g. 1.5 to get 50% padding)
  349. S32 mLineSpacingPixels; // padding between lines
  350. const LLFontGL* mDefaultFont; // font that is used when none specified
  351. LLFontGL::ShadowType mFontShadow;
  352. bool mBorderVisible;
  353. bool                 mParseHTML; // make URLs interactive
  354. bool mParseHighlights; // highlight user-defined keywords
  355. bool                 mWordWrap;
  356. bool mUseEllipses;
  357. bool mTrackEnd; // if true, keeps scroll position at end of document during resize
  358. bool mReadOnly;
  359. bool mBGVisible; // render background?
  360. bool mClipPartial; // false if we show lines that are partially inside bounding rect
  361. S32 mMaxTextByteLength; // Maximum length mText is allowed to be in bytes
  363. // support widgets
  364. LLContextMenu* mPopupMenu;
  365. LLView* mDocumentView;
  366. class LLScrollContainer* mScroller;
  368. // transient state
  369. S32 mReflowIndex; // index at which to start reflow.  S32_MAX indicates no reflow needed.
  370. bool mScrollNeeded; // need to change scroll region because of change to cursor position
  371. S32 mScrollIndex; // index of first character to keep visible in scroll region
  373. };
  375. ///
  376. /// A text segment is used to specify a subsection of a text string
  377. /// that should be formatted differently, such as a hyperlink. It
  378. /// includes a start/end offset from the start of the string, a
  379. /// style to render with, an optional tooltip, etc.
  380. ///
  381. class LLTextSegment : public LLRefCount, public LLMouseHandler
  382. {
  383. public:
  384. LLTextSegment(S32 start, S32 end) : mStart(start), mEnd(end){};
  385. virtual ~LLTextSegment();
  387. virtual bool getDimensions(S32 first_char, S32 num_chars, S32& width, S32& height) const;
  388. virtual S32 getOffset(S32 segment_local_x_coord, S32 start_offset, S32 num_chars, bool round) const;
  389. virtual S32 getNumChars(S32 num_pixels, S32 segment_offset, S32 line_offset, S32 max_chars) const;
  390. virtual void updateLayout(const class LLTextBase& editor);
  391. virtual F32 draw(S32 start, S32 end, S32 selection_start, S32 selection_end, const LLRect& draw_rect);
  392. virtual bool canEdit() const;
  393. virtual void unlinkFromDocument(class LLTextBase* editor);
  394. virtual void linkToDocument(class LLTextBase* editor);
  396. virtual const LLColor4& getColor() const;
  397. //virtual void  setColor(const LLColor4 &color);
  398. virtual LLStyleConstSP getStyle() const;
  399. virtual void  setStyle(LLStyleConstSP style);
  400. virtual void setToken( LLKeywordToken* token );
  401. virtual LLKeywordToken* getToken() const;
  402. virtual void setToolTip(const std::string& tooltip);
  403. virtual void dump() const;
  405. // LLMouseHandler interface
  406. /*virtual*/ BOOL handleMouseDown(S32 x, S32 y, MASK mask);
  407. /*virtual*/ BOOL handleMouseUp(S32 x, S32 y, MASK mask);
  408. /*virtual*/ BOOL handleMiddleMouseDown(S32 x, S32 y, MASK mask);
  409. /*virtual*/ BOOL handleMiddleMouseUp(S32 x, S32 y, MASK mask);
  410. /*virtual*/ BOOL handleRightMouseDown(S32 x, S32 y, MASK mask);
  411. /*virtual*/ BOOL handleRightMouseUp(S32 x, S32 y, MASK mask);
  412. /*virtual*/ BOOL handleDoubleClick(S32 x, S32 y, MASK mask);
  413. /*virtual*/ BOOL handleHover(S32 x, S32 y, MASK mask);
  414. /*virtual*/ BOOL handleScrollWheel(S32 x, S32 y, S32 clicks);
  415. /*virtual*/ BOOL handleToolTip(S32 x, S32 y, MASK mask);
  416. /*virtual*/ std::string getName() const;
  417. /*virtual*/ void onMouseCaptureLost();
  418. /*virtual*/ void screenPointToLocal(S32 screen_x, S32 screen_y, S32* local_x, S32* local_y) const;
  419. /*virtual*/ void localPointToScreen(S32 local_x, S32 local_y, S32* screen_x, S32* screen_y) const;
  420. /*virtual*/ BOOL hasMouseCapture();
  422. S32 getStart() const  { return mStart; }
  423. void setStart(S32 start) { mStart = start; }
  424. S32 getEnd() const { return mEnd; }
  425. void setEnd( S32 end ) { mEnd = end; }
  427. protected:
  428. S32 mStart;
  429. S32 mEnd;
  430. };
  432. class LLNormalTextSegment : public LLTextSegment
  433. {
  434. public:
  435. LLNormalTextSegment( LLStyleConstSP style, S32 start, S32 end, LLTextBase& editor );
  436. LLNormalTextSegment( const LLColor4& color, S32 start, S32 end, LLTextBase& editor, BOOL is_visible = TRUE);
  437. ~LLNormalTextSegment();
  439. /*virtual*/ bool getDimensions(S32 first_char, S32 num_chars, S32& width, S32& height) const;
  440. /*virtual*/ S32 getOffset(S32 segment_local_x_coord, S32 start_offset, S32 num_chars, bool round) const;
  441. /*virtual*/ S32 getNumChars(S32 num_pixels, S32 segment_offset, S32 line_offset, S32 max_chars) const;
  442. /*virtual*/ F32 draw(S32 start, S32 end, S32 selection_start, S32 selection_end, const LLRect& draw_rect);
  443. /*virtual*/ bool canEdit() const { return true; }
  444. /*virtual*/ const LLColor4& getColor() const { return mStyle->getColor(); }
  445. /*virtual*/ LLStyleConstSP getStyle() const { return mStyle; }
  446. /*virtual*/ void  setStyle(LLStyleConstSP style) { mStyle = style; }
  447. /*virtual*/ void setToken( LLKeywordToken* token ) { mToken = token; }
  448. /*virtual*/ LLKeywordToken* getToken() const { return mToken; }
  449. /*virtual*/ BOOL getToolTip( std::string& msg ) const;
  450. /*virtual*/ void setToolTip(const std::string& tooltip);
  451. /*virtual*/ void dump() const;
  453. /*virtual*/ BOOL handleHover(S32 x, S32 y, MASK mask);
  454. /*virtual*/ BOOL handleRightMouseDown(S32 x, S32 y, MASK mask);
  455. /*virtual*/ BOOL handleMouseDown(S32 x, S32 y, MASK mask);
  456. /*virtual*/ BOOL handleMouseUp(S32 x, S32 y, MASK mask);
  457. /*virtual*/ BOOL handleToolTip(S32 x, S32 y, MASK mask);
  459. protected:
  460. F32 drawClippedSegment(S32 seg_start, S32 seg_end, S32 selection_start, S32 selection_end, LLRect rect);
  462. protected:
  463. class LLTextBase& mEditor;
  464. LLStyleConstSP mStyle;
  465. S32 mFontHeight;
  466. LLKeywordToken*  mToken;
  467. std::string      mTooltip;
  468. boost::signals2::connection mImageLoadedConnection;
  469. };
  471. class LLIndexSegment : public LLTextSegment
  472. {
  473. public:
  474. LLIndexSegment(S32 pos) : LLTextSegment(pos, pos) {}
  475. };
  477. class LLInlineViewSegment : public LLTextSegment
  478. {
  479. public:
  480. struct Params : public LLInitParam::Block<Params>
  481. {
  482. Mandatory<LLView*> view;
  483. Optional<bool> force_newline;
  484. Optional<S32> left_pad,
  485. right_pad,
  486. bottom_pad,
  487. top_pad;
  488. };
  490. LLInlineViewSegment(const Params& p, S32 start, S32 end);
  491. ~LLInlineViewSegment();
  492. /*virtual*/ bool getDimensions(S32 first_char, S32 num_chars, S32& width, S32& height) const;
  493. /*virtual*/ S32 getNumChars(S32 num_pixels, S32 segment_offset, S32 line_offset, S32 max_chars) const;
  494. /*virtual*/ void updateLayout(const class LLTextBase& editor);
  495. /*virtual*/ F32 draw(S32 start, S32 end, S32 selection_start, S32 selection_end, const LLRect& draw_rect);
  496. /*virtual*/ bool canEdit() const { return false; }
  497. /*virtual*/ void unlinkFromDocument(class LLTextBase* editor);
  498. /*virtual*/ void linkToDocument(class LLTextBase* editor);
  500. private:
  501. S32 mLeftPad;
  502. S32 mRightPad;
  503. S32 mTopPad;
  504. S32 mBottomPad;
  505. LLView* mView;
  506. bool mForceNewLine;
  507. };
  510. #endif