From c3da5bb12d1c7c173929433589a4068555791bea Mon Sep 17 00:00:00 2001
From: Nat Goodspeed <nat@lindenlab.com>
Date: Wed, 15 May 2024 09:11:29 -0400
Subject: Manual whitespace fixes (fix_whitespace.py).
---
indra/llui/llmenugl.h | 1248 ++++++------
indra/llui/lltexteditor.cpp | 4634 +++++++++++++++++++++----------------------
indra/llui/lltexteditor.h | 456 ++---
3 files changed, 3169 insertions(+), 3169 deletions(-)
(limited to 'indra/llui')
diff --git a/indra/llui/llmenugl.h b/indra/llui/llmenugl.h
index fdbfb38474..e8d6043e54 100644
--- a/indra/llui/llmenugl.h
+++ b/indra/llui/llmenugl.h
@@ -1,25 +1,25 @@
-/**
+/**
* @file llmenugl.h
* @brief Declaration of the opengl based menu system.
*
* $LicenseInfo:firstyear=2001&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2010, Linden Research, Inc.
- *
+ *
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License only.
- *
+ *
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
- *
+ *
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- *
+ *
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
* $/LicenseInfo$
*/
@@ -45,183 +45,183 @@ extern S32 MENU_BAR_WIDTH;
class LLMenuKeyboardBinding
{
public:
- KEY mKey;
- MASK mMask;
+ KEY mKey;
+ MASK mMask;
};
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Class LLMenuItemGL
//
-// The LLMenuItemGL represents a single menu item in a menu.
+// The LLMenuItemGL represents a single menu item in a menu.
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
class LLMenuItemGL: public LLUICtrl, public ll::ui::SearchableControl
{
public:
- struct Params : public LLInitParam::Block<Params, LLUICtrl::Params>
- {
- Optional<std::string> shortcut;
- Optional<KEY> jump_key;
- Optional<bool> use_mac_ctrl,
- allow_key_repeat;
-
- Ignored rect,
- left,
- top,
- right,
- bottom,
- width,
- height,
- bottom_delta,
- left_delta;
-
- Optional<LLUIColor> enabled_color,
- disabled_color,
- highlight_bg_color,
- highlight_fg_color;
-
-
- Params();
- };
+ struct Params : public LLInitParam::Block<Params, LLUICtrl::Params>
+ {
+ Optional<std::string> shortcut;
+ Optional<KEY> jump_key;
+ Optional<bool> use_mac_ctrl,
+ allow_key_repeat;
+
+ Ignored rect,
+ left,
+ top,
+ right,
+ bottom,
+ width,
+ height,
+ bottom_delta,
+ left_delta;
+
+ Optional<LLUIColor> enabled_color,
+ disabled_color,
+ highlight_bg_color,
+ highlight_fg_color;
+
+
+ Params();
+ };
protected:
- LLMenuItemGL(const Params&);
- friend class LLUICtrlFactory;
+ LLMenuItemGL(const Params&);
+ friend class LLUICtrlFactory;
public:
- // LLView overrides
- /*virtual*/ void onVisibilityChange(BOOL new_visibility);
- /*virtual*/ BOOL handleHover(S32 x, S32 y, MASK mask);
- /*virtual*/ BOOL handleRightMouseDown(S32 x, S32 y, MASK mask);
- /*virtual*/ BOOL handleRightMouseUp(S32 x, S32 y, MASK mask);
-
- // LLUICtrl overrides
- /*virtual*/ void setValue(const LLSD& value);
- /*virtual*/ LLSD getValue() const;
-
- virtual bool hasAccelerator(const KEY &key, const MASK &mask) const;
- virtual BOOL handleAcceleratorKey(KEY key, MASK mask);
-
- LLColor4 getHighlightBgColor() { return mHighlightBackground.get(); }
-
- void setJumpKey(KEY key);
- KEY getJumpKey() const { return mJumpKey; }
-
- // set the font used by this item.
- void setFont(const LLFontGL* font) { mFont = font; }
- const LLFontGL* getFont() const { return mFont; }
-
- // returns the height in pixels for the current font.
- virtual U32 getNominalHeight( void ) const;
-
- // Marks item as not needing space for check marks or accelerator keys
- virtual void setBriefItem(BOOL brief);
- virtual BOOL isBriefItem() const;
-
- virtual BOOL addToAcceleratorList(std::list<LLMenuKeyboardBinding*> *listp);
- void setAllowKeyRepeat(BOOL allow) { mAllowKeyRepeat = allow; }
- BOOL getAllowKeyRepeat() const { return mAllowKeyRepeat; }
-
- // change the label
- void setLabel( const LLStringExplicit& label ) { mLabel = label; }
- std::string getLabel( void ) const { return mLabel.getString(); }
- virtual BOOL setLabelArg( const std::string& key, const LLStringExplicit& text );
-
- // Get the parent menu for this item
- virtual class LLMenuGL* getMenu() const;
-
- // returns the normal width of this control in pixels - this is
- // used for calculating the widest item, as well as for horizontal
- // arrangement.
- virtual U32 getNominalWidth( void ) const;
-
- // buildDrawLabel() - constructs the string used during the draw()
- // function. This reduces the overall string manipulation, but can
- // lead to visual errors if the state of the object changes
- // without the knowledge of the menu item. For example, if a
- // boolean being watched is changed outside of the menu item's
- // onCommit() function, the draw buffer will not be updated and will
- // reflect the wrong value. If this ever becomes an issue, there
- // are ways to fix this.
- // Returns the enabled state of the item.
- virtual void buildDrawLabel( void );
-
- // for branching menu items, bring sub menus up to root level of menu hierarchy
- virtual void updateBranchParent( LLView* parentp ){};
-
- virtual void onCommit( void );
-
- virtual void setHighlight( BOOL highlight );
- virtual BOOL getHighlight() const { return mHighlight; }
-
- // determine if this represents an active sub-menu
- virtual BOOL isActive( void ) const { return FALSE; }
-
- // determine if this represents an open sub-menu
- virtual BOOL isOpen( void ) const { return FALSE; }
-
- virtual void setEnabledSubMenus(BOOL enable){};
-
- // LLView Functionality
- virtual BOOL handleKeyHere( KEY key, MASK mask );
- virtual BOOL handleMouseDown( S32 x, S32 y, MASK mask );
- virtual BOOL handleMouseUp( S32 x, S32 y, MASK mask );
- virtual BOOL handleScrollWheel( S32 x, S32 y, S32 clicks );
-
- virtual void onMouseEnter(S32 x, S32 y, MASK mask);
- virtual void onMouseLeave(S32 x, S32 y, MASK mask);
-
- virtual void draw( void );
-
- BOOL getHover() const { return mGotHover; }
-
- void setDrawTextDisabled(BOOL disabled) { mDrawTextDisabled = disabled; }
- BOOL getDrawTextDisabled() const { return mDrawTextDisabled; }
+ // LLView overrides
+ /*virtual*/ void onVisibilityChange(BOOL new_visibility);
+ /*virtual*/ BOOL handleHover(S32 x, S32 y, MASK mask);
+ /*virtual*/ BOOL handleRightMouseDown(S32 x, S32 y, MASK mask);
+ /*virtual*/ BOOL handleRightMouseUp(S32 x, S32 y, MASK mask);
+
+ // LLUICtrl overrides
+ /*virtual*/ void setValue(const LLSD& value);
+ /*virtual*/ LLSD getValue() const;
+
+ virtual bool hasAccelerator(const KEY &key, const MASK &mask) const;
+ virtual BOOL handleAcceleratorKey(KEY key, MASK mask);
+
+ LLColor4 getHighlightBgColor() { return mHighlightBackground.get(); }
+
+ void setJumpKey(KEY key);
+ KEY getJumpKey() const { return mJumpKey; }
+
+ // set the font used by this item.
+ void setFont(const LLFontGL* font) { mFont = font; }
+ const LLFontGL* getFont() const { return mFont; }
+
+ // returns the height in pixels for the current font.
+ virtual U32 getNominalHeight( void ) const;
+
+ // Marks item as not needing space for check marks or accelerator keys
+ virtual void setBriefItem(BOOL brief);
+ virtual BOOL isBriefItem() const;
+
+ virtual BOOL addToAcceleratorList(std::list<LLMenuKeyboardBinding*> *listp);
+ void setAllowKeyRepeat(BOOL allow) { mAllowKeyRepeat = allow; }
+ BOOL getAllowKeyRepeat() const { return mAllowKeyRepeat; }
+
+ // change the label
+ void setLabel( const LLStringExplicit& label ) { mLabel = label; }
+ std::string getLabel( void ) const { return mLabel.getString(); }
+ virtual BOOL setLabelArg( const std::string& key, const LLStringExplicit& text );
+
+ // Get the parent menu for this item
+ virtual class LLMenuGL* getMenu() const;
+
+ // returns the normal width of this control in pixels - this is
+ // used for calculating the widest item, as well as for horizontal
+ // arrangement.
+ virtual U32 getNominalWidth( void ) const;
+
+ // buildDrawLabel() - constructs the string used during the draw()
+ // function. This reduces the overall string manipulation, but can
+ // lead to visual errors if the state of the object changes
+ // without the knowledge of the menu item. For example, if a
+ // boolean being watched is changed outside of the menu item's
+ // onCommit() function, the draw buffer will not be updated and will
+ // reflect the wrong value. If this ever becomes an issue, there
+ // are ways to fix this.
+ // Returns the enabled state of the item.
+ virtual void buildDrawLabel( void );
+
+ // for branching menu items, bring sub menus up to root level of menu hierarchy
+ virtual void updateBranchParent( LLView* parentp ){};
+
+ virtual void onCommit( void );
+
+ virtual void setHighlight( BOOL highlight );
+ virtual BOOL getHighlight() const { return mHighlight; }
+
+ // determine if this represents an active sub-menu
+ virtual BOOL isActive( void ) const { return FALSE; }
+
+ // determine if this represents an open sub-menu
+ virtual BOOL isOpen( void ) const { return FALSE; }
+
+ virtual void setEnabledSubMenus(BOOL enable){};
+
+ // LLView Functionality
+ virtual BOOL handleKeyHere( KEY key, MASK mask );
+ virtual BOOL handleMouseDown( S32 x, S32 y, MASK mask );
+ virtual BOOL handleMouseUp( S32 x, S32 y, MASK mask );
+ virtual BOOL handleScrollWheel( S32 x, S32 y, S32 clicks );
+
+ virtual void onMouseEnter(S32 x, S32 y, MASK mask);
+ virtual void onMouseLeave(S32 x, S32 y, MASK mask);
+
+ virtual void draw( void );
+
+ BOOL getHover() const { return mGotHover; }
+
+ void setDrawTextDisabled(BOOL disabled) { mDrawTextDisabled = disabled; }
+ BOOL getDrawTextDisabled() const { return mDrawTextDisabled; }
protected:
- void setHover(BOOL hover) { mGotHover = hover; }
+ void setHover(BOOL hover) { mGotHover = hover; }
- // This function appends the character string representation of
- // the current accelerator key and mask to the provided string.
- void appendAcceleratorString( std::string& st ) const;
+ // This function appends the character string representation of
+ // the current accelerator key and mask to the provided string.
+ void appendAcceleratorString( std::string& st ) const;
- virtual std::string _getSearchText() const
- {
- return mLabel.getString();
- }
+ virtual std::string _getSearchText() const
+ {
+ return mLabel.getString();
+ }
protected:
- KEY mAcceleratorKey;
- MASK mAcceleratorMask;
- // mLabel contains the actual label specified by the user.
- LLUIString mLabel;
-
- // The draw labels contain some of the labels that we draw during
- // the draw() routine. This optimizes away some of the string
- // manipulation.
- LLUIString mDrawBoolLabel;
- LLUIString mDrawAccelLabel;
- LLUIString mDrawBranchLabel;
-
- LLUIColor mEnabledColor;
- LLUIColor mDisabledColor;
- LLUIColor mHighlightBackground;
- LLUIColor mHighlightForeground;
-
- BOOL mHighlight;
+ KEY mAcceleratorKey;
+ MASK mAcceleratorMask;
+ // mLabel contains the actual label specified by the user.
+ LLUIString mLabel;
+
+ // The draw labels contain some of the labels that we draw during
+ // the draw() routine. This optimizes away some of the string
+ // manipulation.
+ LLUIString mDrawBoolLabel;
+ LLUIString mDrawAccelLabel;
+ LLUIString mDrawBranchLabel;
+
+ LLUIColor mEnabledColor;
+ LLUIColor mDisabledColor;
+ LLUIColor mHighlightBackground;
+ LLUIColor mHighlightForeground;
+
+ BOOL mHighlight;
private:
- // Keyboard and mouse variables
- BOOL mAllowKeyRepeat;
- BOOL mGotHover;
+ // Keyboard and mouse variables
+ BOOL mAllowKeyRepeat;
+ BOOL mGotHover;
- // If true, suppress normal space for check marks on the left and accelerator
- // keys on the right.
- BOOL mBriefItem;
+ // If true, suppress normal space for check marks on the left and accelerator
+ // keys on the right.
+ BOOL mBriefItem;
- // Font for this item
- const LLFontGL* mFont;
- BOOL mDrawTextDisabled;
+ // Font for this item
+ const LLFontGL* mFont;
+ BOOL mDrawTextDisabled;
- KEY mJumpKey;
+ KEY mJumpKey;
};
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -232,22 +232,22 @@ private:
class LLMenuItemSeparatorGL : public LLMenuItemGL
{
public:
- struct Params : public LLInitParam::Block<Params, LLMenuItemGL::Params>
- {
+ struct Params : public LLInitParam::Block<Params, LLMenuItemGL::Params>
+ {
Optional<EnableCallbackParam > on_visible;
Params();
- };
+ };
LLMenuItemSeparatorGL(const LLMenuItemSeparatorGL::Params& p = LLMenuItemSeparatorGL::Params());
- /*virtual*/ void draw( void );
- /*virtual*/ BOOL handleMouseDown(S32 x, S32 y, MASK mask);
- /*virtual*/ BOOL handleMouseUp(S32 x, S32 y, MASK mask);
- /*virtual*/ BOOL handleHover(S32 x, S32 y, MASK mask);
+ /*virtual*/ void draw( void );
+ /*virtual*/ BOOL handleMouseDown(S32 x, S32 y, MASK mask);
+ /*virtual*/ BOOL handleMouseUp(S32 x, S32 y, MASK mask);
+ /*virtual*/ BOOL handleHover(S32 x, S32 y, MASK mask);
virtual void buildDrawLabel();
- /*virtual*/ U32 getNominalHeight( void ) const;
+ /*virtual*/ U32 getNominalHeight( void ) const;
private:
enable_signal_t mVisibleSignal;
@@ -263,49 +263,49 @@ private:
class LLMenuItemCallGL : public LLMenuItemGL
{
public:
- struct Params : public LLInitParam::Block<Params, LLMenuItemGL::Params>
- {
- Optional<EnableCallbackParam > on_enable;
- Optional<CommitCallbackParam > on_click;
- Optional<EnableCallbackParam > on_visible;
- Params()
- : on_enable("on_enable"),
- on_click("on_click"),
- on_visible("on_visible")
- {}
- };
+ struct Params : public LLInitParam::Block<Params, LLMenuItemGL::Params>
+ {
+ Optional<EnableCallbackParam > on_enable;
+ Optional<CommitCallbackParam > on_click;
+ Optional<EnableCallbackParam > on_visible;
+ Params()
+ : on_enable("on_enable"),
+ on_click("on_click"),
+ on_visible("on_visible")
+ {}
+ };
protected:
- LLMenuItemCallGL(const Params&);
- friend class LLUICtrlFactory;
- void updateEnabled( void );
- void updateVisible( void );
+ LLMenuItemCallGL(const Params&);
+ friend class LLUICtrlFactory;
+ void updateEnabled( void );
+ void updateVisible( void );
public:
- void initFromParams(const Params& p);
-
- // called to rebuild the draw label
- virtual void buildDrawLabel( void );
-
- virtual void onCommit( void );
-
- virtual BOOL handleAcceleratorKey(KEY key, MASK mask);
- virtual BOOL handleKeyHere(KEY key, MASK mask);
-
- //virtual void draw();
-
- boost::signals2::connection setClickCallback( const commit_signal_t::slot_type& cb )
- {
- return setCommitCallback(cb);
- }
-
- boost::signals2::connection setEnableCallback( const enable_signal_t::slot_type& cb )
- {
- return mEnableSignal.connect(cb);
- }
-
+ void initFromParams(const Params& p);
+
+ // called to rebuild the draw label
+ virtual void buildDrawLabel( void );
+
+ virtual void onCommit( void );
+
+ virtual BOOL handleAcceleratorKey(KEY key, MASK mask);
+ virtual BOOL handleKeyHere(KEY key, MASK mask);
+
+ //virtual void draw();
+
+ boost::signals2::connection setClickCallback( const commit_signal_t::slot_type& cb )
+ {
+ return setCommitCallback(cb);
+ }
+
+ boost::signals2::connection setEnableCallback( const enable_signal_t::slot_type& cb )
+ {
+ return mEnableSignal.connect(cb);
+ }
+
private:
- enable_signal_t mEnableSignal;
- enable_signal_t mVisibleSignal;
+ enable_signal_t mEnableSignal;
+ enable_signal_t mVisibleSignal;
};
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -318,40 +318,40 @@ private:
// EFFICIENT because it may need to be checked a lot.
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-class LLMenuItemCheckGL
-: public LLMenuItemCallGL
+class LLMenuItemCheckGL
+: public LLMenuItemCallGL
{
public:
- struct Params : public LLInitParam::Block<Params, LLMenuItemCallGL::Params>
- {
- Optional<EnableCallbackParam > on_check;
- Params()
- : on_check("on_check")
- {}
- };
+ struct Params : public LLInitParam::Block<Params, LLMenuItemCallGL::Params>
+ {
+ Optional<EnableCallbackParam > on_check;
+ Params()
+ : on_check("on_check")
+ {}
+ };
protected:
- LLMenuItemCheckGL(const Params&);
- friend class LLUICtrlFactory;
+ LLMenuItemCheckGL(const Params&);
+ friend class LLUICtrlFactory;
public:
-
- void initFromParams(const Params& p);
-
- virtual void onCommit( void );
-
- virtual void setValue(const LLSD& value);
- virtual LLSD getValue() const;
-
- // called to rebuild the draw label
- virtual void buildDrawLabel( void );
-
- boost::signals2::connection setCheckCallback( const enable_signal_t::slot_type& cb )
- {
- return mCheckSignal.connect(cb);
- }
-
+
+ void initFromParams(const Params& p);
+
+ virtual void onCommit( void );
+
+ virtual void setValue(const LLSD& value);
+ virtual LLSD getValue() const;
+
+ // called to rebuild the draw label
+ virtual void buildDrawLabel( void );
+
+ boost::signals2::connection setCheckCallback( const enable_signal_t::slot_type& cb )
+ {
+ return mCheckSignal.connect(cb);
+ }
+
private:
- enable_signal_t mCheckSignal;
+ enable_signal_t mCheckSignal;
};
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -368,199 +368,199 @@ private:
// child widget registry
struct MenuRegistry : public LLChildRegistry<MenuRegistry>
{
- LLSINGLETON_EMPTY_CTOR(MenuRegistry);
+ LLSINGLETON_EMPTY_CTOR(MenuRegistry);
};
-class LLMenuGL
-: public LLUICtrl
+class LLMenuGL
+: public LLUICtrl
{
public:
- struct Params : public LLInitParam::Block<Params, LLUICtrl::Params>
- {
- Optional<KEY> jump_key;
- Optional<bool> horizontal_layout,
- can_tear_off,
- drop_shadow,
- bg_visible,
- create_jump_keys,
- keep_fixed_size,
- scrollable;
- Optional<U32> max_scrollable_items;
- Optional<U32> preferred_width;
- Optional<LLUIColor> bg_color;
- Optional<S32> shortcut_pad;
-
- Params()
- : jump_key("jump_key", KEY_NONE),
- horizontal_layout("horizontal_layout"),
- can_tear_off("tear_off", false),
- drop_shadow("drop_shadow", true),
- bg_visible("bg_visible", true),
- create_jump_keys("create_jump_keys", false),
- keep_fixed_size("keep_fixed_size", false),
- bg_color("bg_color", LLUIColorTable::instance().getColor( "MenuDefaultBgColor" )),
- scrollable("scrollable", false),
- max_scrollable_items("max_scrollable_items", U32_MAX),
- preferred_width("preferred_width", U32_MAX),
- shortcut_pad("shortcut_pad")
- {
- addSynonym(bg_visible, "opaque");
- addSynonym(bg_color, "color");
- addSynonym(can_tear_off, "can_tear_off");
- }
- };
-
- // my valid children are contained in MenuRegistry
- typedef MenuRegistry child_registry_t;
-
- void initFromParams(const Params&);
-
- // textual artwork which menugl-imitators may want to match
- static const std::string BOOLEAN_TRUE_PREFIX;
- static const std::string BRANCH_SUFFIX;
- static const std::string ARROW_UP;
- static const std::string ARROW_DOWN;
-
- // for scrollable menus
- typedef enum e_scrolling_direction
- {
- SD_UP = 0,
- SD_DOWN = 1,
- SD_BEGIN = 2,
- SD_END = 3
- } EScrollingDirection;
+ struct Params : public LLInitParam::Block<Params, LLUICtrl::Params>
+ {
+ Optional<KEY> jump_key;
+ Optional<bool> horizontal_layout,
+ can_tear_off,
+ drop_shadow,
+ bg_visible,
+ create_jump_keys,
+ keep_fixed_size,
+ scrollable;
+ Optional<U32> max_scrollable_items;
+ Optional<U32> preferred_width;
+ Optional<LLUIColor> bg_color;
+ Optional<S32> shortcut_pad;
+
+ Params()
+ : jump_key("jump_key", KEY_NONE),
+ horizontal_layout("horizontal_layout"),
+ can_tear_off("tear_off", false),
+ drop_shadow("drop_shadow", true),
+ bg_visible("bg_visible", true),
+ create_jump_keys("create_jump_keys", false),
+ keep_fixed_size("keep_fixed_size", false),
+ bg_color("bg_color", LLUIColorTable::instance().getColor( "MenuDefaultBgColor" )),
+ scrollable("scrollable", false),
+ max_scrollable_items("max_scrollable_items", U32_MAX),
+ preferred_width("preferred_width", U32_MAX),
+ shortcut_pad("shortcut_pad")
+ {
+ addSynonym(bg_visible, "opaque");
+ addSynonym(bg_color, "color");
+ addSynonym(can_tear_off, "can_tear_off");
+ }
+ };
+
+ // my valid children are contained in MenuRegistry
+ typedef MenuRegistry child_registry_t;
+
+ void initFromParams(const Params&);
+
+ // textual artwork which menugl-imitators may want to match
+ static const std::string BOOLEAN_TRUE_PREFIX;
+ static const std::string BRANCH_SUFFIX;
+ static const std::string ARROW_UP;
+ static const std::string ARROW_DOWN;
+
+ // for scrollable menus
+ typedef enum e_scrolling_direction
+ {
+ SD_UP = 0,
+ SD_DOWN = 1,
+ SD_BEGIN = 2,
+ SD_END = 3
+ } EScrollingDirection;
protected:
- LLMenuGL(const LLMenuGL::Params& p);
- friend class LLUICtrlFactory;
- // let branching menu items use my protected traversal methods
- friend class LLMenuItemBranchGL;
+ LLMenuGL(const LLMenuGL::Params& p);
+ friend class LLUICtrlFactory;
+ // let branching menu items use my protected traversal methods
+ friend class LLMenuItemBranchGL;
public:
- virtual ~LLMenuGL( void );
-
- void parseChildXML(LLXMLNodePtr child, LLView* parent);
-
- // LLView Functionality
- /*virtual*/ BOOL handleUnicodeCharHere( llwchar uni_char );
- /*virtual*/ BOOL handleHover( S32 x, S32 y, MASK mask );
- /*virtual*/ BOOL handleScrollWheel( S32 x, S32 y, S32 clicks );
- /*virtual*/ void draw( void );
- /*virtual*/ void drawBackground(LLMenuItemGL* itemp, F32 alpha);
- /*virtual*/ void setVisible(BOOL visible);
- /*virtual*/ bool addChild(LLView* view, S32 tab_group = 0);
+ virtual ~LLMenuGL( void );
+
+ void parseChildXML(LLXMLNodePtr child, LLView* parent);
+
+ // LLView Functionality
+ /*virtual*/ BOOL handleUnicodeCharHere( llwchar uni_char );
+ /*virtual*/ BOOL handleHover( S32 x, S32 y, MASK mask );
+ /*virtual*/ BOOL handleScrollWheel( S32 x, S32 y, S32 clicks );
+ /*virtual*/ void draw( void );
+ /*virtual*/ void drawBackground(LLMenuItemGL* itemp, F32 alpha);
+ /*virtual*/ void setVisible(BOOL visible);
+ /*virtual*/ bool addChild(LLView* view, S32 tab_group = 0);
/*virtual*/ void deleteAllChildren();
- /*virtual*/ void removeChild( LLView* ctrl);
- /*virtual*/ BOOL postBuild();
-
- virtual bool hasAccelerator(const KEY &key, const MASK &mask) const;
- virtual BOOL handleAcceleratorKey(KEY key, MASK mask);
-
- LLMenuGL* findChildMenuByName(const std::string& name, BOOL recurse) const;
-
- BOOL clearHoverItem();
-
- // return the name label
- const std::string& getLabel( void ) const { return mLabel.getString(); }
- void setLabel(const LLStringExplicit& label) { mLabel = label; }
-
- // background colors
- void setBackgroundColor( const LLUIColor& color ) { mBackgroundColor = color; }
- const LLUIColor& getBackgroundColor() const { return mBackgroundColor; }
- void setBackgroundVisible( BOOL b ) { mBgVisible = b; }
- void setCanTearOff(BOOL tear_off);
-
- // add a separator to this menu
- virtual BOOL addSeparator();
-
- // for branching menu items, bring sub menus up to root level of menu hierarchy
- virtual void updateParent( LLView* parentp );
-
- // setItemEnabled() - pass the name and the enable flag for a
- // menu item. TRUE will make sure it's enabled, FALSE will disable
- // it.
- void setItemEnabled( const std::string& name, BOOL enable );
-
- // propagate message to submenus
- void setEnabledSubMenus(BOOL enable);
-
- void setItemVisible( const std::string& name, BOOL visible);
+ /*virtual*/ void removeChild( LLView* ctrl);
+ /*virtual*/ BOOL postBuild();
+
+ virtual bool hasAccelerator(const KEY &key, const MASK &mask) const;
+ virtual BOOL handleAcceleratorKey(KEY key, MASK mask);
+
+ LLMenuGL* findChildMenuByName(const std::string& name, BOOL recurse) const;
+
+ BOOL clearHoverItem();
+
+ // return the name label
+ const std::string& getLabel( void ) const { return mLabel.getString(); }
+ void setLabel(const LLStringExplicit& label) { mLabel = label; }
+
+ // background colors
+ void setBackgroundColor( const LLUIColor& color ) { mBackgroundColor = color; }
+ const LLUIColor& getBackgroundColor() const { return mBackgroundColor; }
+ void setBackgroundVisible( BOOL b ) { mBgVisible = b; }
+ void setCanTearOff(BOOL tear_off);
+
+ // add a separator to this menu
+ virtual BOOL addSeparator();
+
+ // for branching menu items, bring sub menus up to root level of menu hierarchy
+ virtual void updateParent( LLView* parentp );
+
+ // setItemEnabled() - pass the name and the enable flag for a
+ // menu item. TRUE will make sure it's enabled, FALSE will disable
+ // it.
+ void setItemEnabled( const std::string& name, BOOL enable );
+
+ // propagate message to submenus
+ void setEnabledSubMenus(BOOL enable);
+
+ void setItemVisible( const std::string& name, BOOL visible);
void setItemLabel(const std::string &name, const std::string &label);
-
- // sets the left,bottom corner of menu, useful for popups
- void setLeftAndBottom(S32 left, S32 bottom);
- virtual BOOL handleJumpKey(KEY key);
+ // sets the left,bottom corner of menu, useful for popups
+ void setLeftAndBottom(S32 left, S32 bottom);
- virtual BOOL jumpKeysActive();
+ virtual BOOL handleJumpKey(KEY key);
- virtual BOOL isOpen();
+ virtual BOOL jumpKeysActive();
- void needsArrange() { mNeedsArrange = TRUE; }
- // Shape this menu to fit the current state of the children, and
- // adjust the child rects to fit. This is called automatically
- // when you add items. *FIX: We may need to deal with visibility
- // arrangement.
- virtual void arrange( void );
- void arrangeAndClear( void );
+ virtual BOOL isOpen();
- // remove all items on the menu
- void empty( void );
+ void needsArrange() { mNeedsArrange = TRUE; }
+ // Shape this menu to fit the current state of the children, and
+ // adjust the child rects to fit. This is called automatically
+ // when you add items. *FIX: We may need to deal with visibility
+ // arrangement.
+ virtual void arrange( void );
+ void arrangeAndClear( void );
- // erase group of items from menu
- void erase( S32 begin, S32 end, bool arrange = true );
+ // remove all items on the menu
+ void empty( void );
- // add new item at position
- void insert( S32 begin, LLView * ctrl, bool arrange = true );
+ // erase group of items from menu
+ void erase( S32 begin, S32 end, bool arrange = true );
- void setItemLastSelected(LLMenuItemGL* item); // must be in menu
- U32 getItemCount(); // number of menu items
- LLMenuItemGL* getItem(S32 number); // 0 = first item
+ // add new item at position
+ void insert( S32 begin, LLView * ctrl, bool arrange = true );
+
+ void setItemLastSelected(LLMenuItemGL* item); // must be in menu
+ U32 getItemCount(); // number of menu items
+ LLMenuItemGL* getItem(S32 number); // 0 = first item
LLMenuItemGL* getItem(std::string name);
- LLMenuItemGL* getHighlightedItem();
+ LLMenuItemGL* getHighlightedItem();
+
+ LLMenuItemGL* highlightNextItem(LLMenuItemGL* cur_item, BOOL skip_disabled = TRUE);
+ LLMenuItemGL* highlightPrevItem(LLMenuItemGL* cur_item, BOOL skip_disabled = TRUE);
- LLMenuItemGL* highlightNextItem(LLMenuItemGL* cur_item, BOOL skip_disabled = TRUE);
- LLMenuItemGL* highlightPrevItem(LLMenuItemGL* cur_item, BOOL skip_disabled = TRUE);
+ void buildDrawLabels();
+ void createJumpKeys();
- void buildDrawLabels();
- void createJumpKeys();
+ // Show popup at a specific location, in the spawn_view's coordinate frame
+ static void showPopup(LLView* spawning_view, LLMenuGL* menu, S32 x, S32 y, S32 mouse_x = 0, S32 mouse_y = 0);
- // Show popup at a specific location, in the spawn_view's coordinate frame
- static void showPopup(LLView* spawning_view, LLMenuGL* menu, S32 x, S32 y, S32 mouse_x = 0, S32 mouse_y = 0);
+ // Whether to drop shadow menu bar
+ void setDropShadowed( const BOOL shadowed );
- // Whether to drop shadow menu bar
- void setDropShadowed( const BOOL shadowed );
+ void setParentMenuItem( LLMenuItemGL* parent_menu_item ) { mParentMenuItem = parent_menu_item->getHandle(); }
+ LLMenuItemGL* getParentMenuItem() const { return dynamic_cast<LLMenuItemGL*>(mParentMenuItem.get()); }
- void setParentMenuItem( LLMenuItemGL* parent_menu_item ) { mParentMenuItem = parent_menu_item->getHandle(); }
- LLMenuItemGL* getParentMenuItem() const { return dynamic_cast<LLMenuItemGL*>(mParentMenuItem.get()); }
+ void setTornOff(BOOL torn_off);
+ BOOL getTornOff() { return mTornOff; }
- void setTornOff(BOOL torn_off);
- BOOL getTornOff() { return mTornOff; }
+ BOOL getCanTearOff() { return mTearOffItem != NULL; }
- BOOL getCanTearOff() { return mTearOffItem != NULL; }
+ KEY getJumpKey() const { return mJumpKey; }
+ void setJumpKey(KEY key) { mJumpKey = key; }
- KEY getJumpKey() const { return mJumpKey; }
- void setJumpKey(KEY key) { mJumpKey = key; }
+ static void setKeyboardMode(BOOL mode) { sKeyboardMode = mode; }
+ static BOOL getKeyboardMode() { return sKeyboardMode; }
- static void setKeyboardMode(BOOL mode) { sKeyboardMode = mode; }
- static BOOL getKeyboardMode() { return sKeyboardMode; }
+ S32 getShortcutPad() { return mShortcutPad; }
- S32 getShortcutPad() { return mShortcutPad; }
+ bool scrollItems(EScrollingDirection direction);
+ BOOL isScrollable() const { return mScrollable; }
- bool scrollItems(EScrollingDirection direction);
- BOOL isScrollable() const { return mScrollable; }
+ static class LLMenuHolderGL* sMenuContainer;
- static class LLMenuHolderGL* sMenuContainer;
-
- void resetScrollPositionOnShow(bool reset_scroll_pos) { mResetScrollPositionOnShow = reset_scroll_pos; }
- bool isScrollPositionOnShowReset() { return mResetScrollPositionOnShow; }
+ void resetScrollPositionOnShow(bool reset_scroll_pos) { mResetScrollPositionOnShow = reset_scroll_pos; }
+ bool isScrollPositionOnShowReset() { return mResetScrollPositionOnShow; }
- void setAlwaysShowMenu(BOOL show) { mAlwaysShowMenu = show; }
- BOOL getAlwaysShowMenu() { return mAlwaysShowMenu; }
+ void setAlwaysShowMenu(BOOL show) { mAlwaysShowMenu = show; }
+ BOOL getAlwaysShowMenu() { return mAlwaysShowMenu; }
- // add a context menu branch
- BOOL appendContextSubMenu(LLMenuGL *menu);
+ // add a context menu branch
+ BOOL appendContextSubMenu(LLMenuGL *menu);
// Add the menu item to this menu.
virtual BOOL append( LLMenuItemGL* item );
@@ -571,31 +571,31 @@ public:
const LLFontGL *getFont() const { return mFont; }
protected:
- void createSpilloverBranch();
- void cleanupSpilloverBranch();
-
- // Used in LLContextMenu and in LLTogleableMenu
- // to add an item of context menu branch
- bool addContextChild(LLView* view, S32 tab_group);
-
- // TODO: create accessor methods for these?
- typedef std::list< LLMenuItemGL* > item_list_t;
- item_list_t mItems;
- LLMenuItemGL*mFirstVisibleItem;
- LLMenuItemGL *mArrowUpItem, *mArrowDownItem;
-
- typedef std::map<KEY, LLMenuItemGL*> navigation_key_map_t;
- navigation_key_map_t mJumpKeys;
- S32 mLastMouseX;
- S32 mLastMouseY;
- S32 mMouseVelX;
- S32 mMouseVelY;
- U32 mMaxScrollableItems;
- U32 mPreferredWidth;
- BOOL mHorizontalLayout;
- BOOL mScrollable;
- BOOL mKeepFixedSize;
- BOOL mNeedsArrange;
+ void createSpilloverBranch();
+ void cleanupSpilloverBranch();
+
+ // Used in LLContextMenu and in LLTogleableMenu
+ // to add an item of context menu branch
+ bool addContextChild(LLView* view, S32 tab_group);
+
+ // TODO: create accessor methods for these?
+ typedef std::list< LLMenuItemGL* > item_list_t;
+ item_list_t mItems;
+ LLMenuItemGL*mFirstVisibleItem;
+ LLMenuItemGL *mArrowUpItem, *mArrowDownItem;
+
+ typedef std::map<KEY, LLMenuItemGL*> navigation_key_map_t;
+ navigation_key_map_t mJumpKeys;
+ S32 mLastMouseX;
+ S32 mLastMouseY;
+ S32 mMouseVelX;
+ S32 mMouseVelY;
+ U32 mMaxScrollableItems;
+ U32 mPreferredWidth;
+ BOOL mHorizontalLayout;
+ BOOL mScrollable;
+ BOOL mKeepFixedSize;
+ BOOL mNeedsArrange;
// Font for top menu items only
const LLFontGL* mFont;
@@ -603,27 +603,27 @@ protected:
private:
- static LLColor4 sDefaultBackgroundColor;
- static BOOL sKeyboardMode;
-
- BOOL mAlwaysShowMenu;
-
- LLUIColor mBackgroundColor;
- BOOL mBgVisible;
- LLHandle<LLView> mParentMenuItem;
- LLUIString mLabel;
- BOOL mDropShadowed; // Whether to drop shadow
- bool mHasSelection;
- LLFrameTimer mFadeTimer;
- LLTimer mScrollItemsTimer;
- BOOL mTornOff;
- class LLMenuItemTearOffGL* mTearOffItem;
- class LLMenuItemBranchGL* mSpilloverBranch;
- LLMenuGL* mSpilloverMenu;
- KEY mJumpKey;
- BOOL mCreateJumpKeys;
- S32 mShortcutPad;
- bool mResetScrollPositionOnShow;
+ static LLColor4 sDefaultBackgroundColor;
+ static BOOL sKeyboardMode;
+
+ BOOL mAlwaysShowMenu;
+
+ LLUIColor mBackgroundColor;
+ BOOL mBgVisible;
+ LLHandle<LLView> mParentMenuItem;
+ LLUIString mLabel;
+ BOOL mDropShadowed; // Whether to drop shadow
+ bool mHasSelection;
+ LLFrameTimer mFadeTimer;
+ LLTimer mScrollItemsTimer;
+ BOOL mTornOff;
+ class LLMenuItemTearOffGL* mTearOffItem;
+ class LLMenuItemBranchGL* mSpilloverBranch;
+ LLMenuGL* mSpilloverMenu;
+ KEY mJumpKey;
+ BOOL mCreateJumpKeys;
+ S32 mShortcutPad;
+ bool mResetScrollPositionOnShow;
}; // end class LLMenuGL
@@ -638,61 +638,61 @@ private:
class LLMenuItemBranchGL : public LLMenuItemGL
{
public:
- struct Params : public LLInitParam::Block<Params, LLMenuItemGL::Params>
- {
- Optional<LLMenuGL*> branch;
- };
+ struct Params : public LLInitParam::Block<Params, LLMenuItemGL::Params>
+ {
+ Optional<LLMenuGL*> branch;
+ };
protected:
- LLMenuItemBranchGL(const Params&);
- friend class LLUICtrlFactory;
+ LLMenuItemBranchGL(const Params&);
+ friend class LLUICtrlFactory;
public:
- virtual ~LLMenuItemBranchGL();
-
- virtual BOOL handleMouseUp(S32 x, S32 y, MASK mask);
+ virtual ~LLMenuItemBranchGL();
- virtual bool hasAccelerator(const KEY &key, const MASK &mask) const;
- virtual BOOL handleAcceleratorKey(KEY key, MASK mask);
+ virtual BOOL handleMouseUp(S32 x, S32 y, MASK mask);
- // check if we've used these accelerators already
- virtual BOOL addToAcceleratorList(std::list <LLMenuKeyboardBinding*> *listp);
+ virtual bool hasAccelerator(const KEY &key, const MASK &mask) const;
+ virtual BOOL handleAcceleratorKey(KEY key, MASK mask);
- // called to rebuild the draw label
- virtual void buildDrawLabel( void );
+ // check if we've used these accelerators already
+ virtual BOOL addToAcceleratorList(std::list <LLMenuKeyboardBinding*> *listp);
- virtual void onCommit( void );
+ // called to rebuild the draw label
+ virtual void buildDrawLabel( void );
- virtual BOOL handleKey(KEY key, MASK mask, BOOL called_from_parent);
- virtual BOOL handleUnicodeChar(llwchar uni_char, BOOL called_from_parent);
+ virtual void onCommit( void );
- // set the hover status (called by it's menu) and if the object is
- // active. This is used for behavior transfer.
- virtual void setHighlight( BOOL highlight );
+ virtual BOOL handleKey(KEY key, MASK mask, BOOL called_from_parent);
+ virtual BOOL handleUnicodeChar(llwchar uni_char, BOOL called_from_parent);
- virtual BOOL handleKeyHere(KEY key, MASK mask);
+ // set the hover status (called by it's menu) and if the object is
+ // active. This is used for behavior transfer.
+ virtual void setHighlight( BOOL highlight );
- virtual BOOL isActive() const;
+ virtual BOOL handleKeyHere(KEY key, MASK mask);
- virtual BOOL isOpen() const;
+ virtual BOOL isActive() const;
- LLMenuGL* getBranch() const { return (LLMenuGL*)mBranchHandle.get(); }
+ virtual BOOL isOpen() const;
- virtual void updateBranchParent( LLView* parentp );
+ LLMenuGL* getBranch() const { return (LLMenuGL*)mBranchHandle.get(); }
- // LLView Functionality
- virtual void onVisibilityChange( BOOL curVisibilityIn );
+ virtual void updateBranchParent( LLView* parentp );
- virtual void draw();
+ // LLView Functionality
+ virtual void onVisibilityChange( BOOL curVisibilityIn );
- virtual void setEnabledSubMenus(BOOL enabled) { if (getBranch()) getBranch()->setEnabledSubMenus(enabled); }
+ virtual void draw();
- virtual void openMenu();
+ virtual void setEnabledSubMenus(BOOL enabled) { if (getBranch()) getBranch()->setEnabledSubMenus(enabled); }
- virtual LLView* getChildView(const std::string& name, BOOL recurse = TRUE) const;
- virtual LLView* findChildView(const std::string& name, BOOL recurse = TRUE) const;
+ virtual void openMenu();
+
+ virtual LLView* getChildView(const std::string& name, BOOL recurse = TRUE) const;
+ virtual LLView* findChildView(const std::string& name, BOOL recurse = TRUE) const;
private:
- LLHandle<LLView> mBranchHandle;
+ LLHandle<LLView> mBranchHandle;
}; // end class LLMenuItemBranchGL
@@ -705,44 +705,44 @@ class LLContextMenu
: public LLMenuGL
{
public:
- struct Params : public LLInitParam::Block<Params, LLMenuGL::Params>
- {
- Params()
- {
- changeDefault(visible, false);
- }
- };
+ struct Params : public LLInitParam::Block<Params, LLMenuGL::Params>
+ {
+ Params()
+ {
+ changeDefault(visible, false);
+ }
+ };
protected:
- LLContextMenu(const Params& p);
- friend class LLUICtrlFactory;
+ LLContextMenu(const Params& p);
+ friend class LLUICtrlFactory;
public:
- virtual ~LLContextMenu() {}
+ virtual ~LLContextMenu() {}
+
+ // LLView Functionality
+ // can't set visibility directly, must call show or hide
+ virtual void setVisible (BOOL visible);
- // LLView Functionality
- // can't set visibility directly, must call show or hide
- virtual void setVisible (BOOL visible);
-
- virtual void show (S32 x, S32 y, LLView* spawning_view = NULL);
- virtual void hide ();
+ virtual void show (S32 x, S32 y, LLView* spawning_view = NULL);
+ virtual void hide ();
- virtual BOOL handleHover ( S32 x, S32 y, MASK mask );
- virtual BOOL handleRightMouseDown( S32 x, S32 y, MASK mask );
- virtual BOOL handleRightMouseUp ( S32 x, S32 y, MASK mask );
+ virtual BOOL handleHover ( S32 x, S32 y, MASK mask );
+ virtual BOOL handleRightMouseDown( S32 x, S32 y, MASK mask );
+ virtual BOOL handleRightMouseUp ( S32 x, S32 y, MASK mask );
- virtual bool addChild (LLView* view, S32 tab_group = 0);
+ virtual bool addChild (LLView* view, S32 tab_group = 0);
- LLHandle<LLContextMenu> getHandle() { return getDerivedHandle<LLContextMenu>(); }
+ LLHandle<LLContextMenu> getHandle() { return getDerivedHandle<LLContextMenu>(); }
- LLView* getSpawningView() const { return mSpawningViewHandle.get(); }
- void setSpawningView(LLHandle<LLView> spawning_view) { mSpawningViewHandle = spawning_view; }
+ LLView* getSpawningView() const { return mSpawningViewHandle.get(); }
+ void setSpawningView(LLHandle<LLView> spawning_view) { mSpawningViewHandle = spawning_view; }
protected:
- BOOL mHoveredAnyItem;
- LLMenuItemGL* mHoverItem;
- LLRootHandle<LLContextMenu> mHandle;
- LLHandle<LLView> mSpawningViewHandle;
+ BOOL mHoveredAnyItem;
+ LLMenuItemGL* mHoverItem;
+ LLRootHandle<LLContextMenu> mHandle;
+ LLHandle<LLView> mSpawningViewHandle;
};
//-----------------------------------------------------------------------------
@@ -752,28 +752,28 @@ protected:
class LLContextMenuBranch : public LLMenuItemGL
{
public:
- struct Params : public LLInitParam::Block<Params, LLMenuItemGL::Params>
- {
- Mandatory<LLContextMenu*> branch;
- };
+ struct Params : public LLInitParam::Block<Params, LLMenuItemGL::Params>
+ {
+ Mandatory<LLContextMenu*> branch;
+ };
- LLContextMenuBranch(const Params&);
+ LLContextMenuBranch(const Params&);
- virtual ~LLContextMenuBranch();
+ virtual ~LLContextMenuBranch();
- // called to rebuild the draw label
- virtual void buildDrawLabel( void );
+ // called to rebuild the draw label
+ virtual void buildDrawLabel( void );
- // onCommit() - do the primary funcationality of the menu item.
- virtual void onCommit( void );
+ // onCommit() - do the primary funcationality of the menu item.
+ virtual void onCommit( void );
- LLContextMenu* getBranch() { return mBranch.get(); }
- void setHighlight( BOOL highlight );
+ LLContextMenu* getBranch() { return mBranch.get(); }
+ void setHighlight( BOOL highlight );
protected:
- void showSubMenu();
+ void showSubMenu();
- LLHandle<LLContextMenu> mBranch;
+ LLHandle<LLContextMenu> mBranch;
};
@@ -786,43 +786,43 @@ protected:
class LLMenuBarGL : public LLMenuGL
{
public:
- struct Params : public LLInitParam::Block<Params, LLMenuGL::Params>
- {};
- LLMenuBarGL( const Params& p );
- virtual ~LLMenuBarGL();
+ struct Params : public LLInitParam::Block<Params, LLMenuGL::Params>
+ {};
+ LLMenuBarGL( const Params& p );
+ virtual ~LLMenuBarGL();
- /*virtual*/ BOOL handleAcceleratorKey(KEY key, MASK mask);
- /*virtual*/ BOOL handleKeyHere(KEY key, MASK mask);
- /*virtual*/ BOOL handleJumpKey(KEY key);
- /*virtual*/ BOOL handleMouseDown(S32 x, S32 y, MASK mask);
- /*virtual*/ BOOL handleDoubleClick(S32 x, S32 y, MASK mask);
+ /*virtual*/ BOOL handleAcceleratorKey(KEY key, MASK mask);
+ /*virtual*/ BOOL handleKeyHere(KEY key, MASK mask);
+ /*virtual*/ BOOL handleJumpKey(KEY key);
+ /*virtual*/ BOOL handleMouseDown(S32 x, S32 y, MASK mask);
+ /*virtual*/ BOOL handleDoubleClick(S32 x, S32 y, MASK mask);
- /*virtual*/ void draw();
- /*virtual*/ BOOL jumpKeysActive();
+ /*virtual*/ void draw();
+ /*virtual*/ BOOL jumpKeysActive();
- // add a vertical separator to this menu
- virtual BOOL addSeparator();
+ // add a vertical separator to this menu
+ virtual BOOL addSeparator();
- // LLView Functionality
- virtual BOOL handleHover( S32 x, S32 y, MASK mask );
+ // LLView Functionality
+ virtual BOOL handleHover( S32 x, S32 y, MASK mask );
- // Returns x position of rightmost child, usually Help menu
- S32 getRightmostMenuEdge();
+ // Returns x position of rightmost child, usually Help menu
+ S32 getRightmostMenuEdge();
- void resetMenuTrigger() { mAltKeyTrigger = FALSE; }
+ void resetMenuTrigger() { mAltKeyTrigger = FALSE; }
// add a menu - this will create a drop down menu.
virtual BOOL appendMenu(LLMenuGL *menu);
private:
- // rearrange the child rects so they fit the shape of the menu
- // bar.
- virtual void arrange( void );
+ // rearrange the child rects so they fit the shape of the menu
+ // bar.
+ virtual void arrange( void );
- void checkMenuTrigger();
+ void checkMenuTrigger();
- std::list <LLMenuKeyboardBinding*> mAccelerators;
- BOOL mAltKeyTrigger;
+ std::list <LLMenuKeyboardBinding*> mAccelerators;
+ BOOL mAltKeyTrigger;
};
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -833,39 +833,39 @@ private:
class LLMenuHolderGL : public LLPanel
{
public:
- struct Params : public LLInitParam::Block<Params, LLPanel::Params>
- {};
- LLMenuHolderGL(const Params& p);
- virtual ~LLMenuHolderGL() {}
+ struct Params : public LLInitParam::Block<Params, LLPanel::Params>
+ {};
+ LLMenuHolderGL(const Params& p);
+ virtual ~LLMenuHolderGL() {}
- virtual BOOL hideMenus();
- void reshape(S32 width, S32 height, BOOL called_from_parent = TRUE);
- void setCanHide(BOOL can_hide) { mCanHide = can_hide; }
+ virtual BOOL hideMenus();
+ void reshape(S32 width, S32 height, BOOL called_from_parent = TRUE);
+ void setCanHide(BOOL can_hide) { mCanHide = can_hide; }
- // LLView functionality
- virtual void draw();
- virtual BOOL handleMouseDown( S32 x, S32 y, MASK mask );
- virtual BOOL handleRightMouseDown( S32 x, S32 y, MASK mask );
+ // LLView functionality
+ virtual void draw();
+ virtual BOOL handleMouseDown( S32 x, S32 y, MASK mask );
+ virtual BOOL handleRightMouseDown( S32 x, S32 y, MASK mask );
- // Close context menus on right mouse up not handled by menus.
- /*virtual*/ BOOL handleRightMouseUp( S32 x, S32 y, MASK mask );
+ // Close context menus on right mouse up not handled by menus.
+ /*virtual*/ BOOL handleRightMouseUp( S32 x, S32 y, MASK mask );
- virtual BOOL handleKey(KEY key, MASK mask, BOOL called_from_parent);
- virtual const LLRect getMenuRect() const { return getLocalRect(); }
- LLView*const getVisibleMenu() const;
- virtual BOOL hasVisibleMenu() const {return getVisibleMenu() != NULL;}
+ virtual BOOL handleKey(KEY key, MASK mask, BOOL called_from_parent);
+ virtual const LLRect getMenuRect() const { return getLocalRect(); }
+ LLView*const getVisibleMenu() const;
+ virtual BOOL hasVisibleMenu() const {return getVisibleMenu() != NULL;}
- static void setActivatedItem(LLMenuItemGL* item);
+ static void setActivatedItem(LLMenuItemGL* item);
- // Need to detect if mouse-up after context menu spawn has moved.
- // If not, need to keep the menu up.
- static LLCoordGL sContextMenuSpawnPos;
+ // Need to detect if mouse-up after context menu spawn has moved.
+ // If not, need to keep the menu up.
+ static LLCoordGL sContextMenuSpawnPos;
private:
- static LLHandle<LLView> sItemLastSelectedHandle;
- static LLFrameTimer sItemActivationTimer;
+ static LLHandle<LLView> sItemLastSelectedHandle;
+ static LLFrameTimer sItemActivationTimer;
- BOOL mCanHide;
+ BOOL mCanHide;
};
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -877,26 +877,26 @@ private:
class LLTearOffMenu : public LLFloater
{
public:
- static LLTearOffMenu* create(LLMenuGL* menup);
- virtual ~LLTearOffMenu();
+ static LLTearOffMenu* create(LLMenuGL* menup);
+ virtual ~LLTearOffMenu();
- virtual void draw(void);
- virtual void onFocusReceived();
- virtual void onFocusLost();
- virtual BOOL handleUnicodeChar(llwchar uni_char, BOOL called_from_parent);
- virtual BOOL handleKeyHere(KEY key, MASK mask);
- virtual void translate(S32 x, S32 y);
+ virtual void draw(void);
+ virtual void onFocusReceived();
+ virtual void onFocusLost();
+ virtual BOOL handleUnicodeChar(llwchar uni_char, BOOL called_from_parent);
+ virtual BOOL handleKeyHere(KEY key, MASK mask);
+ virtual void translate(S32 x, S32 y);
- void updateSize();
+ void updateSize();
private:
- LLTearOffMenu(LLMenuGL* menup);
-
- void closeTearOff();
-
- LLView* mOldParent;
- LLMenuGL* mMenu;
- S32 mTargetHeight;
+ LLTearOffMenu(LLMenuGL* menup);
+
+ void closeTearOff();
+
+ LLView* mOldParent;
+ LLMenuGL* mMenu;
+ S32 mTargetHeight;
bool mQuitRequested;
};
@@ -909,16 +909,16 @@ private:
class LLMenuItemTearOffGL : public LLMenuItemGL
{
public:
- struct Params : public LLInitParam::Block<Params, LLMenuItemGL::Params>
- {};
+ struct Params : public LLInitParam::Block<Params, LLMenuItemGL::Params>
+ {};
+
+ LLMenuItemTearOffGL( const Params& );
- LLMenuItemTearOffGL( const Params& );
-
- virtual void onCommit(void);
- virtual void draw(void);
- virtual U32 getNominalHeight() const;
+ virtual void onCommit(void);
+ virtual void draw(void);
+ virtual U32 getNominalHeight() const;
- LLFloater* getParentFloater();
+ LLFloater* getParentFloater();
};
@@ -926,13 +926,13 @@ public:
class LLEditMenuHandlerMgr
{
public:
- LLEditMenuHandlerMgr& getInstance() {
- static LLEditMenuHandlerMgr instance;
- return instance;
- }
- virtual ~LLEditMenuHandlerMgr() {}
+ LLEditMenuHandlerMgr& getInstance() {
+ static LLEditMenuHandlerMgr instance;
+ return instance;
+ }
+ virtual ~LLEditMenuHandlerMgr() {}
private:
- LLEditMenuHandlerMgr() {};
+ LLEditMenuHandlerMgr() {};
};
@@ -941,40 +941,40 @@ private:
class view_listener_t : public boost::signals2::trackable
{
public:
- virtual bool handleEvent(const LLSD& userdata) = 0;
- view_listener_t() { sListeners.insert(this); }
- virtual ~view_listener_t() { sListeners.erase(this); }
-
- static void addEnable(view_listener_t* listener, const std::string& name)
- {
- LLUICtrl::EnableCallbackRegistry::currentRegistrar().add(name, boost::bind(&view_listener_t::handleEvent, listener, _2));
- }
-
- static void addCommit(view_listener_t* listener, const std::string& name)
- {
- LLUICtrl::CommitCallbackRegistry::currentRegistrar().add(name, boost::bind(&view_listener_t::handleEvent, listener, _2));
- }
-
- static void addMenu(view_listener_t* listener, const std::string& name)
- {
- // For now, add to both click and enable registries
- addEnable(listener, name);
- addCommit(listener, name);
- }
-
- static void cleanup()
- {
- listener_vector_t listeners(sListeners.begin(), sListeners.end());
- sListeners.clear();
-
- std::for_each(listeners.begin(), listeners.end(), DeletePointer());
- listeners.clear();
- }
+ virtual bool handleEvent(const LLSD& userdata) = 0;
+ view_listener_t() { sListeners.insert(this); }
+ virtual ~view_listener_t() { sListeners.erase(this); }
+
+ static void addEnable(view_listener_t* listener, const std::string& name)
+ {
+ LLUICtrl::EnableCallbackRegistry::currentRegistrar().add(name, boost::bind(&view_listener_t::handleEvent, listener, _2));
+ }
+
+ static void addCommit(view_listener_t* listener, const std::string& name)
+ {
+ LLUICtrl::CommitCallbackRegistry::currentRegistrar().add(name, boost::bind(&view_listener_t::handleEvent, listener, _2));
+ }
+
+ static void addMenu(view_listener_t* listener, const std::string& name)
+ {
+ // For now, add to both click and enable registries
+ addEnable(listener, name);
+ addCommit(listener, name);
+ }
+
+ static void cleanup()
+ {
+ listener_vector_t listeners(sListeners.begin(), sListeners.end());
+ sListeners.clear();
+
+ std::for_each(listeners.begin(), listeners.end(), DeletePointer());
+ listeners.clear();
+ }
private:
- typedef std::set<view_listener_t*> listener_map_t;
- typedef std::vector<view_listener_t*> listener_vector_t;
- static listener_map_t sListeners;
+ typedef std::set<view_listener_t*> listener_map_t;
+ typedef std::vector<view_listener_t*> listener_vector_t;
+ static listener_map_t sListeners;
};
#endif // LL_LLMENUGL_H
diff --git a/indra/llui/lltexteditor.cpp b/indra/llui/lltexteditor.cpp
index d6fc7d5377..348a4603de 100644
--- a/indra/llui/lltexteditor.cpp
+++ b/indra/llui/lltexteditor.cpp
@@ -1,24 +1,24 @@
-/**
+/**
* @file lltexteditor.cpp
*
* $LicenseInfo:firstyear=2001&license=viewerlgpl$
* Second Life Viewer Source Code
* Copyright (C) 2010, Linden Research, Inc.
- *
+ *
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License only.
- *
+ *
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
- *
+ *
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- *
+ *
* Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
* $/LicenseInfo$
*/
@@ -32,7 +32,7 @@
#include "llfontfreetype.h" // for LLFontFreetype::FIRST_CHAR
#include "llfontgl.h"
-#include "llgl.h" // LLGLSUIDefault()
+#include "llgl.h" // LLGLSUIDefault()
#include "lllocalcliprect.h"
#include "llrender.h"
#include "llui.h"
@@ -64,105 +64,105 @@
#include <queue>
#include "llcombobox.h"
-//
+//
// Globals
//
static LLDefaultChildRegistry::Register<LLTextEditor> r("simple_text_editor");
// Compiler optimization, generate extern template
template class LLTextEditor* LLView::getChild<class LLTextEditor>(
- const std::string& name, BOOL recurse) const;
+ const std::string& name, BOOL recurse) const;
//
// Constants
//
-const S32 SPACES_PER_TAB = 4;
-const F32 SPELLCHECK_DELAY = 0.5f; // delay between the last keypress and spell checking the word the cursor is on
+const S32 SPACES_PER_TAB = 4;
+const F32 SPELLCHECK_DELAY = 0.5f; // delay between the last keypress and spell checking the word the cursor is on
///////////////////////////////////////////////////////////////////
class LLTextEditor::TextCmdInsert : public LLTextBase::TextCmd
{
public:
- TextCmdInsert(S32 pos, BOOL group_with_next, const LLWString &ws, LLTextSegmentPtr segment)
- : TextCmd(pos, group_with_next, segment), mWString(ws)
- {
- }
- virtual ~TextCmdInsert() {}
- virtual BOOL execute( LLTextBase* editor, S32* delta )
- {
- *delta = insert(editor, getPosition(), mWString );
- LLWStringUtil::truncate(mWString, *delta);
- //mWString = wstring_truncate(mWString, *delta);
- return (*delta != 0);
- }
- virtual S32 undo( LLTextBase* editor )
- {
- remove(editor, getPosition(), mWString.length() );
- return getPosition();
- }
- virtual S32 redo( LLTextBase* editor )
- {
- insert(editor, getPosition(), mWString );
- return getPosition() + mWString.length();
- }
+ TextCmdInsert(S32 pos, BOOL group_with_next, const LLWString &ws, LLTextSegmentPtr segment)
+ : TextCmd(pos, group_with_next, segment), mWString(ws)
+ {
+ }
+ virtual ~TextCmdInsert() {}
+ virtual BOOL execute( LLTextBase* editor, S32* delta )
+ {
+ *delta = insert(editor, getPosition(), mWString );
+ LLWStringUtil::truncate(mWString, *delta);
+ //mWString = wstring_truncate(mWString, *delta);
+ return (*delta != 0);
+ }
+ virtual S32 undo( LLTextBase* editor )
+ {
+ remove(editor, getPosition(), mWString.length() );
+ return getPosition();
+ }
+ virtual S32 redo( LLTextBase* editor )
+ {
+ insert(editor, getPosition(), mWString );
+ return getPosition() + mWString.length();
+ }
private:
- LLWString mWString;
+ LLWString mWString;
};
///////////////////////////////////////////////////////////////////
class LLTextEditor::TextCmdAddChar : public LLTextBase::TextCmd
{
public:
- TextCmdAddChar( S32 pos, BOOL group_with_next, llwchar wc, LLTextSegmentPtr segment)
- : TextCmd(pos, group_with_next, segment), mWString(1, wc), mBlockExtensions(FALSE)
- {
- }
- virtual void blockExtensions()
- {
- mBlockExtensions = TRUE;
- }
- virtual BOOL canExtend(S32 pos) const
- {
- // cannot extend text with custom segments
- if (!mSegments.empty()) return FALSE;
-
- return !mBlockExtensions && (pos == getPosition() + (S32)mWString.length());
- }
- virtual BOOL execute( LLTextBase* editor, S32* delta )
- {
- *delta = insert(editor, getPosition(), mWString);
- LLWStringUtil::truncate(mWString, *delta);
- //mWString = wstring_truncate(mWString, *delta);
- return (*delta != 0);
- }
- virtual BOOL extendAndExecute( LLTextBase* editor, S32 pos, llwchar wc, S32* delta )
- {
- LLWString ws;
- ws += wc;
-
- *delta = insert(editor, pos, ws);
- if( *delta > 0 )
- {
- mWString += wc;
- }
- return (*delta != 0);
- }
- virtual S32 undo( LLTextBase* editor )
- {
- remove(editor, getPosition(), mWString.length() );
- return getPosition();
- }
- virtual S32 redo( LLTextBase* editor )
- {
- insert(editor, getPosition(), mWString );
- return getPosition() + mWString.length();
- }
+ TextCmdAddChar( S32 pos, BOOL group_with_next, llwchar wc, LLTextSegmentPtr segment)
+ : TextCmd(pos, group_with_next, segment), mWString(1, wc), mBlockExtensions(FALSE)
+ {
+ }
+ virtual void blockExtensions()
+ {
+ mBlockExtensions = TRUE;
+ }
+ virtual BOOL canExtend(S32 pos) const
+ {
+ // cannot extend text with custom segments
+ if (!mSegments.empty()) return FALSE;
+
+ return !mBlockExtensions && (pos == getPosition() + (S32)mWString.length());
+ }
+ virtual BOOL execute( LLTextBase* editor, S32* delta )
+ {
+ *delta = insert(editor, getPosition(), mWString);
+ LLWStringUtil::truncate(mWString, *delta);
+ //mWString = wstring_truncate(mWString, *delta);
+ return (*delta != 0);
+ }
+ virtual BOOL extendAndExecute( LLTextBase* editor, S32 pos, llwchar wc, S32* delta )
+ {
+ LLWString ws;
+ ws += wc;
+
+ *delta = insert(editor, pos, ws);
+ if( *delta > 0 )
+ {
+ mWString += wc;
+ }
+ return (*delta != 0);
+ }
+ virtual S32 undo( LLTextBase* editor )
+ {
+ remove(editor, getPosition(), mWString.length() );
+ return getPosition();
+ }
+ virtual S32 redo( LLTextBase* editor )
+ {
+ insert(editor, getPosition(), mWString );
+ return getPosition() + mWString.length();
+ }
private:
- LLWString mWString;
- BOOL mBlockExtensions;
+ LLWString mWString;
+ BOOL mBlockExtensions;
};
@@ -171,30 +171,30 @@ private:
class LLTextEditor::TextCmdOverwriteChar : public LLTextBase::TextCmd
{
public:
- TextCmdOverwriteChar( S32 pos, BOOL group_with_next, llwchar wc)
- : TextCmd(pos, group_with_next), mChar(wc), mOldChar(0) {}
-
- virtual BOOL execute( LLTextBase* editor, S32* delta )
- {
- mOldChar = editor->getWText()[getPosition()];
- overwrite(editor, getPosition(), mChar);
- *delta = 0;
- return TRUE;
- }
- virtual S32 undo( LLTextBase* editor )
- {
- overwrite(editor, getPosition(), mOldChar);
- return getPosition();
- }
- virtual S32 redo( LLTextBase* editor )
- {
- overwrite(editor, getPosition(), mChar);
- return getPosition()+1;
- }
+ TextCmdOverwriteChar( S32 pos, BOOL group_with_next, llwchar wc)
+ : TextCmd(pos, group_with_next), mChar(wc), mOldChar(0) {}
+
+ virtual BOOL execute( LLTextBase* editor, S32* delta )
+ {
+ mOldChar = editor->getWText()[getPosition()];
+ overwrite(editor, getPosition(), mChar);
+ *delta = 0;
+ return TRUE;
+ }
+ virtual S32 undo( LLTextBase* editor )
+ {
+ overwrite(editor, getPosition(), mOldChar);
+ return getPosition();
+ }
+ virtual S32 redo( LLTextBase* editor )
+ {
+ overwrite(editor, getPosition(), mChar);
+ return getPosition()+1;
+ }
private:
- llwchar mChar;
- llwchar mOldChar;
+ llwchar mChar;
+ llwchar mOldChar;
};
///////////////////////////////////////////////////////////////////
@@ -202,114 +202,114 @@ private:
class LLTextEditor::TextCmdRemove : public LLTextBase::TextCmd
{
public:
- TextCmdRemove( S32 pos, BOOL group_with_next, S32 len, segment_vec_t& segments ) :
- TextCmd(pos, group_with_next), mLen(len)
- {
- std::swap(mSegments, segments);
- }
- virtual BOOL execute( LLTextBase* editor, S32* delta )
- {
- mWString = editor->getWText().substr(getPosition(), mLen);
- *delta = remove(editor, getPosition(), mLen );
- return (*delta != 0);
- }
- virtual S32 undo( LLTextBase* editor )
- {
- insert(editor, getPosition(), mWString);
- return getPosition() + mWString.length();
- }
- virtual S32 redo( LLTextBase* editor )
- {
- remove(editor, getPosition(), mLen );
- return getPosition();
- }
+ TextCmdRemove( S32 pos, BOOL group_with_next, S32 len, segment_vec_t& segments ) :
+ TextCmd(pos, group_with_next), mLen(len)
+ {
+ std::swap(mSegments, segments);
+ }
+ virtual BOOL execute( LLTextBase* editor, S32* delta )
+ {
+ mWString = editor->getWText().substr(getPosition(), mLen);
+ *delta = remove(editor, getPosition(), mLen );
+ return (*delta != 0);
+ }
+ virtual S32 undo( LLTextBase* editor )
+ {
+ insert(editor, getPosition(), mWString);
+ return getPosition() + mWString.length();
+ }
+ virtual S32 redo( LLTextBase* editor )
+ {
+ remove(editor, getPosition(), mLen );
+ return getPosition();
+ }
private:
- LLWString mWString;
- S32 mLen;
+ LLWString mWString;
+ S32 mLen;
};
///////////////////////////////////////////////////////////////////
LLTextEditor::Params::Params()
-: default_text("default_text"),
- prevalidate_callback("prevalidate_callback"),
- embedded_items("embedded_items", false),
- ignore_tab("ignore_tab", true),
- auto_indent("auto_indent", true),
- default_color("default_color"),
+: default_text("default_text"),
+ prevalidate_callback("prevalidate_callback"),
+ embedded_items("embedded_items", false),
+ ignore_tab("ignore_tab", true),
+ auto_indent("auto_indent", true),
+ default_color("default_color"),
commit_on_focus_lost("commit_on_focus_lost", false),
- show_context_menu("show_context_menu"),
- show_emoji_helper("show_emoji_helper"),
- enable_tooltip_paste("enable_tooltip_paste")
+ show_context_menu("show_context_menu"),
+ show_emoji_helper("show_emoji_helper"),
+ enable_tooltip_paste("enable_tooltip_paste")
{
- addSynonym(prevalidate_callback, "text_type");
+ addSynonym(prevalidate_callback, "text_type");
}
LLTextEditor::LLTextEditor(const LLTextEditor::Params& p) :
- LLTextBase(p),
- mAutoreplaceCallback(),
- mBaseDocIsPristine(TRUE),
- mPristineCmd( NULL ),
- mLastCmd( NULL ),
- mDefaultColor( p.default_color() ),
- mAutoIndent(p.auto_indent),
- mCommitOnFocusLost( p.commit_on_focus_lost),
- mAllowEmbeddedItems( p.embedded_items ),
- mMouseDownX(0),
- mMouseDownY(0),
- mTabsToNextField(p.ignore_tab),
- mPrevalidateFunc(p.prevalidate_callback()),
- mShowContextMenu(p.show_context_menu),
- mShowEmojiHelper(p.show_emoji_helper),
- mEnableTooltipPaste(p.enable_tooltip_paste),
- mPassDelete(FALSE),
- mKeepSelectionOnReturn(false)
-{
- mSourceID.generate();
-
- //FIXME: use image?
- LLViewBorder::Params params;
- params.name = "text ed border";
- params.rect = getLocalRect();
- params.bevel_style = LLViewBorder::BEVEL_IN;
- params.border_thickness = 1;
- params.visible = p.border_visible;
- mBorder = LLUICtrlFactory::create<LLViewBorder> (params);
- addChild( mBorder );
- setText(p.default_text());
-
- mParseOnTheFly = TRUE;
+ LLTextBase(p),
+ mAutoreplaceCallback(),
+ mBaseDocIsPristine(TRUE),
+ mPristineCmd( NULL ),
+ mLastCmd( NULL ),
+ mDefaultColor( p.default_color() ),
+ mAutoIndent(p.auto_indent),
+ mCommitOnFocusLost( p.commit_on_focus_lost),
+ mAllowEmbeddedItems( p.embedded_items ),
+ mMouseDownX(0),
+ mMouseDownY(0),
+ mTabsToNextField(p.ignore_tab),
+ mPrevalidateFunc(p.prevalidate_callback()),
+ mShowContextMenu(p.show_context_menu),
+ mShowEmojiHelper(p.show_emoji_helper),
+ mEnableTooltipPaste(p.enable_tooltip_paste),
+ mPassDelete(FALSE),
+ mKeepSelectionOnReturn(false)
+{
+ mSourceID.generate();
+
+ //FIXME: use image?
+ LLViewBorder::Params params;
+ params.name = "text ed border";
+ params.rect = getLocalRect();
+ params.bevel_style = LLViewBorder::BEVEL_IN;
+ params.border_thickness = 1;
+ params.visible = p.border_visible;
+ mBorder = LLUICtrlFactory::create<LLViewBorder> (params);
+ addChild( mBorder );
+ setText(p.default_text());
+
+ mParseOnTheFly = TRUE;
}
void LLTextEditor::initFromParams( const LLTextEditor::Params& p)
{
- LLTextBase::initFromParams(p);
+ LLTextBase::initFromParams(p);
- // HACK: text editors always need to be enabled so that we can scroll
- LLView::setEnabled(true);
+ // HACK: text editors always need to be enabled so that we can scroll
+ LLView::setEnabled(true);
+
+ if (p.commit_on_focus_lost.isProvided())
+ {
+ mCommitOnFocusLost = p.commit_on_focus_lost;
+ }
- if (p.commit_on_focus_lost.isProvided())
- {
- mCommitOnFocusLost = p.commit_on_focus_lost;
- }
-
- updateAllowingLanguageInput();
+ updateAllowingLanguageInput();
}
LLTextEditor::~LLTextEditor()
{
- gFocusMgr.releaseFocusIfNeeded( this ); // calls onCommit() while LLTextEditor still valid
+ gFocusMgr.releaseFocusIfNeeded( this ); // calls onCommit() while LLTextEditor still valid
- // Scrollbar is deleted by LLView
- std::for_each(mUndoStack.begin(), mUndoStack.end(), DeletePointer());
- mUndoStack.clear();
- // Mark the menu as dead or its retained in memory till shutdown.
- LLContextMenu* menu = static_cast<LLContextMenu*>(mContextMenuHandle.get());
- if(menu)
- {
- menu->die();
- mContextMenuHandle.markDead();
- }
+ // Scrollbar is deleted by LLView
+ std::for_each(mUndoStack.begin(), mUndoStack.end(), DeletePointer());
+ mUndoStack.clear();
+ // Mark the menu as dead or its retained in memory till shutdown.
+ LLContextMenu* menu = static_cast<LLContextMenu*>(mContextMenuHandle.get());
+ if(menu)
+ {
+ menu->die();
+ mContextMenuHandle.markDead();
+ }
}
////////////////////////////////////////////////////////////
@@ -318,649 +318,649 @@ LLTextEditor::~LLTextEditor()
void LLTextEditor::setText(const LLStringExplicit &utf8str, const LLStyle::Params& input_params)
{
- // validate incoming text if necessary
- if (mPrevalidateFunc)
- {
- LLWString test_text = utf8str_to_wstring(utf8str);
- if (!mPrevalidateFunc(test_text))
- {
- // not valid text, nothing to do
- return;
- }
- }
+ // validate incoming text if necessary
+ if (mPrevalidateFunc)
+ {
+ LLWString test_text = utf8str_to_wstring(utf8str);
+ if (!mPrevalidateFunc(test_text))
+ {
+ // not valid text, nothing to do
+ return;
+ }
+ }
- blockUndo();
- deselect();
-
- mParseOnTheFly = FALSE;
- LLTextBase::setText(utf8str, input_params);
- mParseOnTheFly = TRUE;
+ blockUndo();
+ deselect();
- resetDirty();
+ mParseOnTheFly = FALSE;
+ LLTextBase::setText(utf8str, input_params);
+ mParseOnTheFly = TRUE;
+
+ resetDirty();
}
void LLTextEditor::selectNext(const std::string& search_text_in, BOOL case_insensitive, BOOL wrap)
{
- if (search_text_in.empty())
- {
- return;
- }
-
- LLWString text = getWText();
- LLWString search_text = utf8str_to_wstring(search_text_in);
- if (case_insensitive)
- {
- LLWStringUtil::toLower(text);
- LLWStringUtil::toLower(search_text);
- }
-
- if (mIsSelecting)
- {
- LLWString selected_text = text.substr(mSelectionEnd, mSelectionStart - mSelectionEnd);
-
- if (selected_text == search_text)
- {
- // We already have this word selected, we are searching for the next.
- setCursorPos(mCursorPos + search_text.size());
- }
- }
-
- S32 loc = text.find(search_text,mCursorPos);
-
- // If Maybe we wrapped, search again
- if (wrap && (-1 == loc))
- {
- loc = text.find(search_text);
- }
-
- // If still -1, then search_text just isn't found.
+ if (search_text_in.empty())
+ {
+ return;
+ }
+
+ LLWString text = getWText();
+ LLWString search_text = utf8str_to_wstring(search_text_in);
+ if (case_insensitive)
+ {
+ LLWStringUtil::toLower(text);
+ LLWStringUtil::toLower(search_text);
+ }
+
+ if (mIsSelecting)
+ {
+ LLWString selected_text = text.substr(mSelectionEnd, mSelectionStart - mSelectionEnd);
+
+ if (selected_text == search_text)
+ {
+ // We already have this word selected, we are searching for the next.
+ setCursorPos(mCursorPos + search_text.size());
+ }
+ }
+
+ S32 loc = text.find(search_text,mCursorPos);
+
+ // If Maybe we wrapped, search again
+ if (wrap && (-1 == loc))
+ {
+ loc = text.find(search_text);
+ }
+
+ // If still -1, then search_text just isn't found.
if (-1 == loc)
- {
- mIsSelecting = FALSE;
- mSelectionEnd = 0;
- mSelectionStart = 0;
- return;
- }
+ {
+ mIsSelecting = FALSE;
+ mSelectionEnd = 0;
+ mSelectionStart = 0;
+ return;
+ }
+
+ setCursorPos(loc);
- setCursorPos(loc);
-
- mIsSelecting = TRUE;
- mSelectionEnd = mCursorPos;
- mSelectionStart = llmin((S32)getLength(), (S32)(mCursorPos + search_text.size()));
+ mIsSelecting = TRUE;
+ mSelectionEnd = mCursorPos;
+ mSelectionStart = llmin((S32)getLength(), (S32)(mCursorPos + search_text.size()));
}
BOOL LLTextEditor::replaceText(const std::string& search_text_in, const std::string& replace_text,
- BOOL case_insensitive, BOOL wrap)
+ BOOL case_insensitive, BOOL wrap)
{
- BOOL replaced = FALSE;
+ BOOL replaced = FALSE;
- if (search_text_in.empty())
- {
- return replaced;
- }
+ if (search_text_in.empty())
+ {
+ return replaced;
+ }
- LLWString search_text = utf8str_to_wstring(search_text_in);
- if (mIsSelecting)
- {
- LLWString text = getWText();
- LLWString selected_text = text.substr(mSelectionEnd, mSelectionStart - mSelectionEnd);
+ LLWString search_text = utf8str_to_wstring(search_text_in);
+ if (mIsSelecting)
+ {
+ LLWString text = getWText();
+ LLWString selected_text = text.substr(mSelectionEnd, mSelectionStart - mSelectionEnd);
- if (case_insensitive)
- {
- LLWStringUtil::toLower(selected_text);
- LLWStringUtil::toLower(search_text);
- }
+ if (case_insensitive)
+ {
+ LLWStringUtil::toLower(selected_text);
+ LLWStringUtil::toLower(search_text);
+ }
- if (selected_text == search_text)
- {
- insertText(replace_text);
- replaced = TRUE;
- }
- }
+ if (selected_text == search_text)
+ {
+ insertText(replace_text);
+ replaced = TRUE;
+ }
+ }
- selectNext(search_text_in, case_insensitive, wrap);
- return replaced;
+ selectNext(search_text_in, case_insensitive, wrap);
+ return replaced;
}
void LLTextEditor::replaceTextAll(const std::string& search_text, const std::string& replace_text, BOOL case_insensitive)
{
- startOfDoc();
- selectNext(search_text, case_insensitive, FALSE);
+ startOfDoc();
+ selectNext(search_text, case_insensitive, FALSE);
- BOOL replaced = TRUE;
- while ( replaced )
- {
- replaced = replaceText(search_text,replace_text, case_insensitive, FALSE);
- }
+ BOOL replaced = TRUE;
+ while ( replaced )
+ {
+ replaced = replaceText(search_text,replace_text, case_insensitive, FALSE);
+ }
}
S32 LLTextEditor::prevWordPos(S32 cursorPos) const
{
- LLWString wtext(getWText());
- while( (cursorPos > 0) && (wtext[cursorPos-1] == ' ') )
- {
- cursorPos--;
- }
- while( (cursorPos > 0) && LLWStringUtil::isPartOfWord( wtext[cursorPos-1] ) )
- {
- cursorPos--;
- }
- return cursorPos;
+ LLWString wtext(getWText());
+ while( (cursorPos > 0) && (wtext[cursorPos-1] == ' ') )
+ {
+ cursorPos--;
+ }
+ while( (cursorPos > 0) && LLWStringUtil::isPartOfWord( wtext[cursorPos-1] ) )
+ {
+ cursorPos--;
+ }
+ return cursorPos;
}
S32 LLTextEditor::nextWordPos(S32 cursorPos) const
{
- LLWString wtext(getWText());
- while( (cursorPos < getLength()) && LLWStringUtil::isPartOfWord( wtext[cursorPos] ) )
- {
- cursorPos++;
- }
- while( (cursorPos < getLength()) && (wtext[cursorPos] == ' ') )
- {
- cursorPos++;
- }
- return cursorPos;
+ LLWString wtext(getWText());
+ while( (cursorPos < getLength()) && LLWStringUtil::isPartOfWord( wtext[cursorPos] ) )
+ {
+ cursorPos++;
+ }
+ while( (cursorPos < getLength()) && (wtext[cursorPos] == ' ') )
+ {
+ cursorPos++;
+ }
+ return cursorPos;
}
-const LLTextSegmentPtr LLTextEditor::getPreviousSegment() const
+const LLTextSegmentPtr LLTextEditor::getPreviousSegment() const
{
- static LLPointer<LLIndexSegment> index_segment = new LLIndexSegment;
+ static LLPointer<LLIndexSegment> index_segment = new LLIndexSegment;
- index_segment->setStart(mCursorPos);
- index_segment->setEnd(mCursorPos);
+ index_segment->setStart(mCursorPos);
+ index_segment->setEnd(mCursorPos);
- // find segment index at character to left of cursor (or rightmost edge of selection)
- segment_set_t::const_iterator it = mSegments.lower_bound(index_segment);
+ // find segment index at character to left of cursor (or rightmost edge of selection)
+ segment_set_t::const_iterator it = mSegments.lower_bound(index_segment);
- if (it != mSegments.end())
- {
- return *it;
- }
- else
- {
- return LLTextSegmentPtr();
- }
+ if (it != mSegments.end())
+ {
+ return *it;
+ }
+ else
+ {
+ return LLTextSegmentPtr();
+ }
}
void LLTextEditor::getSelectedSegments(LLTextEditor::segment_vec_t& segments) const
{
- S32 left = hasSelection() ? llmin(mSelectionStart, mSelectionEnd) : mCursorPos;
- S32 right = hasSelection() ? llmax(mSelectionStart, mSelectionEnd) : mCursorPos;
+ S32 left = hasSelection() ? llmin(mSelectionStart, mSelectionEnd) : mCursorPos;
+ S32 right = hasSelection() ? llmax(mSelectionStart, mSelectionEnd) : mCursorPos;
- return getSegmentsInRange(segments, left, right, true);
+ return getSegmentsInRange(segments, left, right, true);
}
void LLTextEditor::getSegmentsInRange(LLTextEditor::segment_vec_t& segments_out, S32 start, S32 end, bool include_partial) const
{
- segment_set_t::const_iterator first_it = getSegIterContaining(start);
- segment_set_t::const_iterator end_it = getSegIterContaining(end - 1);
- if (end_it != mSegments.end()) ++end_it;
+ segment_set_t::const_iterator first_it = getSegIterContaining(start);
+ segment_set_t::const_iterator end_it = getSegIterContaining(end - 1);
+ if (end_it != mSegments.end()) ++end_it;
- for (segment_set_t::const_iterator it = first_it; it != end_it; ++it)
- {
- LLTextSegmentPtr segment = *it;
- if (include_partial
- || (segment->getStart() >= start
- && segment->getEnd() <= end))
- {
- segments_out.push_back(segment);
- }
- }
+ for (segment_set_t::const_iterator it = first_it; it != end_it; ++it)
+ {
+ LLTextSegmentPtr segment = *it;
+ if (include_partial
+ || (segment->getStart() >= start
+ && segment->getEnd() <= end))
+ {
+ segments_out.push_back(segment);
+ }
+ }
}
void LLTextEditor::setShowEmojiHelper(bool show)
{
- if (!mShowEmojiHelper)
- {
- LLEmojiHelper::instance().hideHelper(this);
- }
+ if (!mShowEmojiHelper)
+ {
+ LLEmojiHelper::instance().hideHelper(this);
+ }
- mShowEmojiHelper = show;
+ mShowEmojiHelper = show;
}
BOOL LLTextEditor::selectionContainsLineBreaks()
{
- if (hasSelection())
- {
- S32 left = llmin(mSelectionStart, mSelectionEnd);
- S32 right = left + llabs(mSelectionStart - mSelectionEnd);
+ if (hasSelection())
+ {
+ S32 left = llmin(mSelectionStart, mSelectionEnd);
+ S32 right = left + llabs(mSelectionStart - mSelectionEnd);
- LLWString wtext = getWText();
- for( S32 i = left; i < right; i++ )
- {
- if (wtext[i] == '\n')
- {
- return TRUE;
- }
- }
- }
- return FALSE;
+ LLWString wtext = getWText();
+ for( S32 i = left; i < right; i++ )
+ {
+ if (wtext[i] == '\n')
+ {
+ return TRUE;
+ }
+ }
+ }
+ return FALSE;
}
S32 LLTextEditor::indentLine( S32 pos, S32 spaces )
{
- // Assumes that pos is at the start of the line
- // spaces may be positive (indent) or negative (unindent).
- // Returns the actual number of characters added or removed.
-
- llassert(pos >= 0);
- llassert(pos <= getLength() );
-
- S32 delta_spaces = 0;
-
- if (spaces >= 0)
- {
- // Indent
- for(S32 i=0; i < spaces; i++)
- {
- delta_spaces += addChar(pos, ' ');
- }
- }
- else
- {
- // Unindent
- for(S32 i=0; i < -spaces; i++)
- {
- LLWString wtext = getWText();
- if (wtext[pos] == ' ')
- {
- delta_spaces += remove( pos, 1, FALSE );
- }
- }
- }
-
- return delta_spaces;
+ // Assumes that pos is at the start of the line
+ // spaces may be positive (indent) or negative (unindent).
+ // Returns the actual number of characters added or removed.
+
+ llassert(pos >= 0);
+ llassert(pos <= getLength() );
+
+ S32 delta_spaces = 0;
+
+ if (spaces >= 0)
+ {
+ // Indent
+ for(S32 i=0; i < spaces; i++)
+ {
+ delta_spaces += addChar(pos, ' ');
+ }
+ }
+ else
+ {
+ // Unindent
+ for(S32 i=0; i < -spaces; i++)
+ {
+ LLWString wtext = getWText();
+ if (wtext[pos] == ' ')
+ {
+ delta_spaces += remove( pos, 1, FALSE );
+ }
+ }
+ }
+
+ return delta_spaces;
}
void LLTextEditor::indentSelectedLines( S32 spaces )
{
- if( hasSelection() )
- {
- LLWString text = getWText();
- S32 left = llmin( mSelectionStart, mSelectionEnd );
- S32 right = left + llabs( mSelectionStart - mSelectionEnd );
- BOOL cursor_on_right = (mSelectionEnd > mSelectionStart);
- S32 cur = left;
-
- // Expand left to start of line
- while( (cur > 0) && (text[cur] != '\n') )
- {
- cur--;
- }
- left = cur;
- if( cur > 0 )
- {
- left++;
- }
-
- // Expand right to end of line
- if( text[right - 1] == '\n' )
- {
- right--;
- }
- else
- {
- while( (text[right] != '\n') && (right <= getLength() ) )
- {
- right++;
- }
- }
-
- // Disabling parsing on the fly to avoid updating text segments
- // until all indentation commands are executed.
- mParseOnTheFly = FALSE;
-
- // Find each start-of-line and indent it
- do
- {
- if( text[cur] == '\n' )
- {
- cur++;
- }
-
- S32 delta_spaces = indentLine( cur, spaces );
- if( delta_spaces > 0 )
- {
- cur += delta_spaces;
- }
- right += delta_spaces;
-
- text = getWText();
-
- // Find the next new line
- while( (cur < right) && (text[cur] != '\n') )
- {
- cur++;
- }
- }
- while( cur < right );
-
- mParseOnTheFly = TRUE;
-
- if( (right < getLength()) && (text[right] == '\n') )
- {
- right++;
- }
-
- // Set the selection and cursor
- if( cursor_on_right )
- {
- mSelectionStart = left;
- mSelectionEnd = right;
- }
- else
- {
- mSelectionStart = right;
- mSelectionEnd = left;
- }
- setCursorPos(mSelectionEnd);
- }
+ if( hasSelection() )
+ {
+ LLWString text = getWText();
+ S32 left = llmin( mSelectionStart, mSelectionEnd );
+ S32 right = left + llabs( mSelectionStart - mSelectionEnd );
+ BOOL cursor_on_right = (mSelectionEnd > mSelectionStart);
+ S32 cur = left;
+
+ // Expand left to start of line
+ while( (cur > 0) && (text[cur] != '\n') )
+ {
+ cur--;
+ }
+ left = cur;
+ if( cur > 0 )
+ {
+ left++;
+ }
+
+ // Expand right to end of line
+ if( text[right - 1] == '\n' )
+ {
+ right--;
+ }
+ else
+ {
+ while( (text[right] != '\n') && (right <= getLength() ) )
+ {
+ right++;
+ }
+ }
+
+ // Disabling parsing on the fly to avoid updating text segments
+ // until all indentation commands are executed.
+ mParseOnTheFly = FALSE;
+
+ // Find each start-of-line and indent it
+ do
+ {
+ if( text[cur] == '\n' )
+ {
+ cur++;
+ }
+
+ S32 delta_spaces = indentLine( cur, spaces );
+ if( delta_spaces > 0 )
+ {
+ cur += delta_spaces;
+ }
+ right += delta_spaces;
+
+ text = getWText();
+
+ // Find the next new line
+ while( (cur < right) && (text[cur] != '\n') )
+ {
+ cur++;
+ }
+ }
+ while( cur < right );
+
+ mParseOnTheFly = TRUE;
+
+ if( (right < getLength()) && (text[right] == '\n') )
+ {
+ right++;
+ }
+
+ // Set the selection and cursor
+ if( cursor_on_right )
+ {
+ mSelectionStart = left;
+ mSelectionEnd = right;
+ }
+ else
+ {
+ mSelectionStart = right;
+ mSelectionEnd = left;
+ }
+ setCursorPos(mSelectionEnd);
+ }
}
//virtual
BOOL LLTextEditor::canSelectAll() const
{
- return TRUE;
+ return TRUE;
}
// virtual
void LLTextEditor::selectAll()
{
- mSelectionStart = getLength();
- mSelectionEnd = 0;
- setCursorPos(mSelectionEnd);
- updatePrimary();
+ mSelectionStart = getLength();
+ mSelectionEnd = 0;
+ setCursorPos(mSelectionEnd);
+ updatePrimary();
}
void LLTextEditor::selectByCursorPosition(S32 prev_cursor_pos, S32 next_cursor_pos)
{
- setCursorPos(prev_cursor_pos);
- startSelection();
- setCursorPos(next_cursor_pos);
- endSelection();
+ setCursorPos(prev_cursor_pos);
+ startSelection();
+ setCursorPos(next_cursor_pos);
+ endSelection();
}
void LLTextEditor::insertEmoji(llwchar emoji)
{
- LL_INFOS() << "LLTextEditor::insertEmoji(" << wchar_utf8_preview(emoji) << ")" << LL_ENDL;
- auto styleParams = LLStyle::Params();
- styleParams.font = LLFontGL::getFontEmoji();
- auto segment = new LLEmojiTextSegment(new LLStyle(styleParams), mCursorPos, mCursorPos + 1, *this);
- insert(mCursorPos, LLWString(1, emoji), false, segment);
- setCursorPos(mCursorPos + 1);
+ LL_INFOS() << "LLTextEditor::insertEmoji(" << wchar_utf8_preview(emoji) << ")" << LL_ENDL;
+ auto styleParams = LLStyle::Params();
+ styleParams.font = LLFontGL::getFontEmoji();
+ auto segment = new LLEmojiTextSegment(new LLStyle(styleParams), mCursorPos, mCursorPos + 1, *this);
+ insert(mCursorPos, LLWString(1, emoji), false, segment);
+ setCursorPos(mCursorPos + 1);
}
void LLTextEditor::handleEmojiCommit(llwchar emoji)
{
- S32 shortCodePos;
- if (LLEmojiHelper::isCursorInEmojiCode(getWText(), mCursorPos, &shortCodePos))
- {
- remove(shortCodePos, mCursorPos - shortCodePos, true);
- setCursorPos(shortCodePos);
+ S32 shortCodePos;
+ if (LLEmojiHelper::isCursorInEmojiCode(getWText(), mCursorPos, &shortCodePos))
+ {
+ remove(shortCodePos, mCursorPos - shortCodePos, true);
+ setCursorPos(shortCodePos);
- insertEmoji(emoji);
- }
+ insertEmoji(emoji);
+ }
}
BOOL LLTextEditor::handleMouseDown(S32 x, S32 y, MASK mask)
{
- BOOL handled = FALSE;
-
- // set focus first, in case click callbacks want to change it
- // RN: do we really need to have a tab stop?
- if (hasTabStop())
- {
- setFocus( TRUE );
- }
-
- // Let scrollbar have first dibs
- handled = LLTextBase::handleMouseDown(x, y, mask);
-
- if( !handled )
- {
- if (!(mask & MASK_SHIFT))
- {
- deselect();
- }
-
- BOOL start_select = TRUE;
- if( start_select )
- {
- // If we're not scrolling (handled by child), then we're selecting
- if (mask & MASK_SHIFT)
- {
- S32 old_cursor_pos = mCursorPos;
- setCursorAtLocalPos( x, y, true );
-
- if (hasSelection())
- {
- mSelectionEnd = mCursorPos;
- }
- else
- {
- mSelectionStart = old_cursor_pos;
- mSelectionEnd = mCursorPos;
- }
- // assume we're starting a drag select
- mIsSelecting = TRUE;
- }
- else
- {
- setCursorAtLocalPos( x, y, true );
- startSelection();
- }
- }
-
- handled = TRUE;
- }
-
- // Delay cursor flashing
- resetCursorBlink();
-
- if (handled && !gFocusMgr.getMouseCapture())
- {
- gFocusMgr.setMouseCapture( this );
- }
- return handled;
+ BOOL handled = FALSE;
+
+ // set focus first, in case click callbacks want to change it
+ // RN: do we really need to have a tab stop?
+ if (hasTabStop())
+ {
+ setFocus( TRUE );
+ }
+
+ // Let scrollbar have first dibs
+ handled = LLTextBase::handleMouseDown(x, y, mask);
+
+ if( !handled )
+ {
+ if (!(mask & MASK_SHIFT))
+ {
+ deselect();
+ }
+
+ BOOL start_select = TRUE;
+ if( start_select )
+ {
+ // If we're not scrolling (handled by child), then we're selecting
+ if (mask & MASK_SHIFT)
+ {
+ S32 old_cursor_pos = mCursorPos;
+ setCursorAtLocalPos( x, y, true );
+
+ if (hasSelection())
+ {
+ mSelectionEnd = mCursorPos;
+ }
+ else
+ {
+ mSelectionStart = old_cursor_pos;
+ mSelectionEnd = mCursorPos;
+ }
+ // assume we're starting a drag select
+ mIsSelecting = TRUE;
+ }
+ else
+ {
+ setCursorAtLocalPos( x, y, true );
+ startSelection();
+ }
+ }
+
+ handled = TRUE;
+ }
+
+ // Delay cursor flashing
+ resetCursorBlink();
+
+ if (handled && !gFocusMgr.getMouseCapture())
+ {
+ gFocusMgr.setMouseCapture( this );
+ }
+ return handled;
}
BOOL LLTextEditor::handleRightMouseDown(S32 x, S32 y, MASK mask)
{
- if (hasTabStop())
- {
- setFocus(TRUE);
- }
+ if (hasTabStop())
+ {
+ setFocus(TRUE);
+ }
- bool show_menu = false;
+ bool show_menu = false;
- // Prefer editor menu if it has selection. See EXT-6806.
- if (hasSelection())
- {
- S32 click_pos = getDocIndexFromLocalCoord(x, y, FALSE);
- if (click_pos > mSelectionStart && click_pos < mSelectionEnd)
- {
- show_menu = true;
- }
- }
+ // Prefer editor menu if it has selection. See EXT-6806.
+ if (hasSelection())
+ {
+ S32 click_pos = getDocIndexFromLocalCoord(x, y, FALSE);
+ if (click_pos > mSelectionStart && click_pos < mSelectionEnd)
+ {
+ show_menu = true;
+ }
+ }
- // Let segments handle the click, if nothing does, show editor menu
- if (!show_menu && !LLTextBase::handleRightMouseDown(x, y, mask))
- {
- show_menu = true;
- }
+ // Let segments handle the click, if nothing does, show editor menu
+ if (!show_menu && !LLTextBase::handleRightMouseDown(x, y, mask))
+ {
+ show_menu = true;
+ }
- if (show_menu && getShowContextMenu())
- {
- showContextMenu(x, y);
- }
+ if (show_menu && getShowContextMenu())
+ {
+ showContextMenu(x, y);
+ }
- return TRUE;
+ return TRUE;
}
BOOL LLTextEditor::handleMiddleMouseDown(S32 x, S32 y, MASK mask)
{
- if (hasTabStop())
- {
- setFocus(TRUE);
- }
+ if (hasTabStop())
+ {
+ setFocus(TRUE);
+ }
- if (!LLTextBase::handleMouseDown(x, y, mask))
- {
- if( canPastePrimary() )
- {
- setCursorAtLocalPos( x, y, true );
- // does not rely on focus being set
- pastePrimary();
- }
- }
- return TRUE;
+ if (!LLTextBase::handleMouseDown(x, y, mask))
+ {
+ if( canPastePrimary() )
+ {
+ setCursorAtLocalPos( x, y, true );
+ // does not rely on focus being set
+ pastePrimary();
+ }
+ }
+ return TRUE;
}
BOOL LLTextEditor::handleHover(S32 x, S32 y, MASK mask)
{
- BOOL handled = FALSE;
-
- if(hasMouseCapture() )
- {
- if( mIsSelecting )
- {
- if(mScroller)
- {
- mScroller->autoScroll(x, y);
- }
- S32 clamped_x = llclamp(x, mVisibleTextRect.mLeft, mVisibleTextRect.mRight);
- S32 clamped_y = llclamp(y, mVisibleTextRect.mBottom, mVisibleTextRect.mTop);
- setCursorAtLocalPos( clamped_x, clamped_y, true );
- mSelectionEnd = mCursorPos;
- }
- LL_DEBUGS("UserInput") << "hover handled by " << getName() << " (active)" << LL_ENDL;
- getWindow()->setCursor(UI_CURSOR_IBEAM);
- handled = TRUE;
- }
-
- if( !handled )
- {
- // Pass to children
- handled = LLTextBase::handleHover(x, y, mask);
- }
-
- if( handled )
- {
- // Delay cursor flashing
- resetCursorBlink();
- }
-
- if( !handled )
- {
- getWindow()->setCursor(UI_CURSOR_IBEAM);
- handled = TRUE;
- }
-
- return handled;
+ BOOL handled = FALSE;
+
+ if(hasMouseCapture() )
+ {
+ if( mIsSelecting )
+ {
+ if(mScroller)
+ {
+ mScroller->autoScroll(x, y);
+ }
+ S32 clamped_x = llclamp(x, mVisibleTextRect.mLeft, mVisibleTextRect.mRight);
+ S32 clamped_y = llclamp(y, mVisibleTextRect.mBottom, mVisibleTextRect.mTop);
+ setCursorAtLocalPos( clamped_x, clamped_y, true );
+ mSelectionEnd = mCursorPos;
+ }
+ LL_DEBUGS("UserInput") << "hover handled by " << getName() << " (active)" << LL_ENDL;
+ getWindow()->setCursor(UI_CURSOR_IBEAM);
+ handled = TRUE;
+ }
+
+ if( !handled )
+ {
+ // Pass to children
+ handled = LLTextBase::handleHover(x, y, mask);
+ }
+
+ if( handled )
+ {
+ // Delay cursor flashing
+ resetCursorBlink();
+ }
+
+ if( !handled )
+ {
+ getWindow()->setCursor(UI_CURSOR_IBEAM);
+ handled = TRUE;
+ }
+
+ return handled;
}
BOOL LLTextEditor::handleMouseUp(S32 x, S32 y, MASK mask)
{
- BOOL handled = FALSE;
-
- // if I'm not currently selecting text
- if (!(mIsSelecting && hasMouseCapture()))
- {
- // let text segments handle mouse event
- handled = LLTextBase::handleMouseUp(x, y, mask);
- }
-
- if( !handled )
- {
- if( mIsSelecting )
- {
- if(mScroller)
- {
- mScroller->autoScroll(x, y);
- }
- S32 clamped_x = llclamp(x, mVisibleTextRect.mLeft, mVisibleTextRect.mRight);
- S32 clamped_y = llclamp(y, mVisibleTextRect.mBottom, mVisibleTextRect.mTop);
- setCursorAtLocalPos( clamped_x, clamped_y, true );
- endSelection();
- }
-
- // take selection to 'primary' clipboard
- updatePrimary();
-
- handled = TRUE;
- }
-
- // Delay cursor flashing
- resetCursorBlink();
-
- if( hasMouseCapture() )
- {
- gFocusMgr.setMouseCapture( NULL );
-
- handled = TRUE;
- }
-
- return handled;
+ BOOL handled = FALSE;
+
+ // if I'm not currently selecting text
+ if (!(mIsSelecting && hasMouseCapture()))
+ {
+ // let text segments handle mouse event
+ handled = LLTextBase::handleMouseUp(x, y, mask);
+ }
+
+ if( !handled )
+ {
+ if( mIsSelecting )
+ {
+ if(mScroller)
+ {
+ mScroller->autoScroll(x, y);
+ }
+ S32 clamped_x = llclamp(x, mVisibleTextRect.mLeft, mVisibleTextRect.mRight);
+ S32 clamped_y = llclamp(y, mVisibleTextRect.mBottom, mVisibleTextRect.mTop);
+ setCursorAtLocalPos( clamped_x, clamped_y, true );
+ endSelection();
+ }
+
+ // take selection to 'primary' clipboard
+ updatePrimary();
+
+ handled = TRUE;
+ }
+
+ // Delay cursor flashing
+ resetCursorBlink();
+
+ if( hasMouseCapture() )
+ {
+ gFocusMgr.setMouseCapture( NULL );
+
+ handled = TRUE;
+ }
+
+ return handled;
}
BOOL LLTextEditor::handleDoubleClick(S32 x, S32 y, MASK mask)
{
- BOOL handled = FALSE;
+ BOOL handled = FALSE;
- // let scrollbar and text segments have first dibs
- handled = LLTextBase::handleDoubleClick(x, y, mask);
+ // let scrollbar and text segments have first dibs
+ handled = LLTextBase::handleDoubleClick(x, y, mask);
- if( !handled )
- {
- setCursorAtLocalPos( x, y, false );
- deselect();
+ if( !handled )
+ {
+ setCursorAtLocalPos( x, y, false );
+ deselect();
- LLWString text = getWText();
-
- if( LLWStringUtil::isPartOfWord( text[mCursorPos] ) )
- {
- // Select word the cursor is over
- while ((mCursorPos > 0) && LLWStringUtil::isPartOfWord(text[mCursorPos-1]))
- {
- if (!setCursorPos(mCursorPos - 1)) break;
- }
- startSelection();
+ LLWString text = getWText();
- while ((mCursorPos < (S32)text.length()) && LLWStringUtil::isPartOfWord( text[mCursorPos] ) )
- {
- if (!setCursorPos(mCursorPos + 1)) break;
- }
-
- mSelectionEnd = mCursorPos;
- }
- else if ((mCursorPos < (S32)text.length()) && !iswspace( text[mCursorPos]) )
- {
- // Select the character the cursor is over
- startSelection();
- setCursorPos(mCursorPos + 1);
- mSelectionEnd = mCursorPos;
- }
+ if( LLWStringUtil::isPartOfWord( text[mCursorPos] ) )
+ {
+ // Select word the cursor is over
+ while ((mCursorPos > 0) && LLWStringUtil::isPartOfWord(text[mCursorPos-1]))
+ {
+ if (!setCursorPos(mCursorPos - 1)) break;
+ }
+ startSelection();
+
+ while ((mCursorPos < (S32)text.length()) && LLWStringUtil::isPartOfWord( text[mCursorPos] ) )
+ {
+ if (!setCursorPos(mCursorPos + 1)) break;
+ }
+
+ mSelectionEnd = mCursorPos;
+ }
+ else if ((mCursorPos < (S32)text.length()) && !iswspace( text[mCursorPos]) )
+ {
+ // Select the character the cursor is over
+ startSelection();
+ setCursorPos(mCursorPos + 1);
+ mSelectionEnd = mCursorPos;
+ }
- // We don't want handleMouseUp() to "finish" the selection (and thereby
- // set mSelectionEnd to where the mouse is), so we finish the selection here.
- mIsSelecting = FALSE;
+ // We don't want handleMouseUp() to "finish" the selection (and thereby
+ // set mSelectionEnd to where the mouse is), so we finish the selection here.
+ mIsSelecting = FALSE;
- // delay cursor flashing
- resetCursorBlink();
+ // delay cursor flashing
+ resetCursorBlink();
- // take selection to 'primary' clipboard
- updatePrimary();
+ // take selection to 'primary' clipboard
+ updatePrimary();
- handled = TRUE;
- }
+ handled = TRUE;
+ }
- return handled;
+ return handled;
}
@@ -969,228 +969,228 @@ BOOL LLTextEditor::handleDoubleClick(S32 x, S32 y, MASK mask)
S32 LLTextEditor::execute( TextCmd* cmd )
{
- if (!mReadOnly && mShowEmojiHelper)
- {
- // Any change to our contents should always hide the helper
- LLEmojiHelper::instance().hideHelper(this);
- }
-
- S32 delta = 0;
- if( cmd->execute(this, &delta) )
- {
- // Delete top of undo stack
- undo_stack_t::iterator enditer = std::find(mUndoStack.begin(), mUndoStack.end(), mLastCmd);
- std::for_each(mUndoStack.begin(), enditer, DeletePointer());
- mUndoStack.erase(mUndoStack.begin(), enditer);
- // Push the new command is now on the top (front) of the undo stack.
- mUndoStack.push_front(cmd);
- mLastCmd = cmd;
-
- bool need_to_rollback = mPrevalidateFunc
- && !mPrevalidateFunc(getViewModel()->getDisplay());
- if (need_to_rollback)
- {
- // get rid of this last command and clean up undo stack
- undo();
-
- // remove any evidence of this command from redo history
- mUndoStack.pop_front();
- delete cmd;
-
- // failure, nothing changed
- delta = 0;
- }
- }
- else
- {
- // Operation failed, so don't put it on the undo stack.
- delete cmd;
- }
-
- return delta;
+ if (!mReadOnly && mShowEmojiHelper)
+ {
+ // Any change to our contents should always hide the helper
+ LLEmojiHelper::instance().hideHelper(this);
+ }
+
+ S32 delta = 0;
+ if( cmd->execute(this, &delta) )
+ {
+ // Delete top of undo stack
+ undo_stack_t::iterator enditer = std::find(mUndoStack.begin(), mUndoStack.end(), mLastCmd);
+ std::for_each(mUndoStack.begin(), enditer, DeletePointer());
+ mUndoStack.erase(mUndoStack.begin(), enditer);
+ // Push the new command is now on the top (front) of the undo stack.
+ mUndoStack.push_front(cmd);
+ mLastCmd = cmd;
+
+ bool need_to_rollback = mPrevalidateFunc
+ && !mPrevalidateFunc(getViewModel()->getDisplay());
+ if (need_to_rollback)
+ {
+ // get rid of this last command and clean up undo stack
+ undo();
+
+ // remove any evidence of this command from redo history
+ mUndoStack.pop_front();
+ delete cmd;
+
+ // failure, nothing changed
+ delta = 0;
+ }
+ }
+ else
+ {
+ // Operation failed, so don't put it on the undo stack.
+ delete cmd;
+ }
+
+ return delta;
}
S32 LLTextEditor::insert(S32 pos, const LLWString &wstr, bool group_with_next_op, LLTextSegmentPtr segment)
{
- return execute( new TextCmdInsert( pos, group_with_next_op, wstr, segment ) );
+ return execute( new TextCmdInsert( pos, group_with_next_op, wstr, segment ) );
}
S32 LLTextEditor::remove(S32 pos, S32 length, bool group_with_next_op)
{
- S32 end_pos = getEditableIndex(pos + length, true);
- BOOL removedChar = FALSE;
+ S32 end_pos = getEditableIndex(pos + length, true);
+ BOOL removedChar = FALSE;
+
+ segment_vec_t segments_to_remove;
+ // store text segments
+ getSegmentsInRange(segments_to_remove, pos, pos + length, false);
- segment_vec_t segments_to_remove;
- // store text segments
- getSegmentsInRange(segments_to_remove, pos, pos + length, false);
-
- if (pos <= end_pos)
- {
- removedChar = execute( new TextCmdRemove( pos, group_with_next_op, end_pos - pos, segments_to_remove ) );
- }
+ if (pos <= end_pos)
+ {
+ removedChar = execute( new TextCmdRemove( pos, group_with_next_op, end_pos - pos, segments_to_remove ) );
+ }
- return removedChar;
+ return removedChar;
}
S32 LLTextEditor::overwriteChar(S32 pos, llwchar wc)
{
- if ((S32)getLength() == pos)
- {
- return addChar(pos, wc);
- }
- else
- {
- return execute(new TextCmdOverwriteChar(pos, FALSE, wc));
- }
+ if ((S32)getLength() == pos)
+ {
+ return addChar(pos, wc);
+ }
+ else
+ {
+ return execute(new TextCmdOverwriteChar(pos, FALSE, wc));
+ }
}
// Remove a single character from the text. Tries to remove
// a pseudo-tab (up to for spaces in a row)
void LLTextEditor::removeCharOrTab()
{
- if (!getEnabled())
- {
- return;
- }
-
- if (mCursorPos > 0)
- {
- S32 chars_to_remove = 1;
-
- LLWString text = getWText();
- if (text[mCursorPos - 1] == ' ')
- {
- // Try to remove a "tab"
- S32 offset = getLineOffsetFromDocIndex(mCursorPos);
- if (offset > 0)
- {
- chars_to_remove = offset % SPACES_PER_TAB;
- if (chars_to_remove == 0)
- {
- chars_to_remove = SPACES_PER_TAB;
- }
-
- for (S32 i = 0; i < chars_to_remove; i++)
- {
- if (text[mCursorPos - i - 1] != ' ')
- {
- // Fewer than a full tab's worth of spaces, so
- // just delete a single character.
- chars_to_remove = 1;
- break;
- }
- }
- }
- }
-
- for (S32 i = 0; i < chars_to_remove; i++)
- {
- setCursorPos(mCursorPos - 1);
- remove(mCursorPos, 1, false);
- }
-
- tryToShowEmojiHelper();
- }
- else
- {
- LLUI::getInstance()->reportBadKeystroke();
- }
-}
+ if (!getEnabled())
+ {
+ return;
+ }
-// Remove a single character from the text
-S32 LLTextEditor::removeChar(S32 pos)
-{
- return remove(pos, 1, false);
+ if (mCursorPos > 0)
+ {
+ S32 chars_to_remove = 1;
+
+ LLWString text = getWText();
+ if (text[mCursorPos - 1] == ' ')
+ {
+ // Try to remove a "tab"
+ S32 offset = getLineOffsetFromDocIndex(mCursorPos);
+ if (offset > 0)
+ {
+ chars_to_remove = offset % SPACES_PER_TAB;
+ if (chars_to_remove == 0)
+ {
+ chars_to_remove = SPACES_PER_TAB;
+ }
+
+ for (S32 i = 0; i < chars_to_remove; i++)
+ {
+ if (text[mCursorPos - i - 1] != ' ')
+ {
+ // Fewer than a full tab's worth of spaces, so
+ // just delete a single character.
+ chars_to_remove = 1;
+ break;
+ }
+ }
+ }
+ }
+
+ for (S32 i = 0; i < chars_to_remove; i++)
+ {
+ setCursorPos(mCursorPos - 1);
+ remove(mCursorPos, 1, false);
+ }
+
+ tryToShowEmojiHelper();
+ }
+ else
+ {
+ LLUI::getInstance()->reportBadKeystroke();
+ }
+}
+
+// Remove a single character from the text
+S32 LLTextEditor::removeChar(S32 pos)
+{
+ return remove(pos, 1, false);
}
void LLTextEditor::removeChar()
{
- if (!getEnabled())
- {
- return;
- }
+ if (!getEnabled())
+ {
+ return;
+ }
- if (mCursorPos > 0)
- {
- setCursorPos(mCursorPos - 1);
- removeChar(mCursorPos);
- tryToShowEmojiHelper();
- }
- else
- {
- LLUI::getInstance()->reportBadKeystroke();
- }
+ if (mCursorPos > 0)
+ {
+ setCursorPos(mCursorPos - 1);
+ removeChar(mCursorPos);
+ tryToShowEmojiHelper();
+ }
+ else
+ {
+ LLUI::getInstance()->reportBadKeystroke();
+ }
}
// Add a single character to the text
S32 LLTextEditor::addChar(S32 pos, llwchar wc)
{
- if ( (wstring_utf8_length( getWText() ) + wchar_utf8_length( wc )) > mMaxTextByteLength)
- {
- make_ui_sound("UISndBadKeystroke");
- return 0;
- }
-
- if (mLastCmd && mLastCmd->canExtend(pos))
- {
- S32 delta = 0;
- if (mPrevalidateFunc)
- {
- // get a copy of current text contents
- LLWString test_string(getViewModel()->getDisplay());
-
- // modify text contents as if this addChar succeeded
- llassert(pos <= (S32)test_string.size());
- test_string.insert(pos, 1, wc);
- if (!mPrevalidateFunc( test_string))
- {
- return 0;
- }
- }
- mLastCmd->extendAndExecute(this, pos, wc, &delta);
-
- return delta;
- }
- else
- {
- return execute(new TextCmdAddChar(pos, FALSE, wc, LLTextSegmentPtr()));
- }
+ if ( (wstring_utf8_length( getWText() ) + wchar_utf8_length( wc )) > mMaxTextByteLength)
+ {
+ make_ui_sound("UISndBadKeystroke");
+ return 0;
+ }
+
+ if (mLastCmd && mLastCmd->canExtend(pos))
+ {
+ S32 delta = 0;
+ if (mPrevalidateFunc)
+ {
+ // get a copy of current text contents
+ LLWString test_string(getViewModel()->getDisplay());
+
+ // modify text contents as if this addChar succeeded
+ llassert(pos <= (S32)test_string.size());
+ test_string.insert(pos, 1, wc);
+ if (!mPrevalidateFunc( test_string))
+ {
+ return 0;
+ }
+ }
+ mLastCmd->extendAndExecute(this, pos, wc, &delta);
+
+ return delta;
+ }
+ else
+ {
+ return execute(new TextCmdAddChar(pos, FALSE, wc, LLTextSegmentPtr()));
+ }
}
void LLTextEditor::addChar(llwchar wc)
{
- if( !getEnabled() )
- {
- return;
- }
- if( hasSelection() )
- {
- deleteSelection(TRUE);
- }
- else if (LL_KIM_OVERWRITE == gKeyboard->getInsertMode())
- {
- removeChar(mCursorPos);
- }
-
- setCursorPos(mCursorPos + addChar( mCursorPos, wc ));
- tryToShowEmojiHelper();
-
- if (!mReadOnly && mAutoreplaceCallback != NULL)
- {
- // autoreplace the text, if necessary
- S32 replacement_start;
- S32 replacement_length;
- LLWString replacement_string;
- S32 new_cursor_pos = mCursorPos;
- mAutoreplaceCallback(replacement_start, replacement_length, replacement_string, new_cursor_pos, getWText());
-
- if (replacement_length > 0 || !replacement_string.empty())
- {
- remove(replacement_start, replacement_length, true);
- insert(replacement_start, replacement_string, false, LLTextSegmentPtr());
- setCursorPos(new_cursor_pos);
- }
- }
+ if( !getEnabled() )
+ {
+ return;
+ }
+ if( hasSelection() )
+ {
+ deleteSelection(TRUE);
+ }
+ else if (LL_KIM_OVERWRITE == gKeyboard->getInsertMode())
+ {
+ removeChar(mCursorPos);
+ }
+
+ setCursorPos(mCursorPos + addChar( mCursorPos, wc ));
+ tryToShowEmojiHelper();
+
+ if (!mReadOnly && mAutoreplaceCallback != NULL)
+ {
+ // autoreplace the text, if necessary
+ S32 replacement_start;
+ S32 replacement_length;
+ LLWString replacement_string;
+ S32 new_cursor_pos = mCursorPos;
+ mAutoreplaceCallback(replacement_start, replacement_length, replacement_string, new_cursor_pos, getWText());
+
+ if (replacement_length > 0 || !replacement_string.empty())
+ {
+ remove(replacement_start, replacement_length, true);
+ insert(replacement_start, replacement_string, false, LLTextSegmentPtr());
+ setCursorPos(new_cursor_pos);
+ }
+ }
}
void LLTextEditor::showEmojiHelper()
@@ -1226,792 +1226,792 @@ void LLTextEditor::tryToShowEmojiHelper()
void LLTextEditor::addLineBreakChar(BOOL group_together)
{
- if( !getEnabled() )
- {
- return;
- }
- if( hasSelection() )
- {
- deleteSelection(TRUE);
- }
- else if (LL_KIM_OVERWRITE == gKeyboard->getInsertMode())
- {
- removeChar(mCursorPos);
- }
+ if( !getEnabled() )
+ {
+ return;
+ }
+ if( hasSelection() )
+ {
+ deleteSelection(TRUE);
+ }
+ else if (LL_KIM_OVERWRITE == gKeyboard->getInsertMode())
+ {
+ removeChar(mCursorPos);
+ }
+
+ LLStyleConstSP sp(new LLStyle(LLStyle::Params()));
+ LLTextSegmentPtr segment = new LLLineBreakTextSegment(sp, mCursorPos);
- LLStyleConstSP sp(new LLStyle(LLStyle::Params()));
- LLTextSegmentPtr segment = new LLLineBreakTextSegment(sp, mCursorPos);
+ S32 pos = execute(new TextCmdAddChar(mCursorPos, group_together, '\n', segment));
- S32 pos = execute(new TextCmdAddChar(mCursorPos, group_together, '\n', segment));
-
- setCursorPos(mCursorPos + pos);
+ setCursorPos(mCursorPos + pos);
}
BOOL LLTextEditor::handleSelectionKey(const KEY key, const MASK mask)
{
- BOOL handled = FALSE;
-
- if( mask & MASK_SHIFT )
- {
- handled = TRUE;
-
- switch( key )
- {
- case KEY_LEFT:
- if( 0 < mCursorPos )
- {
- startSelection();
- setCursorPos(mCursorPos - 1);
- if( mask & MASK_CONTROL )
- {
- setCursorPos(prevWordPos(mCursorPos));
- }
- mSelectionEnd = mCursorPos;
- }
- break;
-
- case KEY_RIGHT:
- if( mCursorPos < getLength() )
- {
- startSelection();
- setCursorPos(mCursorPos + 1);
- if( mask & MASK_CONTROL )
- {
- setCursorPos(nextWordPos(mCursorPos));
- }
- mSelectionEnd = mCursorPos;
- }
- break;
-
- case KEY_UP:
- startSelection();
- changeLine( -1 );
- mSelectionEnd = mCursorPos;
- break;
-
- case KEY_PAGE_UP:
- startSelection();
- changePage( -1 );
- mSelectionEnd = mCursorPos;
- break;
-
- case KEY_HOME:
- startSelection();
- if( mask & MASK_CONTROL )
- {
- setCursorPos(0);
- }
- else
- {
- startOfLine();
- }
- mSelectionEnd = mCursorPos;
- break;
-
- case KEY_DOWN:
- startSelection();
- changeLine( 1 );
- mSelectionEnd = mCursorPos;
- break;
-
- case KEY_PAGE_DOWN:
- startSelection();
- changePage( 1 );
- mSelectionEnd = mCursorPos;
- break;
-
- case KEY_END:
- startSelection();
- if( mask & MASK_CONTROL )
- {
- setCursorPos(getLength());
- }
- else
- {
- endOfLine();
- }
- mSelectionEnd = mCursorPos;
- break;
-
- default:
- handled = FALSE;
- break;
- }
- }
-
- if( handled )
- {
- // take selection to 'primary' clipboard
- updatePrimary();
- }
-
- return handled;
+ BOOL handled = FALSE;
+
+ if( mask & MASK_SHIFT )
+ {
+ handled = TRUE;
+
+ switch( key )
+ {
+ case KEY_LEFT:
+ if( 0 < mCursorPos )
+ {
+ startSelection();
+ setCursorPos(mCursorPos - 1);
+ if( mask & MASK_CONTROL )
+ {
+ setCursorPos(prevWordPos(mCursorPos));
+ }
+ mSelectionEnd = mCursorPos;
+ }
+ break;
+
+ case KEY_RIGHT:
+ if( mCursorPos < getLength() )
+ {
+ startSelection();
+ setCursorPos(mCursorPos + 1);
+ if( mask & MASK_CONTROL )
+ {
+ setCursorPos(nextWordPos(mCursorPos));
+ }
+ mSelectionEnd = mCursorPos;
+ }
+ break;
+
+ case KEY_UP:
+ startSelection();
+ changeLine( -1 );
+ mSelectionEnd = mCursorPos;
+ break;
+
+ case KEY_PAGE_UP:
+ startSelection();
+ changePage( -1 );
+ mSelectionEnd = mCursorPos;
+ break;
+
+ case KEY_HOME:
+ startSelection();
+ if( mask & MASK_CONTROL )
+ {
+ setCursorPos(0);
+ }
+ else
+ {
+ startOfLine();
+ }
+ mSelectionEnd = mCursorPos;
+ break;
+
+ case KEY_DOWN:
+ startSelection();
+ changeLine( 1 );
+ mSelectionEnd = mCursorPos;
+ break;
+
+ case KEY_PAGE_DOWN:
+ startSelection();
+ changePage( 1 );
+ mSelectionEnd = mCursorPos;
+ break;
+
+ case KEY_END:
+ startSelection();
+ if( mask & MASK_CONTROL )
+ {
+ setCursorPos(getLength());
+ }
+ else
+ {
+ endOfLine();
+ }
+ mSelectionEnd = mCursorPos;
+ break;
+
+ default:
+ handled = FALSE;
+ break;
+ }
+ }
+
+ if( handled )
+ {
+ // take selection to 'primary' clipboard
+ updatePrimary();
+ }
+
+ return handled;
}
BOOL LLTextEditor::handleNavigationKey(const KEY key, const MASK mask)
{
- BOOL handled = FALSE;
-
- // Ignore capslock key
- if( MASK_NONE == mask )
- {
- handled = TRUE;
- switch( key )
- {
- case KEY_UP:
- changeLine( -1 );
- break;
-
- case KEY_PAGE_UP:
- changePage( -1 );
- break;
-
- case KEY_HOME:
- startOfLine();
- break;
-
- case KEY_DOWN:
- changeLine( 1 );
- deselect();
- break;
-
- case KEY_PAGE_DOWN:
- changePage( 1 );
- break;
-
- case KEY_END:
- endOfLine();
- break;
-
- case KEY_LEFT:
- if( hasSelection() )
- {
- setCursorPos(llmin( mSelectionStart, mSelectionEnd ));
- }
- else
- {
- if( 0 < mCursorPos )
- {
- setCursorPos(mCursorPos - 1);
- }
- else
- {
- LLUI::getInstance()->reportBadKeystroke();
- }
- }
- break;
-
- case KEY_RIGHT:
- if( hasSelection() )
- {
- setCursorPos(llmax( mSelectionStart, mSelectionEnd ));
- }
- else
- {
- if( mCursorPos < getLength() )
- {
- setCursorPos(mCursorPos + 1);
- }
- else
- {
- LLUI::getInstance()->reportBadKeystroke();
- }
- }
- break;
-
- default:
- handled = FALSE;
- break;
- }
- }
-
- if (handled)
- {
- deselect();
- }
-
- return handled;
+ BOOL handled = FALSE;
+
+ // Ignore capslock key
+ if( MASK_NONE == mask )
+ {
+ handled = TRUE;
+ switch( key )
+ {
+ case KEY_UP:
+ changeLine( -1 );
+ break;
+
+ case KEY_PAGE_UP:
+ changePage( -1 );
+ break;
+
+ case KEY_HOME:
+ startOfLine();
+ break;
+
+ case KEY_DOWN:
+ changeLine( 1 );
+ deselect();
+ break;
+
+ case KEY_PAGE_DOWN:
+ changePage( 1 );
+ break;
+
+ case KEY_END:
+ endOfLine();
+ break;
+
+ case KEY_LEFT:
+ if( hasSelection() )
+ {
+ setCursorPos(llmin( mSelectionStart, mSelectionEnd ));
+ }
+ else
+ {
+ if( 0 < mCursorPos )
+ {
+ setCursorPos(mCursorPos - 1);
+ }
+ else
+ {
+ LLUI::getInstance()->reportBadKeystroke();
+ }
+ }
+ break;
+
+ case KEY_RIGHT:
+ if( hasSelection() )
+ {
+ setCursorPos(llmax( mSelectionStart, mSelectionEnd ));
+ }
+ else
+ {
+ if( mCursorPos < getLength() )
+ {
+ setCursorPos(mCursorPos + 1);
+ }
+ else
+ {
+ LLUI::getInstance()->reportBadKeystroke();
+ }
+ }
+ break;
+
+ default:
+ handled = FALSE;
+ break;
+ }
+ }
+
+ if (handled)
+ {
+ deselect();
+ }
+
+ return handled;
}
void LLTextEditor::deleteSelection(BOOL group_with_next_op )
{
- if( getEnabled() && hasSelection() )
- {
- S32 pos = llmin( mSelectionStart, mSelectionEnd );
- S32 length = llabs( mSelectionStart - mSelectionEnd );
-
- remove( pos, length, group_with_next_op );
+ if( getEnabled() && hasSelection() )
+ {
+ S32 pos = llmin( mSelectionStart, mSelectionEnd );
+ S32 length = llabs( mSelectionStart - mSelectionEnd );
- deselect();
- setCursorPos(pos);
- }
+ remove( pos, length, group_with_next_op );
+
+ deselect();
+ setCursorPos(pos);
+ }
}
// virtual
BOOL LLTextEditor::canCut() const
{
- return !mReadOnly && hasSelection();
+ return !mReadOnly && hasSelection();
}
// cut selection to clipboard
void LLTextEditor::cut()
{
- if( !canCut() )
- {
- return;
- }
- S32 left_pos = llmin( mSelectionStart, mSelectionEnd );
- S32 length = llabs( mSelectionStart - mSelectionEnd );
- LLClipboard::instance().copyToClipboard( getWText(), left_pos, length);
- deleteSelection( FALSE );
+ if( !canCut() )
+ {
+ return;
+ }
+ S32 left_pos = llmin( mSelectionStart, mSelectionEnd );
+ S32 length = llabs( mSelectionStart - mSelectionEnd );
+ LLClipboard::instance().copyToClipboard( getWText(), left_pos, length);
+ deleteSelection( FALSE );
- onKeyStroke();
+ onKeyStroke();
}
BOOL LLTextEditor::canCopy() const
{
- return hasSelection();
+ return hasSelection();
}
// copy selection to clipboard
void LLTextEditor::copy()
{
- if( !canCopy() )
- {
- return;
- }
- S32 left_pos = llmin( mSelectionStart, mSelectionEnd );
- S32 length = llabs( mSelectionStart - mSelectionEnd );
- LLClipboard::instance().copyToClipboard(getWText(), left_pos, length);
+ if( !canCopy() )
+ {
+ return;
+ }
+ S32 left_pos = llmin( mSelectionStart, mSelectionEnd );
+ S32 length = llabs( mSelectionStart - mSelectionEnd );
+ LLClipboard::instance().copyToClipboard(getWText(), left_pos, length);
}
BOOL LLTextEditor::canPaste() const
{
- return !mReadOnly && LLClipboard::instance().isTextAvailable();
+ return !mReadOnly && LLClipboard::instance().isTextAvailable();
}
// paste from clipboard
void LLTextEditor::paste()
{
- bool is_primary = false;
- pasteHelper(is_primary);
+ bool is_primary = false;
+ pasteHelper(is_primary);
}
// paste from primary
void LLTextEditor::pastePrimary()
{
- bool is_primary = true;
- pasteHelper(is_primary);
+ bool is_primary = true;
+ pasteHelper(is_primary);
}
// paste from primary (itsprimary==true) or clipboard (itsprimary==false)
void LLTextEditor::pasteHelper(bool is_primary)
{
- mParseOnTheFly = FALSE;
- bool can_paste_it;
- if (is_primary)
- {
- can_paste_it = canPastePrimary();
- }
- else
- {
- can_paste_it = canPaste();
- }
+ mParseOnTheFly = FALSE;
+ bool can_paste_it;
+ if (is_primary)
+ {
+ can_paste_it = canPastePrimary();
+ }
+ else
+ {
+ can_paste_it = canPaste();
+ }
- if (!can_paste_it)
- {
- return;
- }
+ if (!can_paste_it)
+ {
+ return;
+ }
- LLWString paste;
- LLClipboard::instance().pasteFromClipboard(paste, is_primary);
+ LLWString paste;
+ LLClipboard::instance().pasteFromClipboard(paste, is_primary);
- if (paste.empty())
- {
- return;
- }
+ if (paste.empty())
+ {
+ return;
+ }
- // Delete any selected characters (the paste replaces them)
- if( (!is_primary) && hasSelection() )
- {
- deleteSelection(TRUE);
- }
+ // Delete any selected characters (the paste replaces them)
+ if( (!is_primary) && hasSelection() )
+ {
+ deleteSelection(TRUE);
+ }
- // Clean up string (replace tabs and remove characters that our fonts don't support).
- LLWString clean_string(paste);
- cleanStringForPaste(clean_string);
+ // Clean up string (replace tabs and remove characters that our fonts don't support).
+ LLWString clean_string(paste);
+ cleanStringForPaste(clean_string);
- // Insert the new text into the existing text.
+ // Insert the new text into the existing text.
- //paste text with linebreaks.
- pasteTextWithLinebreaks(clean_string);
+ //paste text with linebreaks.
+ pasteTextWithLinebreaks(clean_string);
- deselect();
+ deselect();
- onKeyStroke();
- mParseOnTheFly = TRUE;
+ onKeyStroke();
+ mParseOnTheFly = TRUE;
}
// Clean up string (replace tabs and remove characters that our fonts don't support).
void LLTextEditor::cleanStringForPaste(LLWString & clean_string)
{
- std::string clean_string_utf = wstring_to_utf8str(clean_string);
- std::replace( clean_string_utf.begin(), clean_string_utf.end(), '\r', '\n');
- clean_string = utf8str_to_wstring(clean_string_utf);
-
- LLWStringUtil::replaceTabsWithSpaces(clean_string, SPACES_PER_TAB);
- if( mAllowEmbeddedItems )
- {
- const llwchar LF = 10;
- S32 len = clean_string.length();
- for( S32 i = 0; i < len; i++ )
- {
- llwchar wc = clean_string[i];
- if( (wc < LLFontFreetype::FIRST_CHAR) && (wc != LF) )
- {
- clean_string[i] = LL_UNKNOWN_CHAR;
- }
- else if (wc >= FIRST_EMBEDDED_CHAR && wc <= LAST_EMBEDDED_CHAR)
- {
- clean_string[i] = pasteEmbeddedItem(wc);
- }
- }
- }
+ std::string clean_string_utf = wstring_to_utf8str(clean_string);
+ std::replace( clean_string_utf.begin(), clean_string_utf.end(), '\r', '\n');
+ clean_string = utf8str_to_wstring(clean_string_utf);
+
+ LLWStringUtil::replaceTabsWithSpaces(clean_string, SPACES_PER_TAB);
+ if( mAllowEmbeddedItems )
+ {
+ const llwchar LF = 10;
+ S32 len = clean_string.length();
+ for( S32 i = 0; i < len; i++ )
+ {
+ llwchar wc = clean_string[i];
+ if( (wc < LLFontFreetype::FIRST_CHAR) && (wc != LF) )
+ {
+ clean_string[i] = LL_UNKNOWN_CHAR;
+ }
+ else if (wc >= FIRST_EMBEDDED_CHAR && wc <= LAST_EMBEDDED_CHAR)
+ {
+ clean_string[i] = pasteEmbeddedItem(wc);
+ }
+ }
+ }
}
template <>
void LLTextEditor::pasteTextWithLinebreaks<LLWString>(const LLWString & clean_string)
{
- std::basic_string<llwchar>::size_type start = 0;
- std::basic_string<llwchar>::size_type pos = clean_string.find('\n',start);
-
- while((pos != -1) && (pos != clean_string.length() -1))
- {
- if(pos!=start)
- {
- std::basic_string<llwchar> str = std::basic_string<llwchar>(clean_string,start,pos-start);
- setCursorPos(mCursorPos + insert(mCursorPos, str, TRUE, LLTextSegmentPtr()));
- }
- addLineBreakChar(TRUE); // Add a line break and group with the next addition.
-
- start = pos+1;
- pos = clean_string.find('\n',start);
- }
-
- if (pos != start)
- {
- std::basic_string<llwchar> str = std::basic_string<llwchar>(clean_string,start,clean_string.length()-start);
- setCursorPos(mCursorPos + insert(mCursorPos, str, FALSE, LLTextSegmentPtr()));
- }
- else
- {
- addLineBreakChar(FALSE); // Add a line break and end the grouping.
- }
+ std::basic_string<llwchar>::size_type start = 0;
+ std::basic_string<llwchar>::size_type pos = clean_string.find('\n',start);
+
+ while((pos != -1) && (pos != clean_string.length() -1))
+ {
+ if(pos!=start)
+ {
+ std::basic_string<llwchar> str = std::basic_string<llwchar>(clean_string,start,pos-start);
+ setCursorPos(mCursorPos + insert(mCursorPos, str, TRUE, LLTextSegmentPtr()));
+ }
+ addLineBreakChar(TRUE); // Add a line break and group with the next addition.
+
+ start = pos+1;
+ pos = clean_string.find('\n',start);
+ }
+
+ if (pos != start)
+ {
+ std::basic_string<llwchar> str = std::basic_string<llwchar>(clean_string,start,clean_string.length()-start);
+ setCursorPos(mCursorPos + insert(mCursorPos, str, FALSE, LLTextSegmentPtr()));
+ }
+ else
+ {
+ addLineBreakChar(FALSE); // Add a line break and end the grouping.
+ }
}
// copy selection to primary
void LLTextEditor::copyPrimary()
{
- if( !canCopy() )
- {
- return;
- }
- S32 left_pos = llmin( mSelectionStart, mSelectionEnd );
- S32 length = llabs( mSelectionStart - mSelectionEnd );
- LLClipboard::instance().copyToClipboard(getWText(), left_pos, length, true);
+ if( !canCopy() )
+ {
+ return;
+ }
+ S32 left_pos = llmin( mSelectionStart, mSelectionEnd );
+ S32 length = llabs( mSelectionStart - mSelectionEnd );
+ LLClipboard::instance().copyToClipboard(getWText(), left_pos, length, true);
}
BOOL LLTextEditor::canPastePrimary() const
{
- return !mReadOnly && LLClipboard::instance().isTextAvailable(true);
+ return !mReadOnly && LLClipboard::instance().isTextAvailable(true);
}
void LLTextEditor::updatePrimary()
{
- if (canCopy())
- {
- copyPrimary();
- }
-}
-
-BOOL LLTextEditor::handleControlKey(const KEY key, const MASK mask)
-{
- BOOL handled = FALSE;
-
- if( mask & MASK_CONTROL )
- {
- handled = TRUE;
-
- switch( key )
- {
- case KEY_HOME:
- if( mask & MASK_SHIFT )
- {
- startSelection();
- setCursorPos(0);
- mSelectionEnd = mCursorPos;
- }
- else
- {
- // Ctrl-Home, Ctrl-Left, Ctrl-Right, Ctrl-Down
- // all move the cursor as if clicking, so should deselect.
- deselect();
- startOfDoc();
- }
- break;
-
- case KEY_END:
- {
- if( mask & MASK_SHIFT )
- {
- startSelection();
- }
- else
- {
- // Ctrl-Home, Ctrl-Left, Ctrl-Right, Ctrl-Down
- // all move the cursor as if clicking, so should deselect.
- deselect();
- }
- endOfDoc();
- if( mask & MASK_SHIFT )
- {
- mSelectionEnd = mCursorPos;
- }
- break;
- }
-
- case KEY_RIGHT:
- if( mCursorPos < getLength() )
- {
- // Ctrl-Home, Ctrl-Left, Ctrl-Right, Ctrl-Down
- // all move the cursor as if clicking, so should deselect.
- deselect();
-
- setCursorPos(nextWordPos(mCursorPos + 1));
- }
- break;
-
-
- case KEY_LEFT:
- if( mCursorPos > 0 )
- {
- // Ctrl-Home, Ctrl-Left, Ctrl-Right, Ctrl-Down
- // all move the cursor as if clicking, so should deselect.
- deselect();
-
- setCursorPos(prevWordPos(mCursorPos - 1));
- }
- break;
-
- default:
- handled = FALSE;
- break;
- }
- }
-
- if (handled && !gFocusMgr.getMouseCapture())
- {
- updatePrimary();
- }
-
- return handled;
-}
-
-
-BOOL LLTextEditor::handleSpecialKey(const KEY key, const MASK mask)
- {
- BOOL handled = TRUE;
-
- if (mReadOnly) return FALSE;
-
- switch( key )
- {
- case KEY_INSERT:
- if (mask == MASK_NONE)
- {
- gKeyboard->toggleInsertMode();
- }
- break;
-
- case KEY_BACKSPACE:
- if( hasSelection() )
- {
- deleteSelection(FALSE);
- }
- else
- if( 0 < mCursorPos )
- {
- removeCharOrTab();
- }
- else
- {
- LLUI::getInstance()->reportBadKeystroke();
- }
- break;
-
-
- case KEY_RETURN:
- if (mask == MASK_NONE)
- {
- if( hasSelection() && !mKeepSelectionOnReturn )
- {
- deleteSelection(FALSE);
- }
- if (mAutoIndent)
- {
- autoIndent();
- }
- }
- else
- {
- handled = FALSE;
- break;
- }
- break;
-
- case KEY_TAB:
- if (mask & MASK_CONTROL)
- {
- handled = FALSE;
- break;
- }
- if( hasSelection() && selectionContainsLineBreaks() )
- {
- indentSelectedLines( (mask & MASK_SHIFT) ? -SPACES_PER_TAB : SPACES_PER_TAB );
- }
- else
- {
- if( hasSelection() )
- {
- deleteSelection(FALSE);
- }
-
- S32 offset = getLineOffsetFromDocIndex(mCursorPos);
-
- S32 spaces_needed = SPACES_PER_TAB - (offset % SPACES_PER_TAB);
- for( S32 i=0; i < spaces_needed; i++ )
- {
- addChar( ' ' );
- }
- }
- break;
-
- default:
- handled = FALSE;
- break;
- }
-
- if (handled)
- {
- onKeyStroke();
- }
- return handled;
+ if (canCopy())
+ {
+ copyPrimary();
+ }
}
-
-void LLTextEditor::unindentLineBeforeCloseBrace()
+BOOL LLTextEditor::handleControlKey(const KEY key, const MASK mask)
{
- if( mCursorPos >= 1 )
- {
- LLWString text = getWText();
- if( ' ' == text[ mCursorPos - 1 ] )
- {
- S32 line = getLineNumFromDocIndex(mCursorPos, false);
- S32 line_start = getLineStart(line);
+ BOOL handled = FALSE;
+
+ if( mask & MASK_CONTROL )
+ {
+ handled = TRUE;
+
+ switch( key )
+ {
+ case KEY_HOME:
+ if( mask & MASK_SHIFT )
+ {
+ startSelection();
+ setCursorPos(0);
+ mSelectionEnd = mCursorPos;
+ }
+ else
+ {
+ // Ctrl-Home, Ctrl-Left, Ctrl-Right, Ctrl-Down
+ // all move the cursor as if clicking, so should deselect.
+ deselect();
+ startOfDoc();
+ }
+ break;
+
+ case KEY_END:
+ {
+ if( mask & MASK_SHIFT )
+ {
+ startSelection();
+ }
+ else
+ {
+ // Ctrl-Home, Ctrl-Left, Ctrl-Right, Ctrl-Down
+ // all move the cursor as if clicking, so should deselect.
+ deselect();
+ }
+ endOfDoc();
+ if( mask & MASK_SHIFT )
+ {
+ mSelectionEnd = mCursorPos;
+ }
+ break;
+ }
+
+ case KEY_RIGHT:
+ if( mCursorPos < getLength() )
+ {
+ // Ctrl-Home, Ctrl-Left, Ctrl-Right, Ctrl-Down
+ // all move the cursor as if clicking, so should deselect.
+ deselect();
+
+ setCursorPos(nextWordPos(mCursorPos + 1));
+ }
+ break;
+
+
+ case KEY_LEFT:
+ if( mCursorPos > 0 )
+ {
+ // Ctrl-Home, Ctrl-Left, Ctrl-Right, Ctrl-Down
+ // all move the cursor as if clicking, so should deselect.
+ deselect();
+
+ setCursorPos(prevWordPos(mCursorPos - 1));
+ }
+ break;
+
+ default:
+ handled = FALSE;
+ break;
+ }
+ }
+
+ if (handled && !gFocusMgr.getMouseCapture())
+ {
+ updatePrimary();
+ }
+
+ return handled;
+}
+
+
+BOOL LLTextEditor::handleSpecialKey(const KEY key, const MASK mask)
+ {
+ BOOL handled = TRUE;
+
+ if (mReadOnly) return FALSE;
+
+ switch( key )
+ {
+ case KEY_INSERT:
+ if (mask == MASK_NONE)
+ {
+ gKeyboard->toggleInsertMode();
+ }
+ break;
+
+ case KEY_BACKSPACE:
+ if( hasSelection() )
+ {
+ deleteSelection(FALSE);
+ }
+ else
+ if( 0 < mCursorPos )
+ {
+ removeCharOrTab();
+ }
+ else
+ {
+ LLUI::getInstance()->reportBadKeystroke();
+ }
+ break;
+
+
+ case KEY_RETURN:
+ if (mask == MASK_NONE)
+ {
+ if( hasSelection() && !mKeepSelectionOnReturn )
+ {
+ deleteSelection(FALSE);
+ }
+ if (mAutoIndent)
+ {
+ autoIndent();
+ }
+ }
+ else
+ {
+ handled = FALSE;
+ break;
+ }
+ break;
+
+ case KEY_TAB:
+ if (mask & MASK_CONTROL)
+ {
+ handled = FALSE;
+ break;
+ }
+ if( hasSelection() && selectionContainsLineBreaks() )
+ {
+ indentSelectedLines( (mask & MASK_SHIFT) ? -SPACES_PER_TAB : SPACES_PER_TAB );
+ }
+ else
+ {
+ if( hasSelection() )
+ {
+ deleteSelection(FALSE);
+ }
+
+ S32 offset = getLineOffsetFromDocIndex(mCursorPos);
+
+ S32 spaces_needed = SPACES_PER_TAB - (offset % SPACES_PER_TAB);
+ for( S32 i=0; i < spaces_needed; i++ )
+ {
+ addChar( ' ' );
+ }
+ }
+ break;
- // Jump over spaces in the current line
- while ((' ' == text[line_start]) && (line_start < mCursorPos))
- {
- line_start++;
- }
+ default:
+ handled = FALSE;
+ break;
+ }
- // Make sure there is nothing but ' ' before the Brace we are unindenting
- if (line_start == mCursorPos)
- {
- removeCharOrTab();
- }
- }
- }
+ if (handled)
+ {
+ onKeyStroke();
+ }
+ return handled;
+}
+
+
+void LLTextEditor::unindentLineBeforeCloseBrace()
+{
+ if( mCursorPos >= 1 )
+ {
+ LLWString text = getWText();
+ if( ' ' == text[ mCursorPos - 1 ] )
+ {
+ S32 line = getLineNumFromDocIndex(mCursorPos, false);
+ S32 line_start = getLineStart(line);
+
+ // Jump over spaces in the current line
+ while ((' ' == text[line_start]) && (line_start < mCursorPos))
+ {
+ line_start++;
+ }
+
+ // Make sure there is nothing but ' ' before the Brace we are unindenting
+ if (line_start == mCursorPos)
+ {
+ removeCharOrTab();
+ }
+ }
+ }
}
BOOL LLTextEditor::handleKeyHere(KEY key, MASK mask )
{
- BOOL handled = FALSE;
-
- // Special case for TAB. If want to move to next field, report
- // not handled and let the parent take care of field movement.
- if (KEY_TAB == key && mTabsToNextField)
- {
- return FALSE;
- }
-
- if (mReadOnly && mScroller)
- {
- handled = (mScroller && mScroller->handleKeyHere( key, mask ))
- || handleSelectionKey(key, mask)
- || handleControlKey(key, mask);
- }
- else
- {
- if (!mReadOnly && mShowEmojiHelper && LLEmojiHelper::instance().handleKey(this, key, mask))
- {
- return TRUE;
- }
-
- if (mEnableTooltipPaste &&
- LLToolTipMgr::instance().toolTipVisible() &&
+ BOOL handled = FALSE;
+
+ // Special case for TAB. If want to move to next field, report
+ // not handled and let the parent take care of field movement.
+ if (KEY_TAB == key && mTabsToNextField)
+ {
+ return FALSE;
+ }
+
+ if (mReadOnly && mScroller)
+ {
+ handled = (mScroller && mScroller->handleKeyHere( key, mask ))
+ || handleSelectionKey(key, mask)
+ || handleControlKey(key, mask);
+ }
+ else
+ {
+ if (!mReadOnly && mShowEmojiHelper && LLEmojiHelper::instance().handleKey(this, key, mask))
+ {
+ return TRUE;
+ }
+
+ if (mEnableTooltipPaste &&
+ LLToolTipMgr::instance().toolTipVisible() &&
LLToolTipMgr::instance().isTooltipPastable() &&
- KEY_TAB == key)
- { // Paste the first line of a tooltip into the editor
- std::string message;
- LLToolTipMgr::instance().getToolTipMessage(message);
- LLWString tool_tip_text(utf8str_to_wstring(message));
-
- if (tool_tip_text.size() > 0)
- {
- // Delete any selected characters (the tooltip text replaces them)
- if(hasSelection())
- {
- deleteSelection(TRUE);
- }
-
- std::basic_string<llwchar>::size_type pos = tool_tip_text.find('\n',0);
- if (pos != -1)
- { // Extract the first line of the tooltip
- tool_tip_text = std::basic_string<llwchar>(tool_tip_text, 0, pos);
- }
-
- // Add the text
- cleanStringForPaste(tool_tip_text);
- pasteTextWithLinebreaks(tool_tip_text);
- handled = TRUE;
- }
- }
- else
- { // Normal key handling
- handled = handleNavigationKey( key, mask )
- || handleSelectionKey(key, mask)
- || handleControlKey(key, mask)
- || handleSpecialKey(key, mask);
- }
- }
-
- if( handled )
- {
- resetCursorBlink();
- needsScroll();
-
- if (mShowEmojiHelper)
- {
- // Dismiss the helper whenever we handled a key that it didn't
- LLEmojiHelper::instance().hideHelper(this);
- }
- }
-
- return handled;
+ KEY_TAB == key)
+ { // Paste the first line of a tooltip into the editor
+ std::string message;
+ LLToolTipMgr::instance().getToolTipMessage(message);
+ LLWString tool_tip_text(utf8str_to_wstring(message));
+
+ if (tool_tip_text.size() > 0)
+ {
+ // Delete any selected characters (the tooltip text replaces them)
+ if(hasSelection())
+ {
+ deleteSelection(TRUE);
+ }
+
+ std::basic_string<llwchar>::size_type pos = tool_tip_text.find('\n',0);
+ if (pos != -1)
+ { // Extract the first line of the tooltip
+ tool_tip_text = std::basic_string<llwchar>(tool_tip_text, 0, pos);
+ }
+
+ // Add the text
+ cleanStringForPaste(tool_tip_text);
+ pasteTextWithLinebreaks(tool_tip_text);
+ handled = TRUE;
+ }
+ }
+ else
+ { // Normal key handling
+ handled = handleNavigationKey( key, mask )
+ || handleSelectionKey(key, mask)
+ || handleControlKey(key, mask)
+ || handleSpecialKey(key, mask);
+ }
+ }
+
+ if( handled )
+ {
+ resetCursorBlink();
+ needsScroll();
+
+ if (mShowEmojiHelper)
+ {
+ // Dismiss the helper whenever we handled a key that it didn't
+ LLEmojiHelper::instance().hideHelper(this);
+ }
+ }
+
+ return handled;
}
BOOL LLTextEditor::handleUnicodeCharHere(llwchar uni_char)
{
- if ((uni_char < 0x20) || (uni_char == 0x7F)) // Control character or DEL
- {
- return FALSE;
- }
+ if ((uni_char < 0x20) || (uni_char == 0x7F)) // Control character or DEL
+ {
+ return FALSE;
+ }
- BOOL handled = FALSE;
+ BOOL handled = FALSE;
- // Handle most keys only if the text editor is writeable.
- if( !mReadOnly )
- {
+ // Handle most keys only if the text editor is writeable.
+ if( !mReadOnly )
+ {
if (mShowEmojiHelper && uni_char < 0x80 && LLEmojiHelper::instance().handleKey(this, (KEY)uni_char, MASK_NONE))
{
return TRUE;
}
if( mAutoIndent && '}' == uni_char )
- {
- unindentLineBeforeCloseBrace();
- }
+ {
+ unindentLineBeforeCloseBrace();
+ }
- // TODO: KLW Add auto show of tool tip on (
- addChar( uni_char );
+ // TODO: KLW Add auto show of tool tip on (
+ addChar( uni_char );
- // Keys that add characters temporarily hide the cursor
- getWindow()->hideCursorUntilMouseMove();
+ // Keys that add characters temporarily hide the cursor
+ getWindow()->hideCursorUntilMouseMove();
- handled = TRUE;
- }
+ handled = TRUE;
+ }
- if( handled )
- {
- resetCursorBlink();
+ if( handled )
+ {
+ resetCursorBlink();
- // Most keystrokes will make the selection box go away, but not all will.
- deselect();
+ // Most keystrokes will make the selection box go away, but not all will.
+ deselect();
- onKeyStroke();
- }
+ onKeyStroke();
+ }
- return handled;
+ return handled;
}
// virtual
BOOL LLTextEditor::canDoDelete() const
{
- return !mReadOnly && ( !mPassDelete || ( hasSelection() || (mCursorPos < getLength())) );
+ return !mReadOnly && ( !mPassDelete || ( hasSelection() || (mCursorPos < getLength())) );
}
void LLTextEditor::doDelete()
{
- if( !canDoDelete() )
- {
- return;
- }
- if( hasSelection() )
- {
- deleteSelection(FALSE);
- }
- else
- if( mCursorPos < getLength() )
- {
- S32 i;
- S32 chars_to_remove = 1;
- LLWString text = getWText();
- if( (text[ mCursorPos ] == ' ') && (mCursorPos + SPACES_PER_TAB < getLength()) )
- {
- // Try to remove a full tab's worth of spaces
- S32 offset = getLineOffsetFromDocIndex(mCursorPos);
- chars_to_remove = SPACES_PER_TAB - (offset % SPACES_PER_TAB);
- if( chars_to_remove == 0 )
- {
- chars_to_remove = SPACES_PER_TAB;
- }
-
- for( i = 0; i < chars_to_remove; i++ )
- {
- if( text[mCursorPos + i] != ' ' )
- {
- chars_to_remove = 1;
- break;
- }
- }
- }
-
- for( i = 0; i < chars_to_remove; i++ )
- {
- setCursorPos(mCursorPos + 1);
- removeChar();
- }
-
- }
-
- onKeyStroke();
+ if( !canDoDelete() )
+ {
+ return;
+ }
+ if( hasSelection() )
+ {
+ deleteSelection(FALSE);
+ }
+ else
+ if( mCursorPos < getLength() )
+ {
+ S32 i;
+ S32 chars_to_remove = 1;
+ LLWString text = getWText();
+ if( (text[ mCursorPos ] == ' ') && (mCursorPos + SPACES_PER_TAB < getLength()) )
+ {
+ // Try to remove a full tab's worth of spaces
+ S32 offset = getLineOffsetFromDocIndex(mCursorPos);
+ chars_to_remove = SPACES_PER_TAB - (offset % SPACES_PER_TAB);
+ if( chars_to_remove == 0 )
+ {
+ chars_to_remove = SPACES_PER_TAB;
+ }
+
+ for( i = 0; i < chars_to_remove; i++ )
+ {
+ if( text[mCursorPos + i] != ' ' )
+ {
+ chars_to_remove = 1;
+ break;
+ }
+ }
+ }
+
+ for( i = 0; i < chars_to_remove; i++ )
+ {
+ setCursorPos(mCursorPos + 1);
+ removeChar();
+ }
+
+ }
+
+ onKeyStroke();
}
//----------------------------------------------------------------------------
@@ -2019,624 +2019,624 @@ void LLTextEditor::doDelete()
void LLTextEditor::blockUndo()
{
- mBaseDocIsPristine = FALSE;
- mLastCmd = NULL;
- std::for_each(mUndoStack.begin(), mUndoStack.end(), DeletePointer());
- mUndoStack.clear();
+ mBaseDocIsPristine = FALSE;
+ mLastCmd = NULL;
+ std::for_each(mUndoStack.begin(), mUndoStack.end(), DeletePointer());
+ mUndoStack.clear();
}
// virtual
BOOL LLTextEditor::canUndo() const
{
- return !mReadOnly && mLastCmd != NULL;
+ return !mReadOnly && mLastCmd != NULL;
}
void LLTextEditor::undo()
{
- if( !canUndo() )
- {
- return;
- }
- deselect();
- S32 pos = 0;
- do
- {
- pos = mLastCmd->undo(this);
- undo_stack_t::iterator iter = std::find(mUndoStack.begin(), mUndoStack.end(), mLastCmd);
- if (iter != mUndoStack.end())
- ++iter;
- if (iter != mUndoStack.end())
- mLastCmd = *iter;
- else
- mLastCmd = NULL;
+ if( !canUndo() )
+ {
+ return;
+ }
+ deselect();
+ S32 pos = 0;
+ do
+ {
+ pos = mLastCmd->undo(this);
+ undo_stack_t::iterator iter = std::find(mUndoStack.begin(), mUndoStack.end(), mLastCmd);
+ if (iter != mUndoStack.end())
+ ++iter;
+ if (iter != mUndoStack.end())
+ mLastCmd = *iter;
+ else
+ mLastCmd = NULL;
- } while( mLastCmd && mLastCmd->groupWithNext() );
+ } while( mLastCmd && mLastCmd->groupWithNext() );
- setCursorPos(pos);
+ setCursorPos(pos);
- onKeyStroke();
+ onKeyStroke();
}
BOOL LLTextEditor::canRedo() const
{
- return !mReadOnly && (mUndoStack.size() > 0) && (mLastCmd != mUndoStack.front());
+ return !mReadOnly && (mUndoStack.size() > 0) && (mLastCmd != mUndoStack.front());
}
void LLTextEditor::redo()
{
- if( !canRedo() )
- {
- return;
- }
- deselect();
- S32 pos = 0;
- do
- {
- if( !mLastCmd )
- {
- mLastCmd = mUndoStack.back();
- }
- else
- {
- undo_stack_t::iterator iter = std::find(mUndoStack.begin(), mUndoStack.end(), mLastCmd);
- if (iter != mUndoStack.begin())
- mLastCmd = *(--iter);
- else
- mLastCmd = NULL;
- }
-
- if( mLastCmd )
- {
- pos = mLastCmd->redo(this);
- }
- } while(
- mLastCmd &&
- mLastCmd->groupWithNext() &&
- (mLastCmd != mUndoStack.front()) );
-
- setCursorPos(pos);
-
- onKeyStroke();
+ if( !canRedo() )
+ {
+ return;
+ }
+ deselect();
+ S32 pos = 0;
+ do
+ {
+ if( !mLastCmd )
+ {
+ mLastCmd = mUndoStack.back();
+ }
+ else
+ {
+ undo_stack_t::iterator iter = std::find(mUndoStack.begin(), mUndoStack.end(), mLastCmd);
+ if (iter != mUndoStack.begin())
+ mLastCmd = *(--iter);
+ else
+ mLastCmd = NULL;
+ }
+
+ if( mLastCmd )
+ {
+ pos = mLastCmd->redo(this);
+ }
+ } while(
+ mLastCmd &&
+ mLastCmd->groupWithNext() &&
+ (mLastCmd != mUndoStack.front()) );
+
+ setCursorPos(pos);
+
+ onKeyStroke();
}
void LLTextEditor::onFocusReceived()
{
- LLTextBase::onFocusReceived();
- updateAllowingLanguageInput();
+ LLTextBase::onFocusReceived();
+ updateAllowingLanguageInput();
}
void LLTextEditor::focusLostHelper()
{
- updateAllowingLanguageInput();
+ updateAllowingLanguageInput();
- // Route menu back to the default
- if( gEditMenuHandler == this )
- {
- gEditMenuHandler = NULL;
- }
+ // Route menu back to the default
+ if( gEditMenuHandler == this )
+ {
+ gEditMenuHandler = NULL;
+ }
- if (mCommitOnFocusLost)
- {
- onCommit();
- }
+ if (mCommitOnFocusLost)
+ {
+ onCommit();
+ }
- // Make sure cursor is shown again
- getWindow()->showCursorFromMouseMove();
+ // Make sure cursor is shown again
+ getWindow()->showCursorFromMouseMove();
}
void LLTextEditor::onFocusLost()
{
- focusLostHelper();
- LLTextBase::onFocusLost();
+ focusLostHelper();
+ LLTextBase::onFocusLost();
}
void LLTextEditor::onCommit()
{
- setControlValue(getValue());
- LLTextBase::onCommit();
+ setControlValue(getValue());
+ LLTextBase::onCommit();
}
void LLTextEditor::setEnabled(BOOL enabled)
{
- // just treat enabled as read-only flag
- bool read_only = !enabled;
- if (read_only != mReadOnly)
- {
- //mReadOnly = read_only;
- LLTextBase::setReadOnly(read_only);
- updateSegments();
- updateAllowingLanguageInput();
- }
+ // just treat enabled as read-only flag
+ bool read_only = !enabled;
+ if (read_only != mReadOnly)
+ {
+ //mReadOnly = read_only;
+ LLTextBase::setReadOnly(read_only);
+ updateSegments();
+ updateAllowingLanguageInput();
+ }
}
void LLTextEditor::showContextMenu(S32 x, S32 y)
{
- LLContextMenu* menu = static_cast<LLContextMenu*>(mContextMenuHandle.get());
- if (!menu)
- {
- llassert(LLMenuGL::sMenuContainer != NULL);
- menu = LLUICtrlFactory::createFromFile<LLContextMenu>("menu_text_editor.xml",
- LLMenuGL::sMenuContainer,
- LLMenuHolderGL::child_registry_t::instance());
+ LLContextMenu* menu = static_cast<LLContextMenu*>(mContextMenuHandle.get());
+ if (!menu)
+ {
+ llassert(LLMenuGL::sMenuContainer != NULL);
+ menu = LLUICtrlFactory::createFromFile<LLContextMenu>("menu_text_editor.xml",
+ LLMenuGL::sMenuContainer,
+ LLMenuHolderGL::child_registry_t::instance());
if(!menu)
{
LL_WARNS() << "Failed to create menu for LLTextEditor: " << getName() << LL_ENDL;
return;
}
- mContextMenuHandle = menu->getHandle();
- }
-
- // Route menu to this class
- // previously this was done in ::handleRightMoseDown:
- //if(hasTabStop())
- // setFocus(TRUE) - why? weird...
- // and then inside setFocus
- // ....
- // gEditMenuHandler = this;
- // ....
- // but this didn't work in all cases and just weird...
- //why not here?
- // (all this was done for EXT-4443)
-
- gEditMenuHandler = this;
-
- S32 screen_x, screen_y;
- localPointToScreen(x, y, &screen_x, &screen_y);
-
- setCursorAtLocalPos(x, y, false);
- if (hasSelection())
- {
- if ( (mCursorPos < llmin(mSelectionStart, mSelectionEnd)) || (mCursorPos > llmax(mSelectionStart, mSelectionEnd)) )
- {
- deselect();
- }
- else
- {
- setCursorPos(llmax(mSelectionStart, mSelectionEnd));
- }
- }
-
- bool use_spellcheck = getSpellCheck(), is_misspelled = false;
- if (use_spellcheck)
- {
- mSuggestionList.clear();
-
- // If the cursor is on a misspelled word, retrieve suggestions for it
- std::string misspelled_word = getMisspelledWord(mCursorPos);
- if ((is_misspelled = !misspelled_word.empty()) == true)
- {
- LLSpellChecker::instance().getSuggestions(misspelled_word, mSuggestionList);
- }
- }
-
- menu->setItemVisible("Suggestion Separator", (use_spellcheck) && (!mSuggestionList.empty()));
- menu->setItemVisible("Add to Dictionary", (use_spellcheck) && (is_misspelled));
- menu->setItemVisible("Add to Ignore", (use_spellcheck) && (is_misspelled));
- menu->setItemVisible("Spellcheck Separator", (use_spellcheck) && (is_misspelled));
- menu->show(screen_x, screen_y, this);
+ mContextMenuHandle = menu->getHandle();
+ }
+
+ // Route menu to this class
+ // previously this was done in ::handleRightMoseDown:
+ //if(hasTabStop())
+ // setFocus(TRUE) - why? weird...
+ // and then inside setFocus
+ // ....
+ // gEditMenuHandler = this;
+ // ....
+ // but this didn't work in all cases and just weird...
+ //why not here?
+ // (all this was done for EXT-4443)
+
+ gEditMenuHandler = this;
+
+ S32 screen_x, screen_y;
+ localPointToScreen(x, y, &screen_x, &screen_y);
+
+ setCursorAtLocalPos(x, y, false);
+ if (hasSelection())
+ {
+ if ( (mCursorPos < llmin(mSelectionStart, mSelectionEnd)) || (mCursorPos > llmax(mSelectionStart, mSelectionEnd)) )
+ {
+ deselect();
+ }
+ else
+ {
+ setCursorPos(llmax(mSelectionStart, mSelectionEnd));
+ }
+ }
+
+ bool use_spellcheck = getSpellCheck(), is_misspelled = false;
+ if (use_spellcheck)
+ {
+ mSuggestionList.clear();
+
+ // If the cursor is on a misspelled word, retrieve suggestions for it
+ std::string misspelled_word = getMisspelledWord(mCursorPos);
+ if ((is_misspelled = !misspelled_word.empty()) == true)
+ {
+ LLSpellChecker::instance().getSuggestions(misspelled_word, mSuggestionList);
+ }
+ }
+
+ menu->setItemVisible("Suggestion Separator", (use_spellcheck) && (!mSuggestionList.empty()));
+ menu->setItemVisible("Add to Dictionary", (use_spellcheck) && (is_misspelled));
+ menu->setItemVisible("Add to Ignore", (use_spellcheck) && (is_misspelled));
+ menu->setItemVisible("Spellcheck Separator", (use_spellcheck) && (is_misspelled));
+ menu->show(screen_x, screen_y, this);
}
void LLTextEditor::drawPreeditMarker()
{
- static LLUICachedControl<F32> preedit_marker_brightness ("UIPreeditMarkerBrightness", 0);
- static LLUICachedControl<S32> preedit_marker_gap ("UIPreeditMarkerGap", 0);
- static LLUICachedControl<S32> preedit_marker_position ("UIPreeditMarkerPosition", 0);
- static LLUICachedControl<S32> preedit_marker_thickness ("UIPreeditMarkerThickness", 0);
- static LLUICachedControl<F32> preedit_standout_brightness ("UIPreeditStandoutBrightness", 0);
- static LLUICachedControl<S32> preedit_standout_gap ("UIPreeditStandoutGap", 0);
- static LLUICachedControl<S32> preedit_standout_position ("UIPreeditStandoutPosition", 0);
- static LLUICachedControl<S32> preedit_standout_thickness ("UIPreeditStandoutThickness", 0);
+ static LLUICachedControl<F32> preedit_marker_brightness ("UIPreeditMarkerBrightness", 0);
+ static LLUICachedControl<S32> preedit_marker_gap ("UIPreeditMarkerGap", 0);
+ static LLUICachedControl<S32> preedit_marker_position ("UIPreeditMarkerPosition", 0);
+ static LLUICachedControl<S32> preedit_marker_thickness ("UIPreeditMarkerThickness", 0);
+ static LLUICachedControl<F32> preedit_standout_brightness ("UIPreeditStandoutBrightness", 0);
+ static LLUICachedControl<S32> preedit_standout_gap ("UIPreeditStandoutGap", 0);
+ static LLUICachedControl<S32> preedit_standout_position ("UIPreeditStandoutPosition", 0);
+ static LLUICachedControl<S32> preedit_standout_thickness ("UIPreeditStandoutThickness", 0);
- if (!hasPreeditString())
- {
- return;
- }
+ if (!hasPreeditString())
+ {
+ return;
+ }
const LLWString textString(getWText());
- const llwchar *text = textString.c_str();
- const S32 text_len = getLength();
- const S32 num_lines = getLineCount();
-
- S32 cur_line = getFirstVisibleLine();
- if (cur_line >= num_lines)
- {
- return;
- }
-
- const S32 line_height = mFont->getLineHeight();
-
- S32 line_start = getLineStart(cur_line);
- S32 line_y = mVisibleTextRect.mTop - line_height;
- while((mVisibleTextRect.mBottom <= line_y) && (num_lines > cur_line))
- {
- S32 next_start = -1;
- S32 line_end = text_len;
-
- if ((cur_line + 1) < num_lines)
- {
- next_start = getLineStart(cur_line + 1);
- line_end = next_start;
- }
- if ( text[line_end-1] == '\n' )
- {
- --line_end;
- }
-
- // Does this line contain preedits?
- if (line_start >= mPreeditPositions.back())
- {
- // We have passed the preedits.
- break;
- }
- if (line_end > mPreeditPositions.front())
- {
- for (U32 i = 0; i < mPreeditStandouts.size(); i++)
- {
- S32 left = mPreeditPositions[i];
- S32 right = mPreeditPositions[i + 1];
- if (right <= line_start || left >= line_end)
- {
- continue;
- }
-
- line_info& line = mLineInfoList[cur_line];
- LLRect text_rect(line.mRect);
- text_rect.mRight = mDocumentView->getRect().getWidth(); // clamp right edge to document extents
- text_rect.translate(mDocumentView->getRect().mLeft, mDocumentView->getRect().mBottom); // adjust by scroll position
-
- S32 preedit_left = text_rect.mLeft;
- if (left > line_start)
- {
- preedit_left += mFont->getWidth(text, line_start, left - line_start);
- }
- S32 preedit_right = text_rect.mLeft;
- if (right < line_end)
- {
- preedit_right += mFont->getWidth(text, line_start, right - line_start);
- }
- else
- {
- preedit_right += mFont->getWidth(text, line_start, line_end - line_start);
- }
-
- if (mPreeditStandouts[i])
- {
- gl_rect_2d(preedit_left + preedit_standout_gap,
- text_rect.mBottom + mFont->getDescenderHeight() - 1,
- preedit_right - preedit_standout_gap - 1,
- text_rect.mBottom + mFont->getDescenderHeight() - 1 - preedit_standout_thickness,
- (mCursorColor.get() * preedit_standout_brightness + mWriteableBgColor.get() * (1 - preedit_standout_brightness)).setAlpha(1.0f));
- }
- else
- {
- gl_rect_2d(preedit_left + preedit_marker_gap,
- text_rect.mBottom + mFont->getDescenderHeight() - 1,
- preedit_right - preedit_marker_gap - 1,
- text_rect.mBottom + mFont->getDescenderHeight() - 1 - preedit_marker_thickness,
- (mCursorColor.get() * preedit_marker_brightness + mWriteableBgColor.get() * (1 - preedit_marker_brightness)).setAlpha(1.0f));
- }
- }
- }
-
- // move down one line
- line_y -= line_height;
- line_start = next_start;
- cur_line++;
- }
+ const llwchar *text = textString.c_str();
+ const S32 text_len = getLength();
+ const S32 num_lines = getLineCount();
+
+ S32 cur_line = getFirstVisibleLine();
+ if (cur_line >= num_lines)
+ {
+ return;
+ }
+
+ const S32 line_height = mFont->getLineHeight();
+
+ S32 line_start = getLineStart(cur_line);
+ S32 line_y = mVisibleTextRect.mTop - line_height;
+ while((mVisibleTextRect.mBottom <= line_y) && (num_lines > cur_line))
+ {
+ S32 next_start = -1;
+ S32 line_end = text_len;
+
+ if ((cur_line + 1) < num_lines)
+ {
+ next_start = getLineStart(cur_line + 1);
+ line_end = next_start;
+ }
+ if ( text[line_end-1] == '\n' )
+ {
+ --line_end;
+ }
+
+ // Does this line contain preedits?
+ if (line_start >= mPreeditPositions.back())
+ {
+ // We have passed the preedits.
+ break;
+ }
+ if (line_end > mPreeditPositions.front())
+ {
+ for (U32 i = 0; i < mPreeditStandouts.size(); i++)
+ {
+ S32 left = mPreeditPositions[i];
+ S32 right = mPreeditPositions[i + 1];
+ if (right <= line_start || left >= line_end)
+ {
+ continue;
+ }
+
+ line_info& line = mLineInfoList[cur_line];
+ LLRect text_rect(line.mRect);
+ text_rect.mRight = mDocumentView->getRect().getWidth(); // clamp right edge to document extents
+ text_rect.translate(mDocumentView->getRect().mLeft, mDocumentView->getRect().mBottom); // adjust by scroll position
+
+ S32 preedit_left = text_rect.mLeft;
+ if (left > line_start)
+ {
+ preedit_left += mFont->getWidth(text, line_start, left - line_start);
+ }
+ S32 preedit_right = text_rect.mLeft;
+ if (right < line_end)
+ {
+ preedit_right += mFont->getWidth(text, line_start, right - line_start);
+ }
+ else
+ {
+ preedit_right += mFont->getWidth(text, line_start, line_end - line_start);
+ }
+
+ if (mPreeditStandouts[i])
+ {
+ gl_rect_2d(preedit_left + preedit_standout_gap,
+ text_rect.mBottom + mFont->getDescenderHeight() - 1,
+ preedit_right - preedit_standout_gap - 1,
+ text_rect.mBottom + mFont->getDescenderHeight() - 1 - preedit_standout_thickness,
+ (mCursorColor.get() * preedit_standout_brightness + mWriteableBgColor.get() * (1 - preedit_standout_brightness)).setAlpha(1.0f));
+ }
+ else
+ {
+ gl_rect_2d(preedit_left + preedit_marker_gap,
+ text_rect.mBottom + mFont->getDescenderHeight() - 1,
+ preedit_right - preedit_marker_gap - 1,
+ text_rect.mBottom + mFont->getDescenderHeight() - 1 - preedit_marker_thickness,
+ (mCursorColor.get() * preedit_marker_brightness + mWriteableBgColor.get() * (1 - preedit_marker_brightness)).setAlpha(1.0f));
+ }
+ }
+ }
+
+ // move down one line
+ line_y -= line_height;
+ line_start = next_start;
+ cur_line++;
+ }
}
void LLTextEditor::draw()
{
- {
- // pad clipping rectangle so that cursor can draw at full width
- // when at left edge of mVisibleTextRect
- LLRect clip_rect(mVisibleTextRect);
- clip_rect.stretch(1);
- LLLocalClipRect clip(clip_rect);
- }
+ {
+ // pad clipping rectangle so that cursor can draw at full width
+ // when at left edge of mVisibleTextRect
+ LLRect clip_rect(mVisibleTextRect);
+ clip_rect.stretch(1);
+ LLLocalClipRect clip(clip_rect);
+ }
- LLTextBase::draw();
+ LLTextBase::draw();
drawPreeditMarker();
- //RN: the decision was made to always show the orange border for keyboard focus but do not put an insertion caret
- // when in readonly mode
- mBorder->setKeyboardFocusHighlight( hasFocus() );// && !mReadOnly);
+ //RN: the decision was made to always show the orange border for keyboard focus but do not put an insertion caret
+ // when in readonly mode
+ mBorder->setKeyboardFocusHighlight( hasFocus() );// && !mReadOnly);
}
// Start or stop the editor from accepting text-editing keystrokes
// see also LLLineEditor
void LLTextEditor::setFocus( BOOL new_state )
{
- BOOL old_state = hasFocus();
+ BOOL old_state = hasFocus();
- // Don't change anything if the focus state didn't change
- if (new_state == old_state) return;
+ // Don't change anything if the focus state didn't change
+ if (new_state == old_state) return;
- // Notify early if we are losing focus.
- if (!new_state)
- {
- getWindow()->allowLanguageTextInput(this, FALSE);
- }
+ // Notify early if we are losing focus.
+ if (!new_state)
+ {
+ getWindow()->allowLanguageTextInput(this, FALSE);
+ }
- LLTextBase::setFocus( new_state );
+ LLTextBase::setFocus( new_state );
- if( new_state )
- {
- // Route menu to this class
- gEditMenuHandler = this;
+ if( new_state )
+ {
+ // Route menu to this class
+ gEditMenuHandler = this;
- // Don't start the cursor flashing right away
- resetCursorBlink();
- }
- else
- {
- // Route menu back to the default
- if( gEditMenuHandler == this )
- {
- gEditMenuHandler = NULL;
- }
+ // Don't start the cursor flashing right away
+ resetCursorBlink();
+ }
+ else
+ {
+ // Route menu back to the default
+ if( gEditMenuHandler == this )
+ {
+ gEditMenuHandler = NULL;
+ }
- endSelection();
- }
+ endSelection();
+ }
}
// public
void LLTextEditor::setCursorAndScrollToEnd()
{
- deselect();
- endOfDoc();
+ deselect();
+ endOfDoc();
}
-void LLTextEditor::getCurrentLineAndColumn( S32* line, S32* col, BOOL include_wordwrap )
-{
- *line = getLineNumFromDocIndex(mCursorPos, include_wordwrap);
- *col = getLineOffsetFromDocIndex(mCursorPos, include_wordwrap);
+void LLTextEditor::getCurrentLineAndColumn( S32* line, S32* col, BOOL include_wordwrap )
+{
+ *line = getLineNumFromDocIndex(mCursorPos, include_wordwrap);
+ *col = getLineOffsetFromDocIndex(mCursorPos, include_wordwrap);
}
void LLTextEditor::autoIndent()
{
- // Count the number of spaces in the current line
- S32 line = getLineNumFromDocIndex(mCursorPos, false);
- S32 line_start = getLineStart(line);
- S32 space_count = 0;
- S32 i;
+ // Count the number of spaces in the current line
+ S32 line = getLineNumFromDocIndex(mCursorPos, false);
+ S32 line_start = getLineStart(line);
+ S32 space_count = 0;
+ S32 i;
- LLWString text = getWText();
- S32 offset = getLineOffsetFromDocIndex(mCursorPos);
- while(( ' ' == text[line_start] ) && (space_count < offset))
- {
- space_count++;
- line_start++;
- }
+ LLWString text = getWText();
+ S32 offset = getLineOffsetFromDocIndex(mCursorPos);
+ while(( ' ' == text[line_start] ) && (space_count < offset))
+ {
+ space_count++;
+ line_start++;
+ }
- // If we're starting a braced section, indent one level.
- if( (mCursorPos > 0) && (text[mCursorPos -1] == '{') )
- {
- space_count += SPACES_PER_TAB;
- }
+ // If we're starting a braced section, indent one level.
+ if( (mCursorPos > 0) && (text[mCursorPos -1] == '{') )
+ {
+ space_count += SPACES_PER_TAB;
+ }
- // Insert that number of spaces on the new line
+ // Insert that number of spaces on the new line
- //appendLineBreakSegment(LLStyle::Params());//addChar( '\n' );
- addLineBreakChar();
+ //appendLineBreakSegment(LLStyle::Params());//addChar( '\n' );
+ addLineBreakChar();
- for( i = 0; i < space_count; i++ )
- {
- addChar( ' ' );
- }
+ for( i = 0; i < space_count; i++ )
+ {
+ addChar( ' ' );
+ }
}
// Inserts new text at the cursor position
void LLTextEditor::insertText(const std::string &new_text)
{
- BOOL enabled = getEnabled();
- setEnabled( TRUE );
+ BOOL enabled = getEnabled();
+ setEnabled( TRUE );
+
+ // Delete any selected characters (the insertion replaces them)
+ if( hasSelection() )
+ {
+ deleteSelection(TRUE);
+ }
- // Delete any selected characters (the insertion replaces them)
- if( hasSelection() )
- {
- deleteSelection(TRUE);
- }
+ setCursorPos(mCursorPos + insert( mCursorPos, utf8str_to_wstring(new_text), FALSE, LLTextSegmentPtr() ));
- setCursorPos(mCursorPos + insert( mCursorPos, utf8str_to_wstring(new_text), FALSE, LLTextSegmentPtr() ));
-
- setEnabled( enabled );
+ setEnabled( enabled );
}
void LLTextEditor::insertText(LLWString &new_text)
{
- BOOL enabled = getEnabled();
- setEnabled( TRUE );
+ BOOL enabled = getEnabled();
+ setEnabled( TRUE );
- // Delete any selected characters (the insertion replaces them)
- if( hasSelection() )
- {
- deleteSelection(TRUE);
- }
+ // Delete any selected characters (the insertion replaces them)
+ if( hasSelection() )
+ {
+ deleteSelection(TRUE);
+ }
- setCursorPos(mCursorPos + insert( mCursorPos, new_text, FALSE, LLTextSegmentPtr() ));
+ setCursorPos(mCursorPos + insert( mCursorPos, new_text, FALSE, LLTextSegmentPtr() ));
- setEnabled( enabled );
+ setEnabled( enabled );
}
void LLTextEditor::appendWidget(const LLInlineViewSegment::Params& params, const std::string& text, bool allow_undo)
{
- // Save old state
- S32 selection_start = mSelectionStart;
- S32 selection_end = mSelectionEnd;
- BOOL was_selecting = mIsSelecting;
- S32 cursor_pos = mCursorPos;
- S32 old_length = getLength();
- BOOL cursor_was_at_end = (mCursorPos == old_length);
+ // Save old state
+ S32 selection_start = mSelectionStart;
+ S32 selection_end = mSelectionEnd;
+ BOOL was_selecting = mIsSelecting;
+ S32 cursor_pos = mCursorPos;
+ S32 old_length = getLength();
+ BOOL cursor_was_at_end = (mCursorPos == old_length);
- deselect();
+ deselect();
- setCursorPos(old_length);
+ setCursorPos(old_length);
- LLWString widget_wide_text = utf8str_to_wstring(text);
+ LLWString widget_wide_text = utf8str_to_wstring(text);
- LLTextSegmentPtr segment = new LLInlineViewSegment(params, old_length, old_length + widget_wide_text.size());
- insert(getLength(), widget_wide_text, FALSE, segment);
+ LLTextSegmentPtr segment = new LLInlineViewSegment(params, old_length, old_length + widget_wide_text.size());
+ insert(getLength(), widget_wide_text, FALSE, segment);
- // Set the cursor and scroll position
- if( selection_start != selection_end )
- {
- mSelectionStart = selection_start;
- mSelectionEnd = selection_end;
+ // Set the cursor and scroll position
+ if( selection_start != selection_end )
+ {
+ mSelectionStart = selection_start;
+ mSelectionEnd = selection_end;
- mIsSelecting = was_selecting;
- setCursorPos(cursor_pos);
- }
- else if( cursor_was_at_end )
- {
- setCursorPos(getLength());
- }
- else
- {
- setCursorPos(cursor_pos);
- }
+ mIsSelecting = was_selecting;
+ setCursorPos(cursor_pos);
+ }
+ else if( cursor_was_at_end )
+ {
+ setCursorPos(getLength());
+ }
+ else
+ {
+ setCursorPos(cursor_pos);
+ }
- if (!allow_undo)
- {
- blockUndo();
- }
+ if (!allow_undo)
+ {
+ blockUndo();
+ }
}
void LLTextEditor::removeTextFromEnd(S32 num_chars)
{
- if (num_chars <= 0) return;
+ if (num_chars <= 0) return;
- remove(getLength() - num_chars, num_chars, FALSE);
+ remove(getLength() - num_chars, num_chars, FALSE);
- S32 len = getLength();
- setCursorPos (llclamp(mCursorPos, 0, len));
- mSelectionStart = llclamp(mSelectionStart, 0, len);
- mSelectionEnd = llclamp(mSelectionEnd, 0, len);
+ S32 len = getLength();
+ setCursorPos (llclamp(mCursorPos, 0, len));
+ mSelectionStart = llclamp(mSelectionStart, 0, len);
+ mSelectionEnd = llclamp(mSelectionEnd, 0, len);
- needsScroll();
+ needsScroll();
}
//----------------------------------------------------------------------------
void LLTextEditor::onSpellCheckPerformed()
{
- if (isPristine())
- {
- mBaseDocIsPristine = FALSE;
- }
+ if (isPristine())
+ {
+ mBaseDocIsPristine = FALSE;
+ }
}
void LLTextEditor::makePristine()
{
- mPristineCmd = mLastCmd;
- mBaseDocIsPristine = !mLastCmd;
+ mPristineCmd = mLastCmd;
+ mBaseDocIsPristine = !mLastCmd;
- // Create a clean partition in the undo stack. We don't want a single command to extend from
- // the "pre-pristine" state to the "post-pristine" state.
- if( mLastCmd )
- {
- mLastCmd->blockExtensions();
- }
+ // Create a clean partition in the undo stack. We don't want a single command to extend from
+ // the "pre-pristine" state to the "post-pristine" state.
+ if( mLastCmd )
+ {
+ mLastCmd->blockExtensions();
+ }
}
BOOL LLTextEditor::isPristine() const
{
- if( mPristineCmd )
- {
- return (mPristineCmd == mLastCmd);
- }
- else
- {
- // No undo stack, so check if the version before and commands were done was the original version
- return !mLastCmd && mBaseDocIsPristine;
- }
+ if( mPristineCmd )
+ {
+ return (mPristineCmd == mLastCmd);
+ }
+ else
+ {
+ // No undo stack, so check if the version before and commands were done was the original version
+ return !mLastCmd && mBaseDocIsPristine;
+ }
}
BOOL LLTextEditor::tryToRevertToPristineState()
{
- if( !isPristine() )
- {
- deselect();
- S32 i = 0;
- while( !isPristine() && canUndo() )
- {
- undo();
- i--;
- }
-
- while( !isPristine() && canRedo() )
- {
- redo();
- i++;
- }
-
- if( !isPristine() )
- {
- // failed, so go back to where we started
- while( i > 0 )
- {
- undo();
- i--;
- }
- }
- }
-
- return isPristine(); // TRUE => success
+ if( !isPristine() )
+ {
+ deselect();
+ S32 i = 0;
+ while( !isPristine() && canUndo() )
+ {
+ undo();
+ i--;
+ }
+
+ while( !isPristine() && canRedo() )
+ {
+ redo();
+ i++;
+ }
+
+ if( !isPristine() )
+ {
+ // failed, so go back to where we started
+ while( i > 0 )
+ {
+ undo();
+ i--;
+ }
+ }
+ }
+
+ return isPristine(); // TRUE => success
}
void LLTextEditor::updateLinkSegments()
{
- LLWString wtext = getWText();
-
- // update any segments that contain a link
- for (segment_set_t::iterator it = mSegments.begin(); it != mSegments.end(); ++it)
- {
- LLTextSegment *segment = *it;
- if (segment && segment->getStyle() && segment->getStyle()->isLink())
- {
- LLStyleConstSP style = segment->getStyle();
- LLStyleSP new_style(new LLStyle(*style));
- LLWString url_label = wtext.substr(segment->getStart(), segment->getEnd()-segment->getStart());
-
- segment_set_t::const_iterator next_it = mSegments.upper_bound(segment);
- LLTextSegment *next_segment = *next_it;
- if (next_segment)
- {
- LLWString next_url_label = wtext.substr(next_segment->getStart(), next_segment->getEnd()-next_segment->getStart());
- std::string link_check = wstring_to_utf8str(url_label) + wstring_to_utf8str(next_url_label);
- LLUrlMatch match;
-
- if ( LLUrlRegistry::instance().findUrl(link_check, match))
- {
- if(match.getQuery() == wstring_to_utf8str(next_url_label))
- {
- continue;
- }
- }
- }
-
- // if the link's label (what the user can edit) is a valid Url,
- // then update the link's HREF to be the same as the label text.
- // This lets users edit Urls in-place.
- if (acceptsTextInput() && LLUrlRegistry::instance().hasUrl(url_label))
- {
- std::string new_url = wstring_to_utf8str(url_label);
- LLStringUtil::trim(new_url);
- new_style->setLinkHREF(new_url);
- LLStyleConstSP sp(new_style);
- segment->setStyle(sp);
- }
- }
- }
+ LLWString wtext = getWText();
+
+ // update any segments that contain a link
+ for (segment_set_t::iterator it = mSegments.begin(); it != mSegments.end(); ++it)
+ {
+ LLTextSegment *segment = *it;
+ if (segment && segment->getStyle() && segment->getStyle()->isLink())
+ {
+ LLStyleConstSP style = segment->getStyle();
+ LLStyleSP new_style(new LLStyle(*style));
+ LLWString url_label = wtext.substr(segment->getStart(), segment->getEnd()-segment->getStart());
+
+ segment_set_t::const_iterator next_it = mSegments.upper_bound(segment);
+ LLTextSegment *next_segment = *next_it;
+ if (next_segment)
+ {
+ LLWString next_url_label = wtext.substr(next_segment->getStart(), next_segment->getEnd()-next_segment->getStart());
+ std::string link_check = wstring_to_utf8str(url_label) + wstring_to_utf8str(next_url_label);
+ LLUrlMatch match;
+
+ if ( LLUrlRegistry::instance().findUrl(link_check, match))
+ {
+ if(match.getQuery() == wstring_to_utf8str(next_url_label))
+ {
+ continue;
+ }
+ }
+ }
+
+ // if the link's label (what the user can edit) is a valid Url,
+ // then update the link's HREF to be the same as the label text.
+ // This lets users edit Urls in-place.
+ if (acceptsTextInput() && LLUrlRegistry::instance().hasUrl(url_label))
+ {
+ std::string new_url = wstring_to_utf8str(url_label);
+ LLStringUtil::trim(new_url);
+ new_style->setLinkHREF(new_url);
+ LLStyleConstSP sp(new_style);
+ segment->setStyle(sp);
+ }
+ }
+ }
}
void LLTextEditor::onMouseCaptureLost()
{
- endSelection();
+ endSelection();
}
///////////////////////////////////////////////////////////////////
@@ -2644,135 +2644,135 @@ void LLTextEditor::onMouseCaptureLost()
BOOL LLTextEditor::importBuffer(const char* buffer, S32 length )
{
- std::istringstream instream(buffer);
-
- // Version 1 format:
- // Linden text version 1\n
- // {\n
- // <EmbeddedItemList chunk>
- // Text length <bytes without \0>\n
- // <text without \0> (text may contain ext_char_values)
- // }\n
-
- char tbuf[MAX_STRING]; /* Flawfinder: ignore */
-
- S32 version = 0;
- instream.getline(tbuf, MAX_STRING);
- if( 1 != sscanf(tbuf, "Linden text version %d", &version) )
- {
- LL_WARNS() << "Invalid Linden text file header " << LL_ENDL;
- return FALSE;
- }
-
- if( 1 != version )
- {
- LL_WARNS() << "Invalid Linden text file version: " << version << LL_ENDL;
- return FALSE;
- }
-
- instream.getline(tbuf, MAX_STRING);
- if( 0 != sscanf(tbuf, "{") )
- {
- LL_WARNS() << "Invalid Linden text file format" << LL_ENDL;
- return FALSE;
- }
-
- S32 text_len = 0;
- instream.getline(tbuf, MAX_STRING);
- if( 1 != sscanf(tbuf, "Text length %d", &text_len) )
- {
- LL_WARNS() << "Invalid Linden text length field" << LL_ENDL;
- return FALSE;
- }
-
- if( text_len > mMaxTextByteLength )
- {
- LL_WARNS() << "Invalid Linden text length: " << text_len << LL_ENDL;
- return FALSE;
- }
-
- BOOL success = TRUE;
-
- char* text = new char[ text_len + 1];
- if (text == NULL)
- {
+ std::istringstream instream(buffer);
+
+ // Version 1 format:
+ // Linden text version 1\n
+ // {\n
+ // <EmbeddedItemList chunk>
+ // Text length <bytes without \0>\n
+ // <text without \0> (text may contain ext_char_values)
+ // }\n
+
+ char tbuf[MAX_STRING]; /* Flawfinder: ignore */
+
+ S32 version = 0;
+ instream.getline(tbuf, MAX_STRING);
+ if( 1 != sscanf(tbuf, "Linden text version %d", &version) )
+ {
+ LL_WARNS() << "Invalid Linden text file header " << LL_ENDL;
+ return FALSE;
+ }
+
+ if( 1 != version )
+ {
+ LL_WARNS() << "Invalid Linden text file version: " << version << LL_ENDL;
+ return FALSE;
+ }
+
+ instream.getline(tbuf, MAX_STRING);
+ if( 0 != sscanf(tbuf, "{") )
+ {
+ LL_WARNS() << "Invalid Linden text file format" << LL_ENDL;
+ return FALSE;
+ }
+
+ S32 text_len = 0;
+ instream.getline(tbuf, MAX_STRING);
+ if( 1 != sscanf(tbuf, "Text length %d", &text_len) )
+ {
+ LL_WARNS() << "Invalid Linden text length field" << LL_ENDL;
+ return FALSE;
+ }
+
+ if( text_len > mMaxTextByteLength )
+ {
+ LL_WARNS() << "Invalid Linden text length: " << text_len << LL_ENDL;
+ return FALSE;
+ }
+
+ BOOL success = TRUE;
+
+ char* text = new char[ text_len + 1];
+ if (text == NULL)
+ {
LLError::LLUserWarningMsg::showOutOfMemory();
- LL_ERRS() << "Memory allocation failure." << LL_ENDL;
- return FALSE;
- }
- instream.get(text, text_len + 1, '\0');
- text[text_len] = '\0';
- if( text_len != (S32)strlen(text) )/* Flawfinder: ignore */
- {
- LL_WARNS() << llformat("Invalid text length: %d != %d ",strlen(text),text_len) << LL_ENDL;/* Flawfinder: ignore */
- success = FALSE;
- }
-
- instream.getline(tbuf, MAX_STRING);
- if( success && (0 != sscanf(tbuf, "}")) )
- {
- LL_WARNS() << "Invalid Linden text file format: missing terminal }" << LL_ENDL;
- success = FALSE;
- }
-
- if( success )
- {
- // Actually set the text
- setText( LLStringExplicit(text) );
- }
-
- delete[] text;
-
- startOfDoc();
- deselect();
-
- return success;
+ LL_ERRS() << "Memory allocation failure." << LL_ENDL;
+ return FALSE;
+ }
+ instream.get(text, text_len + 1, '\0');
+ text[text_len] = '\0';
+ if( text_len != (S32)strlen(text) )/* Flawfinder: ignore */
+ {
+ LL_WARNS() << llformat("Invalid text length: %d != %d ",strlen(text),text_len) << LL_ENDL;/* Flawfinder: ignore */
+ success = FALSE;
+ }
+
+ instream.getline(tbuf, MAX_STRING);
+ if( success && (0 != sscanf(tbuf, "}")) )
+ {
+ LL_WARNS() << "Invalid Linden text file format: missing terminal }" << LL_ENDL;
+ success = FALSE;
+ }
+
+ if( success )
+ {
+ // Actually set the text
+ setText( LLStringExplicit(text) );
+ }
+
+ delete[] text;
+
+ startOfDoc();
+ deselect();
+
+ return success;
}
BOOL LLTextEditor::exportBuffer(std::string &buffer )
{
- std::ostringstream outstream(buffer);
-
- outstream << "Linden text version 1\n";
- outstream << "{\n";
+ std::ostringstream outstream(buffer);
- outstream << llformat("Text length %d\n", getLength() );
- outstream << getText();
- outstream << "}\n";
+ outstream << "Linden text version 1\n";
+ outstream << "{\n";
- return TRUE;
+ outstream << llformat("Text length %d\n", getLength() );
+ outstream << getText();
+ outstream << "}\n";
+
+ return TRUE;
}
void LLTextEditor::updateAllowingLanguageInput()
{
- LLWindow* window = getWindow();
- if (!window)
- {
- // test app, no window available
- return;
- }
- if (hasFocus() && !mReadOnly)
- {
- window->allowLanguageTextInput(this, TRUE);
- }
- else
- {
- window->allowLanguageTextInput(this, FALSE);
- }
+ LLWindow* window = getWindow();
+ if (!window)
+ {
+ // test app, no window available
+ return;
+ }
+ if (hasFocus() && !mReadOnly)
+ {
+ window->allowLanguageTextInput(this, TRUE);
+ }
+ else
+ {
+ window->allowLanguageTextInput(this, FALSE);
+ }
}
// Preedit is managed off the undo/redo command stack.
BOOL LLTextEditor::hasPreeditString() const
{
- return (mPreeditPositions.size() > 1);
+ return (mPreeditPositions.size() > 1);
}
void LLTextEditor::resetPreedit()
{
if (hasSelection())
{
- if (hasPreeditString())
+ if (hasPreeditString())
{
LL_WARNS() << "Preedit and selection!" << LL_ENDL;
deselect();
@@ -2782,277 +2782,277 @@ void LLTextEditor::resetPreedit()
deleteSelection(TRUE);
}
}
- if (hasPreeditString())
- {
- if (hasSelection())
- {
- LL_WARNS() << "Preedit and selection!" << LL_ENDL;
- deselect();
- }
+ if (hasPreeditString())
+ {
+ if (hasSelection())
+ {
+ LL_WARNS() << "Preedit and selection!" << LL_ENDL;
+ deselect();
+ }
- setCursorPos(mPreeditPositions.front());
- removeStringNoUndo(mCursorPos, mPreeditPositions.back() - mCursorPos);
- insertStringNoUndo(mCursorPos, mPreeditOverwrittenWString);
+ setCursorPos(mPreeditPositions.front());
+ removeStringNoUndo(mCursorPos, mPreeditPositions.back() - mCursorPos);
+ insertStringNoUndo(mCursorPos, mPreeditOverwrittenWString);
- mPreeditWString.clear();
- mPreeditOverwrittenWString.clear();
- mPreeditPositions.clear();
+ mPreeditWString.clear();
+ mPreeditOverwrittenWString.clear();
+ mPreeditPositions.clear();
- // A call to updatePreedit should soon follow under a
- // normal course of operation, so we don't need to
- // maintain internal variables such as line start
- // positions now.
- }
+ // A call to updatePreedit should soon follow under a
+ // normal course of operation, so we don't need to
+ // maintain internal variables such as line start
+ // positions now.
+ }
}
void LLTextEditor::updatePreedit(const LLWString &preedit_string,
- const segment_lengths_t &preedit_segment_lengths, const standouts_t &preedit_standouts, S32 caret_position)
+ const segment_lengths_t &preedit_segment_lengths, const standouts_t &preedit_standouts, S32 caret_position)
{
- // Just in case.
- if (mReadOnly)
- {
- return;
- }
+ // Just in case.
+ if (mReadOnly)
+ {
+ return;
+ }
+
+ getWindow()->hideCursorUntilMouseMove();
- getWindow()->hideCursorUntilMouseMove();
+ S32 insert_preedit_at = mCursorPos;
- S32 insert_preedit_at = mCursorPos;
+ mPreeditWString = preedit_string;
+ mPreeditPositions.resize(preedit_segment_lengths.size() + 1);
+ S32 position = insert_preedit_at;
+ for (segment_lengths_t::size_type i = 0; i < preedit_segment_lengths.size(); i++)
+ {
+ mPreeditPositions[i] = position;
+ position += preedit_segment_lengths[i];
+ }
+ mPreeditPositions.back() = position;
- mPreeditWString = preedit_string;
- mPreeditPositions.resize(preedit_segment_lengths.size() + 1);
- S32 position = insert_preedit_at;
- for (segment_lengths_t::size_type i = 0; i < preedit_segment_lengths.size(); i++)
- {
- mPreeditPositions[i] = position;
- position += preedit_segment_lengths[i];
- }
- mPreeditPositions.back() = position;
+ if (LL_KIM_OVERWRITE == gKeyboard->getInsertMode())
+ {
+ mPreeditOverwrittenWString = getWText().substr(insert_preedit_at, mPreeditWString.length());
+ removeStringNoUndo(insert_preedit_at, mPreeditWString.length());
+ }
+ else
+ {
+ mPreeditOverwrittenWString.clear();
+ }
- if (LL_KIM_OVERWRITE == gKeyboard->getInsertMode())
- {
- mPreeditOverwrittenWString = getWText().substr(insert_preedit_at, mPreeditWString.length());
- removeStringNoUndo(insert_preedit_at, mPreeditWString.length());
- }
- else
- {
- mPreeditOverwrittenWString.clear();
- }
-
- segment_vec_t segments;
- //pass empty segments to let "insertStringNoUndo" make new LLNormalTextSegment and insert it, if needed.
- insertStringNoUndo(insert_preedit_at, mPreeditWString, &segments);
+ segment_vec_t segments;
+ //pass empty segments to let "insertStringNoUndo" make new LLNormalTextSegment and insert it, if needed.
+ insertStringNoUndo(insert_preedit_at, mPreeditWString, &segments);
- mPreeditStandouts = preedit_standouts;
+ mPreeditStandouts = preedit_standouts;
- setCursorPos(insert_preedit_at + caret_position);
+ setCursorPos(insert_preedit_at + caret_position);
- // Update of the preedit should be caused by some key strokes.
- resetCursorBlink();
+ // Update of the preedit should be caused by some key strokes.
+ resetCursorBlink();
- onKeyStroke();
+ onKeyStroke();
}
BOOL LLTextEditor::getPreeditLocation(S32 query_offset, LLCoordGL *coord, LLRect *bounds, LLRect *control) const
{
- if (control)
- {
- LLRect control_rect_screen;
- localRectToScreen(mVisibleTextRect, &control_rect_screen);
- LLUI::getInstance()->screenRectToGL(control_rect_screen, control);
- }
-
- S32 preedit_left_position, preedit_right_position;
- if (hasPreeditString())
- {
- preedit_left_position = mPreeditPositions.front();
- preedit_right_position = mPreeditPositions.back();
- }
- else
- {
- preedit_left_position = preedit_right_position = mCursorPos;
- }
-
- const S32 query = (query_offset >= 0 ? preedit_left_position + query_offset : mCursorPos);
- if (query < preedit_left_position || query > preedit_right_position)
- {
- return FALSE;
- }
-
- const S32 first_visible_line = getFirstVisibleLine();
- if (query < getLineStart(first_visible_line))
- {
- return FALSE;
- }
-
- S32 current_line = first_visible_line;
- S32 current_line_start, current_line_end;
- for (;;)
- {
- current_line_start = getLineStart(current_line);
- current_line_end = getLineStart(current_line + 1);
- if (query >= current_line_start && query < current_line_end)
- {
- break;
- }
- if (current_line_start == current_line_end)
- {
- // We have reached on the last line. The query position must be here.
- break;
- }
- current_line++;
- }
+ if (control)
+ {
+ LLRect control_rect_screen;
+ localRectToScreen(mVisibleTextRect, &control_rect_screen);
+ LLUI::getInstance()->screenRectToGL(control_rect_screen, control);
+ }
+
+ S32 preedit_left_position, preedit_right_position;
+ if (hasPreeditString())
+ {
+ preedit_left_position = mPreeditPositions.front();
+ preedit_right_position = mPreeditPositions.back();
+ }
+ else
+ {
+ preedit_left_position = preedit_right_position = mCursorPos;
+ }
+
+ const S32 query = (query_offset >= 0 ? preedit_left_position + query_offset : mCursorPos);
+ if (query < preedit_left_position || query > preedit_right_position)
+ {
+ return FALSE;
+ }
+
+ const S32 first_visible_line = getFirstVisibleLine();
+ if (query < getLineStart(first_visible_line))
+ {
+ return FALSE;
+ }
+
+ S32 current_line = first_visible_line;
+ S32 current_line_start, current_line_end;
+ for (;;)
+ {
+ current_line_start = getLineStart(current_line);
+ current_line_end = getLineStart(current_line + 1);
+ if (query >= current_line_start && query < current_line_end)
+ {
+ break;
+ }
+ if (current_line_start == current_line_end)
+ {
+ // We have reached on the last line. The query position must be here.
+ break;
+ }
+ current_line++;
+ }
const LLWString textString(getWText());
- const llwchar * const text = textString.c_str();
- const S32 line_height = mFont->getLineHeight();
-
- if (coord)
- {
- const S32 query_x = mVisibleTextRect.mLeft + mFont->getWidth(text, current_line_start, query - current_line_start);
- const S32 query_y = mVisibleTextRect.mTop - (current_line - first_visible_line) * line_height - line_height / 2;
- S32 query_screen_x, query_screen_y;
- localPointToScreen(query_x, query_y, &query_screen_x, &query_screen_y);
- LLUI::getInstance()->screenPointToGL(query_screen_x, query_screen_y, &coord->mX, &coord->mY);
- }
-
- if (bounds)
- {
- S32 preedit_left = mVisibleTextRect.mLeft;
- if (preedit_left_position > current_line_start)
- {
- preedit_left += mFont->getWidth(text, current_line_start, preedit_left_position - current_line_start);
- }
-
- S32 preedit_right = mVisibleTextRect.mLeft;
- if (preedit_right_position < current_line_end)
- {
- preedit_right += mFont->getWidth(text, current_line_start, preedit_right_position - current_line_start);
- }
- else
- {
- preedit_right += mFont->getWidth(text, current_line_start, current_line_end - current_line_start);
- }
-
- const S32 preedit_top = mVisibleTextRect.mTop - (current_line - first_visible_line) * line_height;
- const S32 preedit_bottom = preedit_top - line_height;
-
- const LLRect preedit_rect_local(preedit_left, preedit_top, preedit_right, preedit_bottom);
- LLRect preedit_rect_screen;
- localRectToScreen(preedit_rect_local, &preedit_rect_screen);
- LLUI::getInstance()->screenRectToGL(preedit_rect_screen, bounds);
- }
-
- return TRUE;
+ const llwchar * const text = textString.c_str();
+ const S32 line_height = mFont->getLineHeight();
+
+ if (coord)
+ {
+ const S32 query_x = mVisibleTextRect.mLeft + mFont->getWidth(text, current_line_start, query - current_line_start);
+ const S32 query_y = mVisibleTextRect.mTop - (current_line - first_visible_line) * line_height - line_height / 2;
+ S32 query_screen_x, query_screen_y;
+ localPointToScreen(query_x, query_y, &query_screen_x, &query_screen_y);
+ LLUI::getInstance()->screenPointToGL(query_screen_x, query_screen_y, &coord->mX, &coord->mY);
+ }
+
+ if (bounds)
+ {
+ S32 preedit_left = mVisibleTextRect.mLeft;
+ if (preedit_left_position > current_line_start)
+ {
+ preedit_left += mFont->getWidth(text, current_line_start, preedit_left_position - current_line_start);
+ }
+
+ S32 preedit_right = mVisibleTextRect.mLeft;
+ if (preedit_right_position < current_line_end)
+ {
+ preedit_right += mFont->getWidth(text, current_line_start, preedit_right_position - current_line_start);
+ }
+ else
+ {
+ preedit_right += mFont->getWidth(text, current_line_start, current_line_end - current_line_start);
+ }
+
+ const S32 preedit_top = mVisibleTextRect.mTop - (current_line - first_visible_line) * line_height;
+ const S32 preedit_bottom = preedit_top - line_height;
+
+ const LLRect preedit_rect_local(preedit_left, preedit_top, preedit_right, preedit_bottom);
+ LLRect preedit_rect_screen;
+ localRectToScreen(preedit_rect_local, &preedit_rect_screen);
+ LLUI::getInstance()->screenRectToGL(preedit_rect_screen, bounds);
+ }
+
+ return TRUE;
}
void LLTextEditor::getSelectionRange(S32 *position, S32 *length) const
{
- if (hasSelection())
- {
- *position = llmin(mSelectionStart, mSelectionEnd);
- *length = llabs(mSelectionStart - mSelectionEnd);
- }
- else
- {
- *position = mCursorPos;
- *length = 0;
- }
+ if (hasSelection())
+ {
+ *position = llmin(mSelectionStart, mSelectionEnd);
+ *length = llabs(mSelectionStart - mSelectionEnd);
+ }
+ else
+ {
+ *position = mCursorPos;
+ *length = 0;
+ }
}
void LLTextEditor::getPreeditRange(S32 *position, S32 *length) const
{
- if (hasPreeditString())
- {
- *position = mPreeditPositions.front();
- *length = mPreeditPositions.back() - mPreeditPositions.front();
- }
- else
- {
- *position = mCursorPos;
- *length = 0;
- }
+ if (hasPreeditString())
+ {
+ *position = mPreeditPositions.front();
+ *length = mPreeditPositions.back() - mPreeditPositions.front();
+ }
+ else
+ {
+ *position = mCursorPos;
+ *length = 0;
+ }
}
void LLTextEditor::markAsPreedit(S32 position, S32 length)
{
- deselect();
- setCursorPos(position);
- if (hasPreeditString())
- {
- LL_WARNS() << "markAsPreedit invoked when hasPreeditString is true." << LL_ENDL;
- }
- mPreeditWString = LLWString( getWText(), position, length );
- if (length > 0)
- {
- mPreeditPositions.resize(2);
- mPreeditPositions[0] = position;
- mPreeditPositions[1] = position + length;
- mPreeditStandouts.resize(1);
- mPreeditStandouts[0] = FALSE;
- }
- else
- {
- mPreeditPositions.clear();
- mPreeditStandouts.clear();
- }
- if (LL_KIM_OVERWRITE == gKeyboard->getInsertMode())
- {
- mPreeditOverwrittenWString = mPreeditWString;
- }
- else
- {
- mPreeditOverwrittenWString.clear();
- }
+ deselect();
+ setCursorPos(position);
+ if (hasPreeditString())
+ {
+ LL_WARNS() << "markAsPreedit invoked when hasPreeditString is true." << LL_ENDL;
+ }
+ mPreeditWString = LLWString( getWText(), position, length );
+ if (length > 0)
+ {
+ mPreeditPositions.resize(2);
+ mPreeditPositions[0] = position;
+ mPreeditPositions[1] = position + length;
+ mPreeditStandouts.resize(1);
+ mPreeditStandouts[0] = FALSE;
+ }
+ else
+ {
+ mPreeditPositions.clear();
+ mPreeditStandouts.clear();
+ }
+ if (LL_KIM_OVERWRITE == gKeyboard->getInsertMode())
+ {
+ mPreeditOverwrittenWString = mPreeditWString;
+ }
+ else
+ {
+ mPreeditOverwrittenWString.clear();
+ }
}
S32 LLTextEditor::getPreeditFontSize() const
{
- return ll_round((F32)mFont->getLineHeight() * LLUI::getScaleFactor().mV[VY]);
+ return ll_round((F32)mFont->getLineHeight() * LLUI::getScaleFactor().mV[VY]);
}
BOOL LLTextEditor::isDirty() const
{
- if(mReadOnly)
- {
- return FALSE;
- }
+ if(mReadOnly)
+ {
+ return FALSE;
+ }
- if( mPristineCmd )
- {
- return ( mPristineCmd == mLastCmd );
- }
- else
- {
- return ( NULL != mLastCmd );
- }
+ if( mPristineCmd )
+ {
+ return ( mPristineCmd == mLastCmd );
+ }
+ else
+ {
+ return ( NULL != mLastCmd );
+ }
}
void LLTextEditor::setKeystrokeCallback(const keystroke_signal_t::slot_type& callback)
{
- mKeystrokeSignal.connect(callback);
+ mKeystrokeSignal.connect(callback);
}
void LLTextEditor::onKeyStroke()
{
- mKeystrokeSignal(this);
+ mKeystrokeSignal(this);
- mSpellCheckStart = mSpellCheckEnd = -1;
- mSpellCheckTimer.setTimerExpirySec(SPELLCHECK_DELAY);
+ mSpellCheckStart = mSpellCheckEnd = -1;
+ mSpellCheckTimer.setTimerExpirySec(SPELLCHECK_DELAY);
}
//virtual
void LLTextEditor::clear()
{
- getViewModel()->setDisplay(LLWStringUtil::null);
- clearSegments();
+ getViewModel()->setDisplay(LLWStringUtil::null);
+ clearSegments();
}
bool LLTextEditor::canLoadOrSaveToFile()
{
- return !mReadOnly;
+ return !mReadOnly;
}
S32 LLTextEditor::spacesPerTab()
{
- return SPACES_PER_TAB;
+ return SPACES_PER_TAB;
}
diff --git a/indra/llui/lltexteditor.h b/indra/llui/lltexteditor.h
index 658bfb9295..2bc4184ca8 100644
--- a/indra/llui/lltexteditor.h
+++ b/indra/llui/lltexteditor.h
@@ -48,316 +48,316 @@ class LLUICtrlFactory;
class LLScrollContainer;
class LLTextEditor :
- public LLTextBase,
- protected LLPreeditor
+ public LLTextBase,
+ protected LLPreeditor
{
public:
- struct Params : public LLInitParam::Block<Params, LLTextBase::Params>
- {
- Optional<std::string> default_text;
- Optional<LLTextValidate::validate_func_t, LLTextValidate::ValidateTextNamedFuncs> prevalidate_callback;
-
- Optional<bool> embedded_items,
- ignore_tab,
- commit_on_focus_lost,
- show_context_menu,
- show_emoji_helper,
- enable_tooltip_paste,
- auto_indent;
-
- //colors
- Optional<LLUIColor> default_color;
-
- Params();
- };
-
- void initFromParams(const Params&);
+ struct Params : public LLInitParam::Block<Params, LLTextBase::Params>
+ {
+ Optional<std::string> default_text;
+ Optional<LLTextValidate::validate_func_t, LLTextValidate::ValidateTextNamedFuncs> prevalidate_callback;
+
+ Optional<bool> embedded_items,
+ ignore_tab,
+ commit_on_focus_lost,
+ show_context_menu,
+ show_emoji_helper,
+ enable_tooltip_paste,
+ auto_indent;
+
+ //colors
+ Optional<LLUIColor> default_color;
+
+ Params();
+ };
+
+ void initFromParams(const Params&);
protected:
- LLTextEditor(const Params&);
- friend class LLUICtrlFactory;
+ LLTextEditor(const Params&);
+ friend class LLUICtrlFactory;
public:
- //
- // Constants
- //
- static const llwchar FIRST_EMBEDDED_CHAR = 0x100000;
- static const llwchar LAST_EMBEDDED_CHAR = 0x10ffff;
- static const S32 MAX_EMBEDDED_ITEMS = LAST_EMBEDDED_CHAR - FIRST_EMBEDDED_CHAR + 1;
+ //
+ // Constants
+ //
+ static const llwchar FIRST_EMBEDDED_CHAR = 0x100000;
+ static const llwchar LAST_EMBEDDED_CHAR = 0x10ffff;
+ static const S32 MAX_EMBEDDED_ITEMS = LAST_EMBEDDED_CHAR - FIRST_EMBEDDED_CHAR + 1;
- virtual ~LLTextEditor();
+ virtual ~LLTextEditor();
- typedef boost::signals2::signal<void (LLTextEditor* caller)> keystroke_signal_t;
+ typedef boost::signals2::signal<void (LLTextEditor* caller)> keystroke_signal_t;
- void setKeystrokeCallback(const keystroke_signal_t::slot_type& callback);
+ void setKeystrokeCallback(const keystroke_signal_t::slot_type& callback);
- void setParseHighlights(BOOL parsing) {mParseHighlights=parsing;}
+ void setParseHighlights(BOOL parsing) {mParseHighlights=parsing;}
- static S32 spacesPerTab();
+ static S32 spacesPerTab();
- void insertEmoji(llwchar emoji);
- void handleEmojiCommit(llwchar emoji);
+ void insertEmoji(llwchar emoji);
+ void handleEmojiCommit(llwchar emoji);
- // mousehandler overrides
- virtual BOOL handleMouseDown(S32 x, S32 y, MASK mask);
- virtual BOOL handleMouseUp(S32 x, S32 y, MASK mask);
- virtual BOOL handleRightMouseDown(S32 x, S32 y, MASK mask);
- virtual BOOL handleHover(S32 x, S32 y, MASK mask);
- virtual BOOL handleDoubleClick(S32 x, S32 y, MASK mask );
- virtual BOOL handleMiddleMouseDown(S32 x,S32 y,MASK mask);
+ // mousehandler overrides
+ virtual BOOL handleMouseDown(S32 x, S32 y, MASK mask);
+ virtual BOOL handleMouseUp(S32 x, S32 y, MASK mask);
+ virtual BOOL handleRightMouseDown(S32 x, S32 y, MASK mask);
+ virtual BOOL handleHover(S32 x, S32 y, MASK mask);
+ virtual BOOL handleDoubleClick(S32 x, S32 y, MASK mask );
+ virtual BOOL handleMiddleMouseDown(S32 x,S32 y,MASK mask);
- virtual BOOL handleKeyHere(KEY key, MASK mask );
- virtual BOOL handleUnicodeCharHere(llwchar uni_char);
+ virtual BOOL handleKeyHere(KEY key, MASK mask );
+ virtual BOOL handleUnicodeCharHere(llwchar uni_char);
- virtual void onMouseCaptureLost();
+ virtual void onMouseCaptureLost();
- // view overrides
- virtual void draw();
- virtual void onFocusReceived();
- virtual void onFocusLost();
- virtual void onCommit();
- virtual void setEnabled(BOOL enabled);
+ // view overrides
+ virtual void draw();
+ virtual void onFocusReceived();
+ virtual void onFocusLost();
+ virtual void onCommit();
+ virtual void setEnabled(BOOL enabled);
- // uictrl overrides
- virtual void clear();
- virtual void setFocus( BOOL b );
- virtual BOOL isDirty() const;
+ // uictrl overrides
+ virtual void clear();
+ virtual void setFocus( BOOL b );
+ virtual BOOL isDirty() const;
- // LLEditMenuHandler interface
- virtual void undo();
- virtual BOOL canUndo() const;
- virtual void redo();
- virtual BOOL canRedo() const;
+ // LLEditMenuHandler interface
+ virtual void undo();
+ virtual BOOL canUndo() const;
+ virtual void redo();
+ virtual BOOL canRedo() const;
- virtual void cut();
- virtual BOOL canCut() const;
- virtual void copy();
- virtual BOOL canCopy() const;
- virtual void paste();
- virtual BOOL canPaste() const;
+ virtual void cut();
+ virtual BOOL canCut() const;
+ virtual void copy();
+ virtual BOOL canCopy() const;
+ virtual void paste();
+ virtual BOOL canPaste() const;
- virtual void updatePrimary();
- virtual void copyPrimary();
- virtual void pastePrimary();
- virtual BOOL canPastePrimary() const;
+ virtual void updatePrimary();
+ virtual void copyPrimary();
+ virtual void pastePrimary();
+ virtual BOOL canPastePrimary() const;
- virtual void doDelete();
- virtual BOOL canDoDelete() const;
- virtual void selectAll();
- virtual BOOL canSelectAll() const;
+ virtual void doDelete();
+ virtual BOOL canDoDelete() const;
+ virtual void selectAll();
+ virtual BOOL canSelectAll() const;
- void selectByCursorPosition(S32 prev_cursor_pos, S32 next_cursor_pos);
+ void selectByCursorPosition(S32 prev_cursor_pos, S32 next_cursor_pos);
- virtual bool canLoadOrSaveToFile();
+ virtual bool canLoadOrSaveToFile();
- void selectNext(const std::string& search_text_in, BOOL case_insensitive, BOOL wrap = TRUE);
- BOOL replaceText(const std::string& search_text, const std::string& replace_text, BOOL case_insensitive, BOOL wrap = TRUE);
- void replaceTextAll(const std::string& search_text, const std::string& replace_text, BOOL case_insensitive);
+ void selectNext(const std::string& search_text_in, BOOL case_insensitive, BOOL wrap = TRUE);
+ BOOL replaceText(const std::string& search_text, const std::string& replace_text, BOOL case_insensitive, BOOL wrap = TRUE);
+ void replaceTextAll(const std::string& search_text, const std::string& replace_text, BOOL case_insensitive);
- // Undo/redo stack
- void blockUndo();
+ // Undo/redo stack
+ void blockUndo();
- // Text editing
- virtual void makePristine();
- BOOL isPristine() const;
- BOOL allowsEmbeddedItems() const { return mAllowEmbeddedItems; }
+ // Text editing
+ virtual void makePristine();
+ BOOL isPristine() const;
+ BOOL allowsEmbeddedItems() const { return mAllowEmbeddedItems; }
- // Autoreplace (formerly part of LLLineEditor)
- typedef boost::function<void(S32&, S32&, LLWString&, S32&, const LLWString&)> autoreplace_callback_t;
- autoreplace_callback_t mAutoreplaceCallback;
- void setAutoreplaceCallback(autoreplace_callback_t cb) { mAutoreplaceCallback = cb; }
+ // Autoreplace (formerly part of LLLineEditor)
+ typedef boost::function<void(S32&, S32&, LLWString&, S32&, const LLWString&)> autoreplace_callback_t;
+ autoreplace_callback_t mAutoreplaceCallback;
+ void setAutoreplaceCallback(autoreplace_callback_t cb) { mAutoreplaceCallback = cb; }
- /*virtual*/ void onSpellCheckPerformed();
+ /*virtual*/ void onSpellCheckPerformed();
- //
- // Text manipulation
- //
+ //
+ // Text manipulation
+ //
- // inserts text at cursor
- void insertText(const std::string &text);
- void insertText(LLWString &text);
+ // inserts text at cursor
+ void insertText(const std::string &text);
+ void insertText(LLWString &text);
- void appendWidget(const LLInlineViewSegment::Params& params, const std::string& text, bool allow_undo);
- // Non-undoable
- void setText(const LLStringExplicit &utf8str, const LLStyle::Params& input_params = LLStyle::Params());
+ void appendWidget(const LLInlineViewSegment::Params& params, const std::string& text, bool allow_undo);
+ // Non-undoable
+ void setText(const LLStringExplicit &utf8str, const LLStyle::Params& input_params = LLStyle::Params());
- // Removes text from the end of document
- // Does not change highlight or cursor position.
- void removeTextFromEnd(S32 num_chars);
+ // Removes text from the end of document
+ // Does not change highlight or cursor position.
+ void removeTextFromEnd(S32 num_chars);
- BOOL tryToRevertToPristineState();
+ BOOL tryToRevertToPristineState();
- void setCursorAndScrollToEnd();
+ void setCursorAndScrollToEnd();
- void getCurrentLineAndColumn( S32* line, S32* col, BOOL include_wordwrap );
+ void getCurrentLineAndColumn( S32* line, S32* col, BOOL include_wordwrap );
- // Hacky methods to make it into a word-wrapping, potentially scrolling,
- // read-only text box.
- void setCommitOnFocusLost(BOOL b) { mCommitOnFocusLost = b; }
+ // Hacky methods to make it into a word-wrapping, potentially scrolling,
+ // read-only text box.
+ void setCommitOnFocusLost(BOOL b) { mCommitOnFocusLost = b; }
- // Hack to handle Notecards
- virtual BOOL importBuffer(const char* buffer, S32 length );
- virtual BOOL exportBuffer(std::string& buffer );
+ // Hack to handle Notecards
+ virtual BOOL importBuffer(const char* buffer, S32 length );
+ virtual BOOL exportBuffer(std::string& buffer );
- const LLUUID& getSourceID() const { return mSourceID; }
+ const LLUUID& getSourceID() const { return mSourceID; }
- const LLTextSegmentPtr getPreviousSegment() const;
- const LLTextSegmentPtr getLastSegment() const;
- void getSelectedSegments(segment_vec_t& segments) const;
+ const LLTextSegmentPtr getPreviousSegment() const;
+ const LLTextSegmentPtr getLastSegment() const;
+ void getSelectedSegments(segment_vec_t& segments) const;
- void setShowContextMenu(bool show) { mShowContextMenu = show; }
- bool getShowContextMenu() const { return mShowContextMenu; }
+ void setShowContextMenu(bool show) { mShowContextMenu = show; }
+ bool getShowContextMenu() const { return mShowContextMenu; }
- void showEmojiHelper();
- void setShowEmojiHelper(bool show);
- bool getShowEmojiHelper() const { return mShowEmojiHelper; }
+ void showEmojiHelper();
+ void setShowEmojiHelper(bool show);
+ bool getShowEmojiHelper() const { return mShowEmojiHelper; }
- void setPassDelete(BOOL b) { mPassDelete = b; }
+ void setPassDelete(BOOL b) { mPassDelete = b; }
protected:
- void showContextMenu(S32 x, S32 y);
- void drawPreeditMarker();
+ void showContextMenu(S32 x, S32 y);
+ void drawPreeditMarker();
- void assignEmbedded(const std::string &s);
+ void assignEmbedded(const std::string &s);
- void removeCharOrTab();
+ void removeCharOrTab();
- void indentSelectedLines( S32 spaces );
- S32 indentLine( S32 pos, S32 spaces );
- void unindentLineBeforeCloseBrace();
+ void indentSelectedLines( S32 spaces );
+ S32 indentLine( S32 pos, S32 spaces );
+ void unindentLineBeforeCloseBrace();
- virtual BOOL handleSpecialKey(const KEY key, const MASK mask);
- BOOL handleNavigationKey(const KEY key, const MASK mask);
- BOOL handleSelectionKey(const KEY key, const MASK mask);
- BOOL handleControlKey(const KEY key, const MASK mask);
+ virtual BOOL handleSpecialKey(const KEY key, const MASK mask);
+ BOOL handleNavigationKey(const KEY key, const MASK mask);
+ BOOL handleSelectionKey(const KEY key, const MASK mask);
+ BOOL handleControlKey(const KEY key, const MASK mask);
- BOOL selectionContainsLineBreaks();
- void deleteSelection(BOOL transient_operation);
+ BOOL selectionContainsLineBreaks();
+ void deleteSelection(BOOL transient_operation);
- S32 prevWordPos(S32 cursorPos) const;
- S32 nextWordPos(S32 cursorPos) const;
+ S32 prevWordPos(S32 cursorPos) const;
+ S32 nextWordPos(S32 cursorPos) const;
- void autoIndent();
+ void autoIndent();
- void findEmbeddedItemSegments(S32 start, S32 end);
- void getSegmentsInRange(segment_vec_t& segments, S32 start, S32 end, bool include_partial) const;
+ void findEmbeddedItemSegments(S32 start, S32 end);
+ void getSegmentsInRange(segment_vec_t& segments, S32 start, S32 end, bool include_partial) const;
- virtual llwchar pasteEmbeddedItem(llwchar ext_char) { return ext_char; }
+ virtual llwchar pasteEmbeddedItem(llwchar ext_char) { return ext_char; }
- // Here's the method that takes and applies text commands.
- S32 execute(TextCmd* cmd);
+ // Here's the method that takes and applies text commands.
+ S32 execute(TextCmd* cmd);
- // Undoable operations
- void addChar(llwchar c); // at mCursorPos
- S32 addChar(S32 pos, llwchar wc);
+ // Undoable operations
+ void addChar(llwchar c); // at mCursorPos
+ S32 addChar(S32 pos, llwchar wc);
public:
- void addLineBreakChar(BOOL group_together = FALSE);
+ void addLineBreakChar(BOOL group_together = FALSE);
protected:
- S32 overwriteChar(S32 pos, llwchar wc);
- void removeChar();
- S32 removeChar(S32 pos);
- S32 insert(S32 pos, const LLWString &wstr, bool group_with_next_op, LLTextSegmentPtr segment);
- S32 remove(S32 pos, S32 length, bool group_with_next_op);
-
- void tryToShowEmojiHelper();
- void focusLostHelper();
- void updateAllowingLanguageInput();
- BOOL hasPreeditString() const;
-
- // Overrides LLPreeditor
- virtual void resetPreedit();
- virtual void updatePreedit(const LLWString &preedit_string,
- const segment_lengths_t &preedit_segment_lengths, const standouts_t &preedit_standouts, S32 caret_position);
- virtual void markAsPreedit(S32 position, S32 length);
- virtual void getPreeditRange(S32 *position, S32 *length) const;
- virtual void getSelectionRange(S32 *position, S32 *length) const;
- virtual BOOL getPreeditLocation(S32 query_offset, LLCoordGL *coord, LLRect *bounds, LLRect *control) const;
- virtual S32 getPreeditFontSize() const;
- virtual LLWString getPreeditString() const { return getWText(); }
- //
- // Protected data
- //
- // Probably deserves serious thought to hiding as many of these
- // as possible behind protected accessor methods.
- //
-
- // Use these to determine if a click on an embedded item is a drag or not.
- S32 mMouseDownX;
- S32 mMouseDownY;
-
- LLWString mPreeditWString;
- LLWString mPreeditOverwrittenWString;
- std::vector<S32> mPreeditPositions;
- std::vector<BOOL> mPreeditStandouts;
+ S32 overwriteChar(S32 pos, llwchar wc);
+ void removeChar();
+ S32 removeChar(S32 pos);
+ S32 insert(S32 pos, const LLWString &wstr, bool group_with_next_op, LLTextSegmentPtr segment);
+ S32 remove(S32 pos, S32 length, bool group_with_next_op);
+
+ void tryToShowEmojiHelper();
+ void focusLostHelper();
+ void updateAllowingLanguageInput();
+ BOOL hasPreeditString() const;
+
+ // Overrides LLPreeditor
+ virtual void resetPreedit();
+ virtual void updatePreedit(const LLWString &preedit_string,
+ const segment_lengths_t &preedit_segment_lengths, const standouts_t &preedit_standouts, S32 caret_position);
+ virtual void markAsPreedit(S32 position, S32 length);
+ virtual void getPreeditRange(S32 *position, S32 *length) const;
+ virtual void getSelectionRange(S32 *position, S32 *length) const;
+ virtual BOOL getPreeditLocation(S32 query_offset, LLCoordGL *coord, LLRect *bounds, LLRect *control) const;
+ virtual S32 getPreeditFontSize() const;
+ virtual LLWString getPreeditString() const { return getWText(); }
+ //
+ // Protected data
+ //
+ // Probably deserves serious thought to hiding as many of these
+ // as possible behind protected accessor methods.
+ //
+
+ // Use these to determine if a click on an embedded item is a drag or not.
+ S32 mMouseDownX;
+ S32 mMouseDownY;
+
+ LLWString mPreeditWString;
+ LLWString mPreeditOverwrittenWString;
+ std::vector<S32> mPreeditPositions;
+ std::vector<BOOL> mPreeditStandouts;
protected:
- LLUIColor mDefaultColor;
+ LLUIColor mDefaultColor;
- bool mAutoIndent;
- bool mParseOnTheFly;
+ bool mAutoIndent;
+ bool mParseOnTheFly;
- void updateLinkSegments();
- void keepSelectionOnReturn(bool keep) { mKeepSelectionOnReturn = keep; }
- class LLViewBorder* mBorder;
+ void updateLinkSegments();
+ void keepSelectionOnReturn(bool keep) { mKeepSelectionOnReturn = keep; }
+ class LLViewBorder* mBorder;
private:
- //
- // Methods
- //
- void pasteHelper(bool is_primary);
- void cleanStringForPaste(LLWString & clean_string);
+ //
+ // Methods
+ //
+ void pasteHelper(bool is_primary);
+ void cleanStringForPaste(LLWString & clean_string);
public:
- template <typename STRINGTYPE>
- void pasteTextWithLinebreaks(const STRINGTYPE& clean_string)
- {
- pasteTextWithLinebreaks<LLWString>(ll_convert(clean_string));
- }
- template <>
- void pasteTextWithLinebreaks<LLWString>(const LLWString & clean_string);
+ template <typename STRINGTYPE>
+ void pasteTextWithLinebreaks(const STRINGTYPE& clean_string)
+ {
+ pasteTextWithLinebreaks<LLWString>(ll_convert(clean_string));
+ }
+ template <>
+ void pasteTextWithLinebreaks<LLWString>(const LLWString & clean_string);
private:
- void onKeyStroke();
+ void onKeyStroke();
- // Concrete TextCmd sub-classes used by the LLTextEditor base class
- class TextCmdInsert;
- class TextCmdAddChar;
- class TextCmdOverwriteChar;
- class TextCmdRemove;
+ // Concrete TextCmd sub-classes used by the LLTextEditor base class
+ class TextCmdInsert;
+ class TextCmdAddChar;
+ class TextCmdOverwriteChar;
+ class TextCmdRemove;
- BOOL mBaseDocIsPristine;
- TextCmd* mPristineCmd;
+ BOOL mBaseDocIsPristine;
+ TextCmd* mPristineCmd;
- TextCmd* mLastCmd;
+ TextCmd* mLastCmd;
- typedef std::deque<TextCmd*> undo_stack_t;
- undo_stack_t mUndoStack;
+ typedef std::deque<TextCmd*> undo_stack_t;
+ undo_stack_t mUndoStack;
- BOOL mTabsToNextField; // if true, tab moves focus to next field, else inserts spaces
- BOOL mCommitOnFocusLost;
- BOOL mTakesFocus;
+ BOOL mTabsToNextField; // if true, tab moves focus to next field, else inserts spaces
+ BOOL mCommitOnFocusLost;
+ BOOL mTakesFocus;
- BOOL mAllowEmbeddedItems;
- bool mShowContextMenu;
- bool mShowEmojiHelper;
- bool mEnableTooltipPaste;
- bool mPassDelete;
- bool mKeepSelectionOnReturn; // disabling of removing selected text after pressing of Enter
+ BOOL mAllowEmbeddedItems;
+ bool mShowContextMenu;
+ bool mShowEmojiHelper;
+ bool mEnableTooltipPaste;
+ bool mPassDelete;
+ bool mKeepSelectionOnReturn; // disabling of removing selected text after pressing of Enter
- LLUUID mSourceID;
+ LLUUID mSourceID;
- LLCoordGL mLastIMEPosition; // Last position of the IME editor
+ LLCoordGL mLastIMEPosition; // Last position of the IME editor
- keystroke_signal_t mKeystrokeSignal;
- LLTextValidate::validate_func_t mPrevalidateFunc;
+ keystroke_signal_t mKeystrokeSignal;
+ LLTextValidate::validate_func_t mPrevalidateFunc;
- LLHandle<LLContextMenu> mContextMenuHandle;
+ LLHandle<LLContextMenu> mContextMenuHandle;
}; // end class LLTextEditor
// Build time optimization, generate once in .cpp file
#ifndef LLTEXTEDITOR_CPP
extern template class LLTextEditor* LLView::getChild<class LLTextEditor>(
- const std::string& name, BOOL recurse) const;
+ const std::string& name, BOOL recurse) const;
#endif
#endif // LL_TEXTEDITOR_H
--
cgit v1.2.3