Replace BOOL with bool in llwindow and dependent classes

69 files changed, 728 insertions, 728 deletions

diff --git a/indra/llui/llaccordionctrl.cpp b/indra/llui/llaccordionctrl.cpp
index 0a82bed896..a5417d054e 100644
--- a/indra/llui/llaccordionctrl.cpp
+++ b/indra/llui/llaccordionctrl.cpp
@@ -199,7 +199,7 @@ void LLAccordionCtrl::reshape(S32 width, S32 height, BOOL called_from_parent)
 }
 
 //---------------------------------------------------------------------------------
-BOOL LLAccordionCtrl::handleRightMouseDown(S32 x, S32 y, MASK mask)
+bool LLAccordionCtrl::handleRightMouseDown(S32 x, S32 y, MASK mask)
 {
 	return LLPanel::handleRightMouseDown(x, y, mask);
 }
@@ -552,13 +552,13 @@ void LLAccordionCtrl::arrange()
 
 //---------------------------------------------------------------------------------
 
-BOOL LLAccordionCtrl::handleScrollWheel(S32 x, S32 y, S32 clicks)
+bool LLAccordionCtrl::handleScrollWheel(S32 x, S32 y, S32 clicks)
 {
 	if (LLPanel::handleScrollWheel(x, y, clicks))
-		return TRUE;
+		return true;
 	if (mScrollbar->getVisible() && mScrollbar->handleScrollWheel(0, 0, clicks))
-		return TRUE;
-	return FALSE;
+		return true;
+	return false;
 }
 
 BOOL LLAccordionCtrl::handleKeyHere(KEY key, MASK mask)
diff --git a/indra/llui/llaccordionctrl.h b/indra/llui/llaccordionctrl.h
index 6a1989afba..ba5a45759f 100644
--- a/indra/llui/llaccordionctrl.h
+++ b/indra/llui/llaccordionctrl.h
@@ -90,8 +90,8 @@ public:
 
 	virtual BOOL postBuild();
 	
-	virtual BOOL handleRightMouseDown	( S32 x, S32 y, MASK mask); 
-	virtual BOOL handleScrollWheel		( S32 x, S32 y, S32 clicks );
+	virtual bool handleRightMouseDown	( S32 x, S32 y, MASK mask);
+	virtual bool handleScrollWheel		( S32 x, S32 y, S32 clicks );
 	virtual BOOL handleKeyHere			(KEY key, MASK mask);
 	virtual BOOL handleDragAndDrop		(S32 x, S32 y, MASK mask, BOOL drop,
 										 EDragAndDropType cargo_type,
diff --git a/indra/llui/llaccordionctrltab.cpp b/indra/llui/llaccordionctrltab.cpp
index 20da568746..c3787acec2 100644
--- a/indra/llui/llaccordionctrltab.cpp
+++ b/indra/llui/llaccordionctrltab.cpp
@@ -482,7 +482,7 @@ void LLAccordionCtrlTab::onUpdateScrollToChild(const LLUICtrl *cntrl)
     LLUICtrl::onUpdateScrollToChild(cntrl);
 }
 
-BOOL LLAccordionCtrlTab::handleMouseDown(S32 x, S32 y, MASK mask)
+bool LLAccordionCtrlTab::handleMouseDown(S32 x, S32 y, MASK mask)
 {
 	if (mCollapsible && mHeaderVisible && mCanOpenClose)
 	{
@@ -493,13 +493,13 @@ BOOL LLAccordionCtrlTab::handleMouseDown(S32 x, S32 y, MASK mask)
 
 			// Reset stored state
 			mWasStateStored = false;
-			return TRUE;
+			return true;
 		}
 	}
 	return LLUICtrl::handleMouseDown(x,y,mask);
 }
 
-BOOL LLAccordionCtrlTab::handleMouseUp(S32 x, S32 y, MASK mask)
+bool LLAccordionCtrlTab::handleMouseUp(S32 x, S32 y, MASK mask)
 {
 	return LLUICtrl::handleMouseUp(x,y,mask);
 }
@@ -820,7 +820,7 @@ BOOL LLAccordionCtrlTab::handleKey(KEY key, MASK mask, BOOL called_from_parent)
 	if ((key == KEY_RETURN) && mask == MASK_NONE)
 	{
 		changeOpenClose(getDisplayChildren());
-		return TRUE;
+		return true;
 	}
 
 	if ((key == KEY_ADD || key == KEY_RIGHT) && mask == MASK_NONE)
@@ -828,7 +828,7 @@ BOOL LLAccordionCtrlTab::handleKey(KEY key, MASK mask, BOOL called_from_parent)
 		if (!getDisplayChildren())
 		{
 			changeOpenClose(getDisplayChildren());
-			return TRUE;
+			return true;
 		}
 	}
 
@@ -837,7 +837,7 @@ BOOL LLAccordionCtrlTab::handleKey(KEY key, MASK mask, BOOL called_from_parent)
 		if (getDisplayChildren())
 		{
 			changeOpenClose(getDisplayChildren());
-			return TRUE;
+			return true;
 		}
 	}
 
@@ -853,7 +853,7 @@ BOOL LLAccordionCtrlTab::handleKey(KEY key, MASK mask, BOOL called_from_parent)
 		{
 			getAccordionView()->notify(LLSD().with("action", "select_first"));
 		}
-		return TRUE;
+		return true;
 	}
 
 	if (key == KEY_UP && mask == MASK_NONE)
@@ -862,7 +862,7 @@ BOOL LLAccordionCtrlTab::handleKey(KEY key, MASK mask, BOOL called_from_parent)
 
 		// we're processing notifyParent so let call parent directly
 		getParent()->notifyParent(LLSD().with("action", "select_prev"));
-		return TRUE;
+		return true;
 	}
 
 	return LLUICtrl::handleKey(key, mask, called_from_parent);
@@ -1097,7 +1097,7 @@ void LLAccordionCtrlTab::ctrlSetLeftTopAndSize(LLView* panel, S32 left, S32 top,
 	panel->setRect(panel_rect);
 }
 
-BOOL LLAccordionCtrlTab::handleToolTip(S32 x, S32 y, MASK mask)
+bool LLAccordionCtrlTab::handleToolTip(S32 x, S32 y, MASK mask)
 {
 	//header may be not the first child but we need to process it first
 	if (y >= (getRect().getHeight() - HEADER_HEIGHT - HEADER_HEIGHT / 2))
@@ -1105,22 +1105,22 @@ BOOL LLAccordionCtrlTab::handleToolTip(S32 x, S32 y, MASK mask)
 		//inside tab header
 		//fix for EXT-6619
 		mHeader->handleToolTip(x, y, mask);
-		return TRUE;
+		return true;
 	}
 	return LLUICtrl::handleToolTip(x, y, mask);
 }
 
-BOOL LLAccordionCtrlTab::handleScrollWheel(S32 x, S32 y, S32 clicks)
+bool LLAccordionCtrlTab::handleScrollWheel(S32 x, S32 y, S32 clicks)
 {
 	if (LLUICtrl::handleScrollWheel(x, y, clicks))
 	{
-		return TRUE;
+		return true;
 	}
 
 	if (mScrollbar && mScrollbar->getVisible() && mScrollbar->handleScrollWheel(0, 0, clicks))
 	{
-		return TRUE;
+		return true;
 	}
 
-	return FALSE;
+	return false;
 }
diff --git a/indra/llui/llaccordionctrltab.h b/indra/llui/llaccordionctrltab.h
index 896a34cac4..161f5c6361 100644
--- a/indra/llui/llaccordionctrltab.h
+++ b/indra/llui/llaccordionctrltab.h
@@ -162,13 +162,13 @@ public:
 	virtual void onUpdateScrollToChild(const LLUICtrl * cntrl);
 
 	// Changes expand/collapse state and triggers expand/collapse callbacks
-	virtual BOOL handleMouseDown(S32 x, S32 y, MASK mask);
+	virtual bool handleMouseDown(S32 x, S32 y, MASK mask);
 
-	virtual BOOL handleMouseUp(S32 x, S32 y, MASK mask);
+	virtual bool handleMouseUp(S32 x, S32 y, MASK mask);
 	virtual BOOL handleKey(KEY key, MASK mask, BOOL called_from_parent);
 
-	virtual BOOL handleToolTip(S32 x, S32 y, MASK mask);
-	virtual BOOL handleScrollWheel( S32 x, S32 y, S32 clicks );
+	virtual bool handleToolTip(S32 x, S32 y, MASK mask);
+	virtual bool handleScrollWheel( S32 x, S32 y, S32 clicks );
 
 
 	virtual bool addChild(LLView* child, S32 tab_group = 0 );
diff --git a/indra/llui/llbutton.cpp b/indra/llui/llbutton.cpp
index 49d275997a..d8589444fb 100644
--- a/indra/llui/llbutton.cpp
+++ b/indra/llui/llbutton.cpp
@@ -393,9 +393,9 @@ BOOL LLButton::postBuild()
 	return LLUICtrl::postBuild();
 }
 
-BOOL LLButton::handleUnicodeCharHere(llwchar uni_char)
+bool LLButton::handleUnicodeCharHere(llwchar uni_char)
 {
-	BOOL handled = FALSE;
+	bool handled = false;
 	if(' ' == uni_char 
 		&& !gKeyboard->getKeyRepeated(' '))
 	{
@@ -406,9 +406,9 @@ BOOL LLButton::handleUnicodeCharHere(llwchar uni_char)
 
 		LLUICtrl::onCommit();
 		
-		handled = TRUE;		
+		handled = true;
 	}
-	return handled;	
+	return handled;
 }
 
 BOOL LLButton::handleKeyHere(KEY key, MASK mask )
@@ -429,7 +429,7 @@ BOOL LLButton::handleKeyHere(KEY key, MASK mask )
 }
 
 
-BOOL LLButton::handleMouseDown(S32 x, S32 y, MASK mask)
+bool LLButton::handleMouseDown(S32 x, S32 y, MASK mask)
 {
 	if (!childrenHandleMouseDown(x, y, mask))
 	{
@@ -438,7 +438,7 @@ BOOL LLButton::handleMouseDown(S32 x, S32 y, MASK mask)
 
 		if (hasTabStop() && !getIsChrome())
 		{
-			setFocus(TRUE);
+			setFocus(true);
 		}
 
 		if (!mFunctionName.empty())
@@ -469,11 +469,11 @@ BOOL LLButton::handleMouseDown(S32 x, S32 y, MASK mask)
 			make_ui_sound("UISndClick");
 		}
 	}
-	return TRUE;
+	return true;
 }
 
 
-BOOL LLButton::handleMouseUp(S32 x, S32 y, MASK mask)
+bool LLButton::handleMouseUp(S32 x, S32 y, MASK mask)
 {
 	// We only handle the click if the click both started and ended within us
 	if( hasMouseCapture() )
@@ -518,10 +518,10 @@ BOOL LLButton::handleMouseUp(S32 x, S32 y, MASK mask)
 		childrenHandleMouseUp(x, y, mask);
 	}
 
-	return TRUE;
+	return true;
 }
 
-BOOL	LLButton::handleRightMouseDown(S32 x, S32 y, MASK mask)
+bool	LLButton::handleRightMouseDown(S32 x, S32 y, MASK mask)
 {
 	if (mHandleRightMouse && !childrenHandleRightMouseDown(x, y, mask))
 	{
@@ -530,7 +530,7 @@ BOOL	LLButton::handleRightMouseDown(S32 x, S32 y, MASK mask)
 
 		if (hasTabStop() && !getIsChrome())
 		{
-			setFocus(TRUE);
+			setFocus(true);
 		}
 
 //		if (pointInView(x, y))
@@ -543,10 +543,10 @@ BOOL	LLButton::handleRightMouseDown(S32 x, S32 y, MASK mask)
 		// if they are not mouse opaque.
 	}
 
-	return TRUE;
+	return true;
 }
 
-BOOL	LLButton::handleRightMouseUp(S32 x, S32 y, MASK mask)
+bool	LLButton::handleRightMouseUp(S32 x, S32 y, MASK mask)
 {
 	if (mHandleRightMouse)
 	{
@@ -572,7 +572,7 @@ BOOL	LLButton::handleRightMouseUp(S32 x, S32 y, MASK mask)
 		// but this might change the mouse handling of existing buttons in a bad way.
 		// if they are not mouse opaque.
 	}
-	return TRUE;
+	return true;
 }
 
 void LLButton::onMouseLeave(S32 x, S32 y, MASK mask)
@@ -587,11 +587,11 @@ void LLButton::setHighlight(bool b)
 	mNeedsHighlight = b;
 }
 
-BOOL LLButton::handleHover(S32 x, S32 y, MASK mask)
+bool LLButton::handleHover(S32 x, S32 y, MASK mask)
 {
 	if (isInEnabledChain() 
 		&& (!gFocusMgr.getMouseCapture() || gFocusMgr.getMouseCapture() == this))
-		mNeedsHighlight = TRUE;
+		mNeedsHighlight = true;
 
 	if (!childrenHandleHover(x, y, mask))
 	{
@@ -610,7 +610,7 @@ BOOL LLButton::handleHover(S32 x, S32 y, MASK mask)
 		getWindow()->setCursor(UI_CURSOR_ARROW);
 		LL_DEBUGS("UserInput") << "hover handled by " << getName() << LL_ENDL;
 	}
-	return TRUE;
+	return true;
 }
 
 void LLButton::getOverlayImageSize(S32& overlay_width, S32& overlay_height)
@@ -1308,7 +1308,7 @@ void LLButton::resetMouseDownTimer()
 	mMouseDownTimer.reset();
 }
 
-BOOL LLButton::handleDoubleClick(S32 x, S32 y, MASK mask)
+bool LLButton::handleDoubleClick(S32 x, S32 y, MASK mask)
 {
 	// just treat a double click as a second click
 	return handleMouseDown(x, y, mask);
diff --git a/indra/llui/llbutton.h b/indra/llui/llbutton.h
index ccd31e90c0..0c99f6a343 100644
--- a/indra/llui/llbutton.h
+++ b/indra/llui/llbutton.h
@@ -155,14 +155,14 @@ public:
 
 	void			addImageAttributeToXML(LLXMLNodePtr node, const std::string& imageName,
 										const LLUUID&	imageID,const std::string&	xmlTagName) const;
-	virtual BOOL	handleUnicodeCharHere(llwchar uni_char);
+	virtual bool	handleUnicodeCharHere(llwchar uni_char);
 	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	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	handleDoubleClick(S32 x, S32 y, MASK mask);
+	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 bool	handleRightMouseDown(S32 x, S32 y, MASK mask);
+	virtual bool	handleRightMouseUp(S32 x, S32 y, MASK mask);
+	virtual bool	handleDoubleClick(S32 x, S32 y, MASK mask);
 	virtual void	draw();
 	/*virtual*/ BOOL postBuild();
 
diff --git a/indra/llui/llcombobox.cpp b/indra/llui/llcombobox.cpp
index 9ca05a16f3..81031508ec 100644
--- a/indra/llui/llcombobox.cpp
+++ b/indra/llui/llcombobox.cpp
@@ -782,13 +782,13 @@ void LLComboBox::onItemSelected(const LLSD& data)
 	onCommit();
 }
 
-BOOL LLComboBox::handleToolTip(S32 x, S32 y, MASK mask)
+bool LLComboBox::handleToolTip(S32 x, S32 y, MASK mask)
 {
     std::string tool_tip;
 
 	if(LLUICtrl::handleToolTip(x, y, mask))
 	{
-		return TRUE;
+		return true;
 	}
 	
 	tool_tip = getToolTip();
@@ -803,7 +803,7 @@ BOOL LLComboBox::handleToolTip(S32 x, S32 y, MASK mask)
 			.message(tool_tip)
 			.sticky_rect(calcScreenRect()));
 	}
-	return TRUE;
+	return true;
 }
 
 BOOL LLComboBox::handleKeyHere(KEY key, MASK mask)
@@ -852,9 +852,9 @@ BOOL LLComboBox::handleKeyHere(KEY key, MASK mask)
 	return result;
 }
 
-BOOL LLComboBox::handleUnicodeCharHere(llwchar uni_char)
+bool LLComboBox::handleUnicodeCharHere(llwchar uni_char)
 {
-	BOOL result = FALSE;
+	bool result = false;
 	if (gFocusMgr.childHasKeyboardFocus(this))
 	{
 		// space bar just shows the list
diff --git a/indra/llui/llcombobox.h b/indra/llui/llcombobox.h
index cac8850a25..d87ce9189e 100644
--- a/indra/llui/llcombobox.h
+++ b/indra/llui/llcombobox.h
@@ -111,9 +111,9 @@ public:
 	// LLView interface
 	virtual void	onFocusLost();
 
-	virtual BOOL	handleToolTip(S32 x, S32 y, MASK mask);
+	virtual bool	handleToolTip(S32 x, S32 y, MASK mask);
 	virtual BOOL	handleKeyHere(KEY key, MASK mask);
-	virtual BOOL	handleUnicodeCharHere(llwchar uni_char);
+	virtual bool	handleUnicodeCharHere(llwchar uni_char);
 
 	// LLUICtrl interface
 	virtual void	clear();					// select nothing
diff --git a/indra/llui/llcontainerview.cpp b/indra/llui/llcontainerview.cpp
index 727fbe850e..415cdced4d 100644
--- a/indra/llui/llcontainerview.cpp
+++ b/indra/llui/llcontainerview.cpp
@@ -74,14 +74,14 @@ bool LLContainerView::addChild(LLView* child, S32 tab_group)
 	return res;
 }
 
-BOOL LLContainerView::handleDoubleClick(S32 x, S32 y, MASK mask)
+bool LLContainerView::handleDoubleClick(S32 x, S32 y, MASK mask)
 {
 	return handleMouseDown(x, y, mask);
 }
 
-BOOL LLContainerView::handleMouseDown(S32 x, S32 y, MASK mask)
+bool LLContainerView::handleMouseDown(S32 x, S32 y, MASK mask)
 {
-	BOOL handled = FALSE;
+	bool handled = false;
 	if (mDisplayChildren)
 	{
 		handled = (LLView::childrenHandleMouseDown(x, y, mask) != NULL);
@@ -92,15 +92,15 @@ BOOL LLContainerView::handleMouseDown(S32 x, S32 y, MASK mask)
 		{
 			setDisplayChildren(!mDisplayChildren);
 			reshape(getRect().getWidth(), getRect().getHeight(), FALSE);
-			handled = TRUE;
+			handled = true;
 		}
 	}
 	return handled;
 }
 
-BOOL LLContainerView::handleMouseUp(S32 x, S32 y, MASK mask)
+bool LLContainerView::handleMouseUp(S32 x, S32 y, MASK mask)
 {
-	BOOL handled = FALSE;
+	bool handled = false;
 	if (mDisplayChildren)
 	{
 		handled = (LLView::childrenHandleMouseUp(x, y, mask) != NULL);
diff --git a/indra/llui/llcontainerview.h b/indra/llui/llcontainerview.h
index 99267d978a..f439689ceb 100644
--- a/indra/llui/llcontainerview.h
+++ b/indra/llui/llcontainerview.h
@@ -68,9 +68,9 @@ public:
 	/*virtual*/ BOOL postBuild();
 	/*virtual*/ bool addChild(LLView* view, S32 tab_group = 0);
 	
-	/*virtual*/ BOOL handleDoubleClick(S32 x, S32 y, MASK mask);
-	/*virtual*/ BOOL handleMouseDown(S32 x, S32 y, MASK mask);
-	/*virtual*/ BOOL handleMouseUp(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool handleDoubleClick(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool handleMouseDown(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool handleMouseUp(S32 x, S32 y, MASK mask);
 
 	/*virtual*/ void draw();
 	/*virtual*/ void reshape(S32 width, S32 height, BOOL called_from_parent = TRUE);
diff --git a/indra/llui/lldraghandle.cpp b/indra/llui/lldraghandle.cpp
index 220f5ee825..b2e342411c 100644
--- a/indra/llui/lldraghandle.cpp
+++ b/indra/llui/lldraghandle.cpp
@@ -271,7 +271,7 @@ void LLDragHandleLeft::reshape(S32 width, S32 height, BOOL called_from_parent)
 // UI event handling
 //-------------------------------------------------------------
 
-BOOL LLDragHandle::handleMouseDown(S32 x, S32 y, MASK mask)
+bool LLDragHandle::handleMouseDown(S32 x, S32 y, MASK mask)
 {
 	// Route future Mouse messages here preemptively.  (Release on mouse up.)
 	// No handler needed for focus lost since this clas has no state that depends on it.
@@ -282,11 +282,11 @@ BOOL LLDragHandle::handleMouseDown(S32 x, S32 y, MASK mask)
 	mLastMouseScreenY = mDragLastScreenY;
 
 	// Note: don't pass on to children
-	return TRUE;
+	return true;
 }
 
 
-BOOL LLDragHandle::handleMouseUp(S32 x, S32 y, MASK mask)
+bool LLDragHandle::handleMouseUp(S32 x, S32 y, MASK mask)
 {
 	if( hasMouseCapture() )
 	{
@@ -295,13 +295,13 @@ BOOL LLDragHandle::handleMouseUp(S32 x, S32 y, MASK mask)
 	}
 
 	// Note: don't pass on to children
-	return TRUE;
+	return true;
 }
 
 
-BOOL LLDragHandle::handleHover(S32 x, S32 y, MASK mask)
+bool LLDragHandle::handleHover(S32 x, S32 y, MASK mask)
 {
-	BOOL	handled = FALSE;
+	bool	handled = false;
 
 	// We only handle the click if the click both started and ended within us
 	if( hasMouseCapture() )
@@ -324,11 +324,11 @@ BOOL LLDragHandle::handleHover(S32 x, S32 y, MASK mask)
 				delta_y >= SLOP)
 			{
 				parent->setDocked(false, false);
-				return TRUE;
+				return true;
 			}
 			else
 			{
-				return FALSE;
+				return false;
 			}
 		}
 
@@ -367,13 +367,13 @@ BOOL LLDragHandle::handleHover(S32 x, S32 y, MASK mask)
 
 		getWindow()->setCursor(UI_CURSOR_ARROW);
 		LL_DEBUGS("UserInput") << "hover handled by " << getName() << " (active)" <<LL_ENDL;		
-		handled = TRUE;
+		handled = true;
 	}
 	else
 	{
 		getWindow()->setCursor(UI_CURSOR_ARROW);
 		LL_DEBUGS("UserInput") << "hover handled by " << getName() << " (inactive)" << LL_ENDL;		
-		handled = TRUE;
+		handled = true;
 	}
 
 	// Note: don't pass on to children
diff --git a/indra/llui/lldraghandle.h b/indra/llui/lldraghandle.h
index e095e577b1..7f6ae47201 100644
--- a/indra/llui/lldraghandle.h
+++ b/indra/llui/lldraghandle.h
@@ -72,9 +72,9 @@ public:
 	virtual void	setTitle( const std::string& title ) = 0;
 	virtual std::string	getTitle() const = 0;
 
-	virtual BOOL	handleHover(S32 x, S32 y, MASK mask);
-	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 bool	handleMouseDown(S32 x, S32 y, MASK mask);
+	virtual bool	handleMouseUp(S32 x, S32 y, MASK mask);
 
 protected:
 	LLDragHandle(const Params&);
diff --git a/indra/llui/llfloater.cpp b/indra/llui/llfloater.cpp
index 2303cd24b7..e90dab1a99 100644
--- a/indra/llui/llfloater.cpp
+++ b/indra/llui/llfloater.cpp
@@ -1561,17 +1561,17 @@ BOOL LLFloater::offerClickToButton(S32 x, S32 y, MASK mask, EFloaterButton index
 	return FALSE;
 }
 
-BOOL LLFloater::handleScrollWheel(S32 x, S32 y, S32 clicks)
+bool LLFloater::handleScrollWheel(S32 x, S32 y, S32 clicks)
 {
 	LLPanel::handleScrollWheel(x,y,clicks);
-	return TRUE;//always
+	return true;//always
 }
 
 // virtual
-BOOL LLFloater::handleMouseUp(S32 x, S32 y, MASK mask)
+bool LLFloater::handleMouseUp(S32 x, S32 y, MASK mask)
 {
 	LL_DEBUGS() << "LLFloater::handleMouseUp calling LLPanel (really LLView)'s handleMouseUp (first initialized xui to: " << getPathname() << " )" << LL_ENDL;
-	BOOL handled = LLPanel::handleMouseUp(x,y,mask); // Not implemented in LLPanel so this actually calls LLView
+	bool handled = LLPanel::handleMouseUp(x,y,mask); // Not implemented in LLPanel so this actually calls LLView
 	if (handled) {
 		LLViewerEventRecorder::instance().updateMouseEventInfo(x,y,-55,-55,getPathname());
 	}
@@ -1579,7 +1579,7 @@ BOOL LLFloater::handleMouseUp(S32 x, S32 y, MASK mask)
 }
 
 // virtual
-BOOL LLFloater::handleMouseDown(S32 x, S32 y, MASK mask)
+bool LLFloater::handleMouseDown(S32 x, S32 y, MASK mask)
 {
 	if( mMinimized )
 	{
@@ -1587,19 +1587,19 @@ BOOL LLFloater::handleMouseDown(S32 x, S32 y, MASK mask)
 		// Note: this block and the offerClickToButton helper method can be removed
 		// because the parent container will handle it for us but we'll keep it here
 		// for safety until after reworking the panel code to manage hidden children.
-		if(offerClickToButton(x, y, mask, BUTTON_CLOSE)) return TRUE;
-		if(offerClickToButton(x, y, mask, BUTTON_RESTORE)) return TRUE;
-		if(offerClickToButton(x, y, mask, BUTTON_TEAR_OFF)) return TRUE;
-		if(offerClickToButton(x, y, mask, BUTTON_DOCK)) return TRUE;
+		if(offerClickToButton(x, y, mask, BUTTON_CLOSE)) return true;
+		if(offerClickToButton(x, y, mask, BUTTON_RESTORE)) return true;
+		if(offerClickToButton(x, y, mask, BUTTON_TEAR_OFF)) return true;
+		if(offerClickToButton(x, y, mask, BUTTON_DOCK)) return true;
 
-		setFrontmost(TRUE, FALSE);
+		setFrontmost(true, false);
 		// Otherwise pass to drag handle for movement
 		return mDragHandle->handleMouseDown(x, y, mask);
 	}
 	else
 	{
 		bringToFront( x, y );
-		BOOL handled = LLPanel::handleMouseDown( x, y, mask ); 
+		bool handled = LLPanel::handleMouseDown( x, y, mask );
 		if (handled) {
 			LLViewerEventRecorder::instance().updateMouseEventInfo(x,y,-55,-55,getPathname()); 
 		}
@@ -1608,14 +1608,14 @@ BOOL LLFloater::handleMouseDown(S32 x, S32 y, MASK mask)
 }
 
 // virtual
-BOOL LLFloater::handleRightMouseDown(S32 x, S32 y, MASK mask)
+bool LLFloater::handleRightMouseDown(S32 x, S32 y, MASK mask)
 {
-	BOOL was_minimized = mMinimized;
+	bool was_minimized = mMinimized;
 	bringToFront( x, y );
 	return was_minimized || LLPanel::handleRightMouseDown( x, y, mask );
 }
 
-BOOL LLFloater::handleMiddleMouseDown(S32 x, S32 y, MASK mask)
+bool LLFloater::handleMiddleMouseDown(S32 x, S32 y, MASK mask)
 {
 	bringToFront( x, y );
 	return LLPanel::handleMiddleMouseDown( x, y, mask );
@@ -1623,10 +1623,10 @@ BOOL LLFloater::handleMiddleMouseDown(S32 x, S32 y, MASK mask)
 
 
 // virtual
-BOOL LLFloater::handleDoubleClick(S32 x, S32 y, MASK mask)
+bool LLFloater::handleDoubleClick(S32 x, S32 y, MASK mask)
 {
-	BOOL was_minimized = mMinimized;
-	setMinimized(FALSE);
+	bool was_minimized = mMinimized;
+	setMinimized(false);
 	return was_minimized || LLPanel::handleDoubleClick(x, y, mask);
 }
 
diff --git a/indra/llui/llfloater.h b/indra/llui/llfloater.h
index 3d15708295..99ec77fa4d 100644
--- a/indra/llui/llfloater.h
+++ b/indra/llui/llfloater.h
@@ -293,13 +293,13 @@ public:
 	S32				getMinHeight() const{ return mMinHeight; }
 	S32				getHeaderHeight() const { return mHeaderHeight; }
 
-	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	handleDoubleClick(S32 x, S32 y, MASK mask);
-	virtual BOOL	handleMiddleMouseDown(S32 x, S32 y, MASK mask);
+	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	handleDoubleClick(S32 x, S32 y, MASK mask);
+	virtual bool	handleMiddleMouseDown(S32 x, S32 y, MASK mask);
 	
-	virtual BOOL	handleScrollWheel(S32 x, S32 y, S32 mask);
+	virtual bool	handleScrollWheel(S32 x, S32 y, S32 mask);
 	
 	virtual void	draw();
 	virtual void	drawShadow(LLPanel* panel);
diff --git a/indra/llui/llfolderview.cpp b/indra/llui/llfolderview.cpp
index 8033eaa00f..c9f74c63f8 100644
--- a/indra/llui/llfolderview.cpp
+++ b/indra/llui/llfolderview.cpp
@@ -1310,20 +1310,20 @@ BOOL LLFolderView::handleKeyHere( KEY key, MASK mask )
 }
 
 
-BOOL LLFolderView::handleUnicodeCharHere(llwchar uni_char)
+bool LLFolderView::handleUnicodeCharHere(llwchar uni_char)
 {
 	if ((uni_char < 0x20) || (uni_char == 0x7F)) // Control character or DEL
 	{
-		return FALSE;
+		return false;
 	}
 
 	if (uni_char > 0x7f)
 	{
 		LL_WARNS() << "LLFolderView::handleUnicodeCharHere - Don't handle non-ascii yet, aborting" << LL_ENDL;
-		return FALSE;
+		return false;
 	}
 
-	BOOL handled = FALSE;
+	bool handled = false;
 	if (mParentPanel.get()->hasFocus())
 	{
 		// SL-51858: Key presses are not being passed to the Popup menu.
@@ -1344,21 +1344,21 @@ BOOL LLFolderView::handleUnicodeCharHere(llwchar uni_char)
 		{
 			mSearchString += uni_char;
 		}
-		search(getCurSelectedItem(), mSearchString, FALSE);
+		search(getCurSelectedItem(), mSearchString, false);
 
-		handled = TRUE;
+		handled = true;
 	}
 
 	return handled;
 }
 
 
-BOOL LLFolderView::handleMouseDown( S32 x, S32 y, MASK mask )
+bool LLFolderView::handleMouseDown( S32 x, S32 y, MASK mask )
 {
-	mKeyboardSelection = FALSE;
+	mKeyboardSelection = false;
 	mSearchString.clear();
 
-	mParentPanel.get()->setFocus(TRUE);
+	mParentPanel.get()->setFocus(true);
 
 	LLEditMenuHandler::gEditMenuHandler = this;
 
@@ -1432,19 +1432,19 @@ BOOL LLFolderView::search(LLFolderViewItem* first_item, const std::string &searc
 	return found;
 }
 
-BOOL LLFolderView::handleDoubleClick( S32 x, S32 y, MASK mask )
+bool LLFolderView::handleDoubleClick( S32 x, S32 y, MASK mask )
 {
 	// skip LLFolderViewFolder::handleDoubleClick()
 	return LLView::handleDoubleClick( x, y, mask );
 }
 
-BOOL LLFolderView::handleRightMouseDown( S32 x, S32 y, MASK mask )
+bool LLFolderView::handleRightMouseDown( S32 x, S32 y, MASK mask )
 {
 	// all user operations move keyboard focus to inventory
 	// this way, we know when to stop auto-updating a search
-	mParentPanel.get()->setFocus(TRUE);
+	mParentPanel.get()->setFocus(true);
 
-	BOOL handled = childrenHandleRightMouseDown(x, y, mask) != NULL;
+	bool handled = childrenHandleRightMouseDown(x, y, mask) != NULL;
 	S32 count = mSelectedItems.size();
 
 	LLMenuGL* menu = static_cast<LLMenuGL*>(mPopupMenuHandle.get());
@@ -1516,9 +1516,9 @@ BOOL LLFolderView::handleRightMouseDown( S32 x, S32 y, MASK mask )
 	{
 		if (menu && menu->getVisible())
 		{
-			menu->setVisible(FALSE);
+			menu->setVisible(false);
 		}
-		setSelection(NULL, FALSE, TRUE);
+		setSelection(NULL, false, true);
 	}
 	return handled;
 }
@@ -1554,7 +1554,7 @@ BOOL LLFolderView::addNoOptions(LLMenuGL* menu) const
 	return FALSE;
 }
 
-BOOL LLFolderView::handleHover( S32 x, S32 y, MASK mask )
+bool LLFolderView::handleHover( S32 x, S32 y, MASK mask )
 {
 	return LLView::handleHover( x, y, mask );
 }
diff --git a/indra/llui/llfolderview.h b/indra/llui/llfolderview.h
index 5f8a173889..b235de95e9 100644
--- a/indra/llui/llfolderview.h
+++ b/indra/llui/llfolderview.h
@@ -202,11 +202,11 @@ public:
 	// LLView functionality
 	///*virtual*/ BOOL handleKey( KEY key, MASK mask, BOOL called_from_parent );
 	/*virtual*/ BOOL handleKeyHere( KEY key, MASK mask );
-	/*virtual*/ BOOL handleUnicodeCharHere(llwchar uni_char);
-	/*virtual*/ BOOL handleMouseDown( S32 x, S32 y, MASK mask );
-	/*virtual*/ BOOL handleDoubleClick( 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 handleUnicodeCharHere(llwchar uni_char);
+	/*virtual*/ bool handleMouseDown( S32 x, S32 y, MASK mask );
+	/*virtual*/ bool handleDoubleClick( 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 handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
 								   EDragAndDropType cargo_type,
 								   void* cargo_data,
diff --git a/indra/llui/llfolderviewitem.cpp b/indra/llui/llfolderviewitem.cpp
index 0dc66bf37a..9069a95c9f 100644
--- a/indra/llui/llfolderviewitem.cpp
+++ b/indra/llui/llfolderviewitem.cpp
@@ -550,21 +550,21 @@ const std::string& LLFolderViewItem::getName( void ) const
 }
 
 // LLView functionality
-BOOL LLFolderViewItem::handleRightMouseDown( S32 x, S32 y, MASK mask )
+bool LLFolderViewItem::handleRightMouseDown( S32 x, S32 y, MASK mask )
 {
 	if(!mIsSelected)
 	{
-		getRoot()->setSelection(this, FALSE);
+		getRoot()->setSelection(this, false);
 	}
 	make_ui_sound("UISndClick");
-	return TRUE;
+	return true;
 }
 
-BOOL LLFolderViewItem::handleMouseDown( S32 x, S32 y, MASK mask )
+bool LLFolderViewItem::handleMouseDown( S32 x, S32 y, MASK mask )
 {
 	if (LLView::childrenHandleMouseDown(x, y, mask))
 	{
-		return TRUE;
+		return true;
 	}
 	
 	// No handler needed for focus lost since this class has no
@@ -583,7 +583,7 @@ BOOL LLFolderViewItem::handleMouseDown( S32 x, S32 y, MASK mask )
 		}
 		else
 		{
-			getRoot()->setSelection(this, FALSE);
+			getRoot()->setSelection(this, false);
 		}
 		make_ui_sound("UISndClick");
 	}
@@ -591,15 +591,15 @@ BOOL LLFolderViewItem::handleMouseDown( S32 x, S32 y, MASK mask )
 	{
 		// If selected, we reserve the decision of deselecting/reselecting to the mouse up moment.
 		// This is necessary so we maintain selection consistent when starting a drag.
-		mSelectPending = TRUE;
+		mSelectPending = true;
 	}
 
 	mDragStartX = x;
 	mDragStartY = y;
-	return TRUE;
+	return true;
 }
 
-BOOL LLFolderViewItem::handleHover( S32 x, S32 y, MASK mask )
+bool LLFolderViewItem::handleHover( S32 x, S32 y, MASK mask )
 {
 	static LLCachedControl<S32> drag_and_drop_threshold(*LLUI::getInstance()->mSettingGroups["config"],"DragAndDropDistanceThreshold", 3);
 
@@ -616,7 +616,7 @@ BOOL LLFolderViewItem::handleHover( S32 x, S32 y, MASK mask )
 		{
 					// RN: when starting drag and drop, clear out last auto-open
 					root->autoOpenTest(NULL);
-					root->setShowSelectionContext(TRUE);
+					root->setShowSelectionContext(true);
 
 					// Release keyboard focus, so that if stuff is dropped into the
 					// world, pressing the delete key won't blow away the inventory
@@ -631,31 +631,31 @@ BOOL LLFolderViewItem::handleHover( S32 x, S32 y, MASK mask )
 		}
 
 		root->clearHoveredItem();
-		return TRUE;
+		return true;
 	}
 	else
 	{
 		LLFolderView* pRoot = getRoot();
 		pRoot->setHoveredItem(this);
-		pRoot->setShowSelectionContext(FALSE);
+		pRoot->setShowSelectionContext(false);
 		getWindow()->setCursor(UI_CURSOR_ARROW);
 		// let parent handle this then...
-		return FALSE;
+		return false;
 	}
 }
 
 
-BOOL LLFolderViewItem::handleDoubleClick( S32 x, S32 y, MASK mask )
+bool LLFolderViewItem::handleDoubleClick( S32 x, S32 y, MASK mask )
 {
 	openItem();
-	return TRUE;
+	return true;
 }
 
-BOOL LLFolderViewItem::handleMouseUp( S32 x, S32 y, MASK mask )
+bool LLFolderViewItem::handleMouseUp( S32 x, S32 y, MASK mask )
 {
 	if (LLView::childrenHandleMouseUp(x, y, mask))
 	{
-		return TRUE;
+		return true;
 	}
 	
 	// if mouse hasn't moved since mouse down...
@@ -672,21 +672,21 @@ BOOL LLFolderViewItem::handleMouseUp( S32 x, S32 y, MASK mask )
 		}
 		else
 		{
-			getRoot()->setSelection(this, FALSE);
+			getRoot()->setSelection(this, false);
 		}
 	}
 
-	mSelectPending = FALSE;
+	mSelectPending = false;
 
 	if( hasMouseCapture() )
 	{
 		if (getRoot())
 		{
-		getRoot()->setShowSelectionContext(FALSE);
+		getRoot()->setShowSelectionContext(false);
 		}
 		gFocusMgr.setMouseCapture( NULL );
 	}
-	return TRUE;
+	return true;
 }
 
 void LLFolderViewItem::onMouseLeave(S32 x, S32 y, MASK mask)
@@ -2019,9 +2019,9 @@ BOOL LLFolderViewFolder::handleDragAndDropToThisFolder(MASK mask,
 }
 
 
-BOOL LLFolderViewFolder::handleRightMouseDown( S32 x, S32 y, MASK mask )
+bool LLFolderViewFolder::handleRightMouseDown( S32 x, S32 y, MASK mask )
 {
-	BOOL handled = FALSE;
+	bool handled = false;
 
 	if( isOpen() )
 	{
@@ -2035,11 +2035,11 @@ BOOL LLFolderViewFolder::handleRightMouseDown( S32 x, S32 y, MASK mask )
 }
 
 
-BOOL LLFolderViewFolder::handleHover(S32 x, S32 y, MASK mask)
+bool LLFolderViewFolder::handleHover(S32 x, S32 y, MASK mask)
 {
 	mIsMouseOverTitle = (y > (getRect().getHeight() - mItemHeight));
 
-	BOOL handled = LLView::handleHover(x, y, mask);
+	bool handled = LLView::handleHover(x, y, mask);
 
 	if (!handled)
 	{
@@ -2050,9 +2050,9 @@ BOOL LLFolderViewFolder::handleHover(S32 x, S32 y, MASK mask)
 	return handled;
 }
 
-BOOL LLFolderViewFolder::handleMouseDown( S32 x, S32 y, MASK mask )
+bool LLFolderViewFolder::handleMouseDown( S32 x, S32 y, MASK mask )
 {
-	BOOL handled = FALSE;
+	bool handled = false;
 	if( isOpen() )
 	{
 		handled = childrenHandleMouseDown(x,y,mask) != NULL;
@@ -2063,7 +2063,7 @@ BOOL LLFolderViewFolder::handleMouseDown( S32 x, S32 y, MASK mask )
            && !mSingleFolderMode)
 		{
 			toggleOpen();
-			handled = TRUE;
+			handled = true;
 		}
 		else
 		{
@@ -2075,9 +2075,9 @@ BOOL LLFolderViewFolder::handleMouseDown( S32 x, S32 y, MASK mask )
 	return handled;
 }
 
-BOOL LLFolderViewFolder::handleDoubleClick( S32 x, S32 y, MASK mask )
+bool LLFolderViewFolder::handleDoubleClick( S32 x, S32 y, MASK mask )
 {
-	BOOL handled = FALSE;
+	bool handled = false;
     if(mSingleFolderMode)
     {
         static LLUICachedControl<bool> double_click_new_window("SingleModeDoubleClickOpenWindow", false);
@@ -2094,7 +2094,7 @@ BOOL LLFolderViewFolder::handleDoubleClick( S32 x, S32 y, MASK mask )
                                 getViewModelItem()->navigateToFolder(false);
                             });
         }
-        return TRUE;
+        return true;
     }
 
 	if( isOpen() )
@@ -2109,12 +2109,12 @@ BOOL LLFolderViewFolder::handleDoubleClick( S32 x, S32 y, MASK mask )
             if (double_click_action == 1)
             {
                 getViewModelItem()->navigateToFolder(true);
-                return TRUE;
+                return true;
             }
             if (double_click_action == 2)
             {
                 getViewModelItem()->navigateToFolder(false, true);
-                return TRUE;
+                return true;
             }
         }
 		if(mIndentation < x && x < mIndentation + (isCollapsed() ? 0 : mArrowSize) + mTextPad)
@@ -2125,10 +2125,10 @@ BOOL LLFolderViewFolder::handleDoubleClick( S32 x, S32 y, MASK mask )
 		}
 		else
 		{
-			getRoot()->setSelection(this, FALSE);
+			getRoot()->setSelection(this, false);
 			toggleOpen();
 		}
-		handled = TRUE;
+		handled = true;
 	}
 	return handled;
 }
diff --git a/indra/llui/llfolderviewitem.h b/indra/llui/llfolderviewitem.h
index 5c2a1ecff0..d178aa40d5 100644
--- a/indra/llui/llfolderviewitem.h
+++ b/indra/llui/llfolderviewitem.h
@@ -284,11 +284,11 @@ public:
     bool isSingleFolderMode() { return mSingleFolderMode; }
 
 	// LLView functionality
-	virtual BOOL handleRightMouseDown( S32 x, S32 y, MASK mask );
-	virtual BOOL handleMouseDown( S32 x, S32 y, MASK mask );
-	virtual BOOL handleHover( S32 x, S32 y, MASK mask );
-	virtual BOOL handleMouseUp( S32 x, S32 y, MASK mask );
-	virtual BOOL handleDoubleClick( S32 x, S32 y, MASK mask );
+	virtual bool handleRightMouseDown( S32 x, S32 y, MASK mask );
+	virtual bool handleMouseDown( S32 x, S32 y, MASK mask );
+	virtual bool handleHover( S32 x, S32 y, MASK mask );
+	virtual bool handleMouseUp( S32 x, S32 y, MASK mask );
+	virtual bool handleDoubleClick( S32 x, S32 y, MASK mask );
 
 	virtual void onMouseLeave(S32 x, S32 y, MASK mask);
 
@@ -447,10 +447,10 @@ public:
 	virtual void openItem( void );
 
 	// LLView functionality
-	virtual BOOL handleHover(S32 x, S32 y, MASK mask);
-	virtual BOOL handleRightMouseDown( S32 x, S32 y, MASK mask );
-	virtual BOOL handleMouseDown( S32 x, S32 y, MASK mask );
-	virtual BOOL handleDoubleClick( 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 handleMouseDown( S32 x, S32 y, MASK mask );
+	virtual bool handleDoubleClick( S32 x, S32 y, MASK mask );
 	virtual BOOL handleDragAndDrop(S32 x, S32 y, MASK mask, 
 									BOOL drop,
 									EDragAndDropType cargo_type,
diff --git a/indra/llui/lliconctrl.cpp b/indra/llui/lliconctrl.cpp
index 2791377a5e..c774a1105f 100644
--- a/indra/llui/lliconctrl.cpp
+++ b/indra/llui/lliconctrl.cpp
@@ -86,12 +86,12 @@ void LLIconCtrl::draw()
 	LLUICtrl::draw();
 }
 
-BOOL LLIconCtrl::handleHover(S32 x, S32 y, MASK mask)
+bool LLIconCtrl::handleHover(S32 x, S32 y, MASK mask)
 {
     if (mInteractable && getEnabled())
     {
         getWindow()->setCursor(UI_CURSOR_HAND);
-        return TRUE;
+        return true;
     }
     return LLUICtrl::handleHover(x, y, mask);
 }
diff --git a/indra/llui/lliconctrl.h b/indra/llui/lliconctrl.h
index e983d63a01..76b24cae52 100644
--- a/indra/llui/lliconctrl.h
+++ b/indra/llui/lliconctrl.h
@@ -71,7 +71,7 @@ public:
 	virtual void	draw();
 
     // llview overrides
-    virtual BOOL handleHover(S32 x, S32 y, MASK mask);
+    virtual bool handleHover(S32 x, S32 y, MASK mask);
 
 	// lluictrl overrides
 	void onVisibilityChange(BOOL new_visibility);
diff --git a/indra/llui/lllineeditor.cpp b/indra/llui/lllineeditor.cpp
index 60dbfd68c6..a1b9b5696c 100644
--- a/indra/llui/lllineeditor.cpp
+++ b/indra/llui/lllineeditor.cpp
@@ -660,9 +660,9 @@ void LLLineEditor::onSpellCheckSettingsChange()
 	mSpellCheckStart = mSpellCheckEnd = -1;
 }
 
-BOOL LLLineEditor::handleDoubleClick(S32 x, S32 y, MASK mask)
+bool LLLineEditor::handleDoubleClick(S32 x, S32 y, MASK mask)
 {
-	setFocus( TRUE );
+	setFocus( true );
 	mTripleClickTimer.setTimerExpirySec(TRIPLE_CLICK_INTERVAL);
 
 	if (mSelectionEnd == 0 && mSelectionStart == mText.length())
@@ -674,7 +674,7 @@ BOOL LLLineEditor::handleDoubleClick(S32 x, S32 y, MASK mask)
 	{
 		const LLWString& wtext = mText.getWString();
 
-		BOOL doSelectAll = TRUE;
+		bool doSelectAll = true;
 
 		// Select the word we're on
 		if( LLWStringUtil::isPartOfWord( wtext[mCursorPos] ) )
@@ -709,7 +709,7 @@ BOOL LLLineEditor::handleDoubleClick(S32 x, S32 y, MASK mask)
 	// 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;  
+	mIsSelecting = false;
 
 	// delay cursor flashing
 	mKeystrokeTimer.reset();
@@ -717,15 +717,15 @@ BOOL LLLineEditor::handleDoubleClick(S32 x, S32 y, MASK mask)
 	// take selection to 'primary' clipboard
 	updatePrimary();
 
-	return TRUE;
+	return true;
 }
 
-BOOL LLLineEditor::handleMouseDown(S32 x, S32 y, MASK mask)
+bool LLLineEditor::handleMouseDown(S32 x, S32 y, MASK mask)
 {
 	// Check first whether the "clear search" button wants to deal with this.
 	if(childrenHandleMouseDown(x, y, mask) != NULL) 
 	{
-		return TRUE;
+		return true;
 	}
 	
 	if (!mSelectAllonFocusReceived
@@ -737,7 +737,7 @@ BOOL LLLineEditor::handleMouseDown(S32 x, S32 y, MASK mask)
 		if (mask & MASK_SHIFT)
 		{
 			// assume we're starting a drag select
-			mIsSelecting = TRUE;
+			mIsSelecting = true;
 
 			// Handle selection extension
 			S32 old_cursor_pos = getCursor();
@@ -793,14 +793,14 @@ BOOL LLLineEditor::handleMouseDown(S32 x, S32 y, MASK mask)
 				// 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;
+				mIsSelecting = false;
 			}
 		}
 
 		gFocusMgr.setMouseCapture( this );
 	}
 
-	setFocus(TRUE);
+	setFocus(true);
 
 	// delay cursor flashing
 	mKeystrokeTimer.reset();
@@ -808,40 +808,40 @@ BOOL LLLineEditor::handleMouseDown(S32 x, S32 y, MASK mask)
 	if (mMouseDownSignal)
 		(*mMouseDownSignal)(this,x,y,mask);
 
-	return TRUE;
+	return true;
 }
 
-BOOL LLLineEditor::handleMiddleMouseDown(S32 x, S32 y, MASK mask)
+bool LLLineEditor::handleMiddleMouseDown(S32 x, S32 y, MASK mask)
 {
         // LL_INFOS() << "MiddleMouseDown" << LL_ENDL;
-	setFocus( TRUE );
+	setFocus( true );
 	if( canPastePrimary() )
 	{
 		setCursorAtLocalPos(x);
 		pastePrimary();
 	}
-	return TRUE;
+	return true;
 }
 
-BOOL LLLineEditor::handleRightMouseDown(S32 x, S32 y, MASK mask)
+bool LLLineEditor::handleRightMouseDown(S32 x, S32 y, MASK mask)
 {
-	setFocus(TRUE);
+	setFocus(true);
     if (!LLUICtrl::handleRightMouseDown(x, y, mask) && getShowContextMenu())
 	{
 		showContextMenu(x, y);
 	}
-	return TRUE;
+	return true;
 }
 
-BOOL LLLineEditor::handleHover(S32 x, S32 y, MASK mask)
+bool LLLineEditor::handleHover(S32 x, S32 y, MASK mask)
 {
-	BOOL handled = FALSE;
+	bool handled = false;
 	// Check first whether the "clear search" button wants to deal with this.
 	if(!hasMouseCapture())
 	{
 		if(childrenHandleHover(x, y, mask) != NULL) 
 		{
-			return TRUE;
+			return true;
 		}
 	}
 
@@ -884,34 +884,34 @@ BOOL LLLineEditor::handleHover(S32 x, S32 y, MASK mask)
 
 		getWindow()->setCursor(UI_CURSOR_IBEAM);
 		LL_DEBUGS("UserInput") << "hover handled by " << getName() << " (active)" << LL_ENDL;		
-		handled = TRUE;
+		handled = true;
 	}
 
 	if( !handled  )
 	{
 		getWindow()->setCursor(UI_CURSOR_IBEAM);
 		LL_DEBUGS("UserInput") << "hover handled by " << getName() << " (inactive)" << LL_ENDL;		
-		handled = TRUE;
+		handled = true;
 	}
 
 	return handled;
 }
 
 
-BOOL LLLineEditor::handleMouseUp(S32 x, S32 y, MASK mask)
+bool LLLineEditor::handleMouseUp(S32 x, S32 y, MASK mask)
 {
-	BOOL	handled = FALSE;
+	bool	handled = false;
 
 	if( hasMouseCapture() )
 	{
 		gFocusMgr.setMouseCapture( NULL );
-		handled = TRUE;
+		handled = true;
 	}
 
 	// Check first whether the "clear search" button wants to deal with this.
 	if(!handled && childrenHandleMouseUp(x, y, mask) != NULL) 
 	{
-		return TRUE;
+		return true;
 	}
 
 	if( mIsSelecting )
@@ -919,7 +919,7 @@ BOOL LLLineEditor::handleMouseUp(S32 x, S32 y, MASK mask)
 		setCursorAtLocalPos( x );
 		mSelectionEnd = getCursor();
 
-		handled = TRUE;
+		handled = true;
 	}
 
 	if( handled )
@@ -1597,18 +1597,18 @@ BOOL LLLineEditor::handleKeyHere(KEY key, MASK mask )
 }
 
 
-BOOL LLLineEditor::handleUnicodeCharHere(llwchar uni_char)
+bool LLLineEditor::handleUnicodeCharHere(llwchar uni_char)
 {
 	if ((uni_char < 0x20) || (uni_char == 0x7F)) // Control character or DEL
 	{
-		return FALSE;
+		return false;
 	}
 
-	BOOL	handled = FALSE;
+	bool	handled = false;
 
 	if ( (gFocusMgr.getKeyboardFocus() == this) && getVisible() && !mReadOnly)
 	{
-		handled = TRUE;
+		handled = true;
 
 		LLLineEditorRollback rollback( this );
 
@@ -2489,7 +2489,7 @@ void LLLineEditor::updatePreedit(const LLWString &preedit_string,
 	mSpellCheckTimer.setTimerExpirySec(SPELLCHECK_DELAY);
 }
 
-BOOL LLLineEditor::getPreeditLocation(S32 query_offset, LLCoordGL *coord, LLRect *bounds, LLRect *control) const
+bool LLLineEditor::getPreeditLocation(S32 query_offset, LLCoordGL *coord, LLRect *bounds, LLRect *control) const
 {
 	if (control)
 	{
@@ -2511,13 +2511,13 @@ BOOL LLLineEditor::getPreeditLocation(S32 query_offset, LLCoordGL *coord, LLRect
 	if (preedit_right_column < mScrollHPos)
 	{
 		// This should not occure...
-		return FALSE;
+		return false;
 	}
 
 	const S32 query = (query_offset >= 0 ? preedit_left_column + query_offset : getCursor());
 	if (query < mScrollHPos || query < preedit_left_column || query > preedit_right_column)
 	{
-		return FALSE;
+		return false;
 	}
 
 	if (coord)
@@ -2544,7 +2544,7 @@ BOOL LLLineEditor::getPreeditLocation(S32 query_offset, LLCoordGL *coord, LLRect
 		LLUI::getInstance()->screenRectToGL(preedit_rect_screen, bounds);
 	}
 
-	return TRUE;
+	return true;
 }
 
 void LLLineEditor::getPreeditRange(S32 *position, S32 *length) const
diff --git a/indra/llui/lllineeditor.h b/indra/llui/lllineeditor.h
index f983828d2b..cdb514deaa 100644
--- a/indra/llui/lllineeditor.h
+++ b/indra/llui/lllineeditor.h
@@ -122,14 +122,14 @@ public:
 	virtual ~LLLineEditor();
 
 	// mousehandler overrides
-	/*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*/ BOOL	handleDoubleClick(S32 x,S32 y,MASK mask);
-	/*virtual*/ BOOL	handleMiddleMouseDown(S32 x,S32 y,MASK mask);
-	/*virtual*/ BOOL	handleRightMouseDown(S32 x, S32 y, MASK mask);
+	/*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*/ bool	handleDoubleClick(S32 x,S32 y,MASK mask);
+	/*virtual*/ bool	handleMiddleMouseDown(S32 x,S32 y,MASK mask);
+	/*virtual*/ bool	handleRightMouseDown(S32 x, S32 y, MASK mask);
 	/*virtual*/ BOOL	handleKeyHere(KEY key, MASK mask );
-	/*virtual*/ BOOL	handleUnicodeCharHere(llwchar uni_char);
+	/*virtual*/ bool	handleUnicodeCharHere(llwchar uni_char);
 	/*virtual*/ void	onMouseCaptureLost();
 
 	// LLEditMenuHandler overrides
@@ -319,7 +319,7 @@ public:
 						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 BOOL	getPreeditLocation(S32 query_position, LLCoordGL *coord, LLRect *bounds, LLRect *control) const;
+	virtual bool	getPreeditLocation(S32 query_position, LLCoordGL *coord, LLRect *bounds, LLRect *control) const;
 	virtual S32		getPreeditFontSize() const;
 	virtual LLWString getPreeditString() const { return getWText(); }
 
diff --git a/indra/llui/llmenubutton.cpp b/indra/llui/llmenubutton.cpp
index 583704418b..ceb78387ac 100644
--- a/indra/llui/llmenubutton.cpp
+++ b/indra/llui/llmenubutton.cpp
@@ -142,13 +142,13 @@ BOOL LLMenuButton::handleKeyHere(KEY key, MASK mask )
 	return FALSE;
 }
 
-BOOL LLMenuButton::handleMouseDown(S32 x, S32 y, MASK mask)
+bool LLMenuButton::handleMouseDown(S32 x, S32 y, MASK mask)
 {
 	LLButton::handleMouseDown(x, y, mask);
 
 	toggleMenu();
 	
-	return TRUE;
+	return true;
 }
 
 void LLMenuButton::toggleMenu()
diff --git a/indra/llui/llmenubutton.h b/indra/llui/llmenubutton.h
index e42f8f53bd..b6ec4e2e35 100644
--- a/indra/llui/llmenubutton.h
+++ b/indra/llui/llmenubutton.h
@@ -65,7 +65,7 @@ public:
 	
 	boost::signals2::connection setMouseDownCallback( const mouse_signal_t::slot_type& cb );
 
-	/*virtual*/ BOOL handleMouseDown(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool handleMouseDown(S32 x, S32 y, MASK mask);
 	/*virtual*/ BOOL handleKeyHere(KEY key, MASK mask );
 
 	void hideMenu();
diff --git a/indra/llui/llmenugl.cpp b/indra/llui/llmenugl.cpp
index cebca70b59..755ff5f4e3 100644
--- a/indra/llui/llmenugl.cpp
+++ b/indra/llui/llmenugl.cpp
@@ -229,14 +229,14 @@ BOOL LLMenuItemGL::handleAcceleratorKey(KEY key, MASK mask)
 	return FALSE;
 }
 
-BOOL LLMenuItemGL::handleHover(S32 x, S32 y, MASK mask)
+bool LLMenuItemGL::handleHover(S32 x, S32 y, MASK mask)
 {
 	getWindow()->setCursor(UI_CURSOR_ARROW);
-	return TRUE;
+	return true;
 }
 
 //virtual
-BOOL LLMenuItemGL::handleRightMouseDown(S32 x, S32 y, MASK mask)
+bool LLMenuItemGL::handleRightMouseDown(S32 x, S32 y, MASK mask)
 {
 	return LLUICtrl::handleRightMouseDown(x,y,mask);
 }
@@ -254,14 +254,14 @@ void LLMenuItemGL::onMouseLeave(S32 x, S32 y, MASK mask)
 }
 
 //virtual
-BOOL LLMenuItemGL::handleRightMouseUp(S32 x, S32 y, MASK mask)
+bool LLMenuItemGL::handleRightMouseUp(S32 x, S32 y, MASK mask)
 {
 	// If this event came from a right-click context menu spawn,
 	// process as a left-click to allow menu items to be hit
 	if (LLMenuHolderGL::sContextMenuSpawnPos.mX != S32_MAX
 		|| LLMenuHolderGL::sContextMenuSpawnPos.mY != S32_MAX)
 	{
-		BOOL handled = handleMouseUp(x, y, mask);
+		bool handled = handleMouseUp(x, y, mask);
 		return handled;
 	}
 	return LLUICtrl::handleRightMouseUp(x,y,mask);
@@ -453,26 +453,26 @@ BOOL LLMenuItemGL::handleKeyHere( KEY key, MASK mask )
 	return FALSE;
 }
 
-BOOL LLMenuItemGL::handleMouseUp( S32 x, S32 y, MASK mask)
+bool LLMenuItemGL::handleMouseUp( S32 x, S32 y, MASK mask)
 {
 	// switch to mouse navigation mode
-	LLMenuGL::setKeyboardMode(FALSE);
+	LLMenuGL::setKeyboardMode(false);
 
 	onCommit();
 	make_ui_sound("UISndClickRelease");
 	return LLView::handleMouseUp(x, y, mask);
 }
 
-BOOL LLMenuItemGL::handleMouseDown( S32 x, S32 y, MASK mask)
+bool LLMenuItemGL::handleMouseDown( S32 x, S32 y, MASK mask)
 {
 	// switch to mouse navigation mode
-	LLMenuGL::setKeyboardMode(FALSE);
+	LLMenuGL::setKeyboardMode(false);
 
-	setHighlight(TRUE);
+	setHighlight(true);
 	return LLView::handleMouseDown(x, y, mask);
 }
 
-BOOL LLMenuItemGL::handleScrollWheel( S32 x, S32 y, S32 clicks )
+bool LLMenuItemGL::handleScrollWheel( S32 x, S32 y, S32 clicks )
 {
 	// If the menu is scrollable let it handle the wheel event.
 	return !getMenu()->isScrollable();
@@ -605,49 +605,49 @@ void LLMenuItemSeparatorGL::buildDrawLabel( void )
     }
 }
 
-BOOL LLMenuItemSeparatorGL::handleMouseDown(S32 x, S32 y, MASK mask)
+bool LLMenuItemSeparatorGL::handleMouseDown(S32 x, S32 y, MASK mask)
 {
 	LLMenuGL* parent_menu = getMenu();
 	if (y > getRect().getHeight() / 2)
 	{
 		// the menu items are in the child list in bottom up order
 		LLView* prev_menu_item = parent_menu->findNextSibling(this);
-		return (prev_menu_item && prev_menu_item->getVisible() && prev_menu_item->getEnabled()) ? prev_menu_item->handleMouseDown(x, prev_menu_item->getRect().getHeight(), mask) : FALSE;
+		return (prev_menu_item && prev_menu_item->getVisible() && prev_menu_item->getEnabled()) ? prev_menu_item->handleMouseDown(x, prev_menu_item->getRect().getHeight(), mask) : false;
 	}
 	else
 	{
 		LLView* next_menu_item = parent_menu->findPrevSibling(this);
-		return (next_menu_item && next_menu_item->getVisible() && next_menu_item->getEnabled()) ? next_menu_item->handleMouseDown(x, 0, mask) : FALSE;
+		return (next_menu_item && next_menu_item->getVisible() && next_menu_item->getEnabled()) ? next_menu_item->handleMouseDown(x, 0, mask) : false;
 	}
 }
 
-BOOL LLMenuItemSeparatorGL::handleMouseUp(S32 x, S32 y, MASK mask) 
+bool LLMenuItemSeparatorGL::handleMouseUp(S32 x, S32 y, MASK mask)
 {
 	LLMenuGL* parent_menu = getMenu();
 	if (y > getRect().getHeight() / 2)
 	{
 		LLView* prev_menu_item = parent_menu->findNextSibling(this);
-		return (prev_menu_item && prev_menu_item->getVisible() && prev_menu_item->getEnabled()) ? prev_menu_item->handleMouseUp(x, prev_menu_item->getRect().getHeight(), mask) : FALSE;
+		return (prev_menu_item && prev_menu_item->getVisible() && prev_menu_item->getEnabled()) ? prev_menu_item->handleMouseUp(x, prev_menu_item->getRect().getHeight(), mask) : false;
 	}
 	else
 	{
 		LLView* next_menu_item = parent_menu->findPrevSibling(this);
-		return (next_menu_item && next_menu_item->getVisible() && next_menu_item->getEnabled()) ? next_menu_item->handleMouseUp(x, 0, mask) : FALSE;
+		return (next_menu_item && next_menu_item->getVisible() && next_menu_item->getEnabled()) ? next_menu_item->handleMouseUp(x, 0, mask) : false;
 	}
 }
 
-BOOL LLMenuItemSeparatorGL::handleHover(S32 x, S32 y, MASK mask) 
+bool LLMenuItemSeparatorGL::handleHover(S32 x, S32 y, MASK mask)
 {
 	LLMenuGL* parent_menu = getMenu();
 	if (y > getRect().getHeight() / 2)
 	{
-		parent_menu->highlightPrevItem(this, FALSE);
-		return FALSE;
+		parent_menu->highlightPrevItem(this, false);
+		return false;
 	}
 	else
 	{
-		parent_menu->highlightNextItem(this, FALSE);
-		return FALSE;
+		parent_menu->highlightNextItem(this, false);
+		return false;
 	}
 }
 
@@ -663,7 +663,7 @@ class LLMenuItemVerticalSeparatorGL
 public:
 	LLMenuItemVerticalSeparatorGL( void );
 
-	virtual BOOL handleMouseDown(S32 x, S32 y, MASK mask) { return FALSE; }
+	virtual bool handleMouseDown(S32 x, S32 y, MASK mask) { return false; }
 };
 
 LLMenuItemVerticalSeparatorGL::LLMenuItemVerticalSeparatorGL( void )
@@ -1019,14 +1019,14 @@ LLView* LLMenuItemBranchGL::findChildView(const std::string& name, BOOL recurse)
 }
 
 // virtual
-BOOL LLMenuItemBranchGL::handleMouseUp(S32 x, S32 y, MASK mask)
+bool LLMenuItemBranchGL::handleMouseUp(S32 x, S32 y, MASK mask)
 {
 	// switch to mouse navigation mode
 	LLMenuGL::setKeyboardMode(FALSE);
 
 	onCommit();
 	make_ui_sound("UISndClickRelease");
-	return TRUE;
+	return true;
 }
 
 bool LLMenuItemBranchGL::hasAccelerator(const KEY &key, const MASK &mask) const
@@ -1363,8 +1363,8 @@ public:
 	virtual BOOL isActive( void ) const;
 
 	// LLView functionality
-	virtual BOOL handleMouseDown( S32 x, S32 y, MASK mask );
-	virtual BOOL handleMouseUp( S32 x, S32 y, MASK mask ); 
+	virtual bool handleMouseDown( S32 x, S32 y, MASK mask );
+	virtual bool handleMouseUp( S32 x, S32 y, MASK mask );
 	virtual void draw( void );
 	virtual BOOL handleKeyHere(KEY key, MASK mask);
 	
@@ -1490,10 +1490,10 @@ BOOL LLMenuItemBranchDownGL::isActive() const
 	return isOpen();
 }
 
-BOOL LLMenuItemBranchDownGL::handleMouseDown( S32 x, S32 y, MASK mask )
+bool LLMenuItemBranchDownGL::handleMouseDown( S32 x, S32 y, MASK mask )
 {
 	// switch to mouse control mode
-	LLMenuGL::setKeyboardMode(FALSE);
+	LLMenuGL::setKeyboardMode(false);
 
 	if (getVisible() && isOpen())
 	{
@@ -1505,12 +1505,12 @@ BOOL LLMenuItemBranchDownGL::handleMouseDown( S32 x, S32 y, MASK mask )
 	}
 
 	make_ui_sound("UISndClick");
-	return TRUE;
+	return true;
 }
 
-BOOL LLMenuItemBranchDownGL::handleMouseUp( S32 x, S32 y, MASK mask )
+bool LLMenuItemBranchDownGL::handleMouseUp( S32 x, S32 y, MASK mask )
 {
-	return TRUE;
+	return true;
 }
 
 
@@ -3118,19 +3118,19 @@ BOOL LLMenuGL::handleAcceleratorKey(KEY key, MASK mask)
 	return FALSE;
 }
 
-BOOL LLMenuGL::handleUnicodeCharHere( llwchar uni_char )
+bool LLMenuGL::handleUnicodeCharHere( llwchar uni_char )
 {
 	if (jumpKeysActive())
 	{
 		return handleJumpKey((KEY)uni_char);
 	}
-	return FALSE;
+	return false;
 }
 
-BOOL LLMenuGL::handleHover( S32 x, S32 y, MASK mask )
+bool LLMenuGL::handleHover( S32 x, S32 y, MASK mask )
 {
 	// leave submenu in place if slope of mouse < MAX_MOUSE_SLOPE_SUB_MENU
-	BOOL no_mouse_data = mLastMouseX == 0 && mLastMouseY == 0;
+	bool no_mouse_data = mLastMouseX == 0 && mLastMouseY == 0;
 	S32 mouse_delta_x = no_mouse_data ? 0 : x - mLastMouseX;
 	S32 mouse_delta_y = no_mouse_data ? 0 : y - mLastMouseY;
 	LLVector2 mouse_dir((F32)mouse_delta_x, (F32)mouse_delta_y);
@@ -3161,7 +3161,7 @@ BOOL LLMenuGL::handleHover( S32 x, S32 y, MASK mask )
 				// moving mouse always highlights new item
 				if (mouse_delta_x != 0 || mouse_delta_y != 0)
 				{
-					((LLMenuItemGL*)viewp)->setHighlight(FALSE);
+					((LLMenuItemGL*)viewp)->setHighlight(false);
 				}
 			}
 		}
@@ -3183,8 +3183,8 @@ BOOL LLMenuGL::handleHover( S32 x, S32 y, MASK mask )
 				// moving mouse always highlights new item
 				if (mouse_delta_x != 0 || mouse_delta_y != 0)
 				{
-					((LLMenuItemGL*)viewp)->setHighlight(TRUE);
-					LLMenuGL::setKeyboardMode(FALSE);
+					((LLMenuItemGL*)viewp)->setHighlight(true);
+					LLMenuGL::setKeyboardMode(false);
 				}
 				mHasSelection = true;
 			}
@@ -3197,10 +3197,10 @@ BOOL LLMenuGL::handleHover( S32 x, S32 y, MASK mask )
 	// drop-down menu is shown. Otherwise any other view won't be able to handle mouse events
 	// until the user chooses one of the drop-down menu items.
 
-	return TRUE;
+	return true;
 }
 
-BOOL LLMenuGL::handleScrollWheel( S32 x, S32 y, S32 clicks )
+bool LLMenuGL::handleScrollWheel( S32 x, S32 y, S32 clicks )
 {
 	if (!mScrollable)
 		return blockMouseEvent(x, y);
@@ -3216,7 +3216,7 @@ BOOL LLMenuGL::handleScrollWheel( S32 x, S32 y, S32 clicks )
 			scrollItems(SD_UP);
 	}
 
-	return TRUE;
+	return true;
 }
 
 
@@ -3503,7 +3503,7 @@ BOOL LLMenuBarGL::handleJumpKey(KEY key)
 	return TRUE;
 }
 
-BOOL LLMenuBarGL::handleMouseDown(S32 x, S32 y, MASK mask)
+bool LLMenuBarGL::handleMouseDown(S32 x, S32 y, MASK mask)
 {
 	// clicks on menu bar closes existing menus from other contexts but leave
 	// own menu open so that we get toggle behavior
@@ -3515,7 +3515,7 @@ BOOL LLMenuBarGL::handleMouseDown(S32 x, S32 y, MASK mask)
 	return LLMenuGL::handleMouseDown(x, y, mask);
 }
 
-BOOL LLMenuBarGL::handleDoubleClick(S32 x, S32 y, MASK mask)
+bool LLMenuBarGL::handleDoubleClick(S32 x, S32 y, MASK mask)
 {
 	return LLMenuGL::handleMouseDown(x, y, mask);
 }
@@ -3652,9 +3652,9 @@ BOOL LLMenuBarGL::appendMenu( LLMenuGL* menu )
 	return success;
 }
 
-BOOL LLMenuBarGL::handleHover( S32 x, S32 y, MASK mask )
+bool LLMenuBarGL::handleHover( S32 x, S32 y, MASK mask )
 {
-	BOOL handled = FALSE;
+	bool handled = false;
 	LLView* active_menu = NULL;
 
 	BOOL no_mouse_data = mLastMouseX == 0 && mLastMouseY == 0;
@@ -3690,14 +3690,14 @@ BOOL LLMenuBarGL::handleHover( S32 x, S32 y, MASK mask )
 				viewp->pointInView(local_x, local_y) && 
 				viewp->handleHover(local_x, local_y, mask))
 			{
-				((LLMenuItemGL*)viewp)->setHighlight(TRUE);
+				((LLMenuItemGL*)viewp)->setHighlight(true);
 				handled = TRUE;
 				if (active_menu && active_menu != viewp)
 				{
 					((LLMenuItemGL*)viewp)->onCommit();
-					LLMenuGL::setKeyboardMode(FALSE);
+					LLMenuGL::setKeyboardMode(false);
 				}
-				LLMenuGL::setKeyboardMode(FALSE);
+				LLMenuGL::setKeyboardMode(false);
 			}
 		}
 
@@ -3711,7 +3711,7 @@ BOOL LLMenuBarGL::handleHover( S32 x, S32 y, MASK mask )
 				S32 local_y = y - viewp->getRect().mBottom;
 				if (!viewp->pointInView(local_x, local_y) && ((LLMenuItemGL*)viewp)->getHighlight())
 				{
-					((LLMenuItemGL*)viewp)->setHighlight(FALSE);
+					((LLMenuItemGL*)viewp)->setHighlight(false);
 				}
 			}
 		}
@@ -3719,7 +3719,7 @@ BOOL LLMenuBarGL::handleHover( S32 x, S32 y, MASK mask )
 
 	getWindow()->setCursor(UI_CURSOR_ARROW);
 	
-	return TRUE;
+	return true;
 }
 
 ///============================================================================
@@ -3759,9 +3759,9 @@ void LLMenuHolderGL::draw()
 	}
 }
 
-BOOL LLMenuHolderGL::handleMouseDown( S32 x, S32 y, MASK mask )
+bool LLMenuHolderGL::handleMouseDown( S32 x, S32 y, MASK mask )
 {
-	BOOL handled = LLView::childrenHandleMouseDown(x, y, mask) != NULL;
+	bool handled = LLView::childrenHandleMouseDown(x, y, mask) != NULL;
 	if (!handled)
 	{
 		LLMenuGL* visible_menu = (LLMenuGL*)getVisibleMenu();
@@ -3786,9 +3786,9 @@ BOOL LLMenuHolderGL::handleMouseDown( S32 x, S32 y, MASK mask )
 	return handled;
 }
 
-BOOL LLMenuHolderGL::handleRightMouseDown( S32 x, S32 y, MASK mask )
+bool LLMenuHolderGL::handleRightMouseDown( S32 x, S32 y, MASK mask )
 {
-	BOOL handled = LLView::childrenHandleRightMouseDown(x, y, mask) != NULL;
+	bool handled = LLView::childrenHandleRightMouseDown(x, y, mask) != NULL;
 	if (!handled)
 	{
 		// clicked off of menu, hide them all
@@ -3799,7 +3799,7 @@ BOOL LLMenuHolderGL::handleRightMouseDown( S32 x, S32 y, MASK mask )
 
 // This occurs when you mouse-down to spawn a context menu, hold the button 
 // down, move off the menu, then mouse-up.  We want this to close the menu.
-BOOL LLMenuHolderGL::handleRightMouseUp( S32 x, S32 y, MASK mask )
+bool LLMenuHolderGL::handleRightMouseUp( S32 x, S32 y, MASK mask )
 {
 	const S32 SLOP = 2;
 	S32 spawn_dx = (x - sContextMenuSpawnPos.mX);
@@ -3811,10 +3811,10 @@ BOOL LLMenuHolderGL::handleRightMouseUp( S32 x, S32 y, MASK mask )
 		// so interpret the mouse-up as a single-click to show and leave on
 		// screen
 		sContextMenuSpawnPos.set(S32_MAX, S32_MAX);
-		return TRUE;
+		return true;
 	}
 
-	BOOL handled = LLView::childrenHandleRightMouseUp(x, y, mask) != NULL;
+	bool handled = LLView::childrenHandleRightMouseUp(x, y, mask) != NULL;
 	if (!handled)
 	{
 		// clicked off of menu, hide them all
@@ -4296,36 +4296,36 @@ void LLContextMenu::hide()
 }
 
 
-BOOL LLContextMenu::handleHover( S32 x, S32 y, MASK mask )
+bool LLContextMenu::handleHover( S32 x, S32 y, MASK mask )
 {
 	LLMenuGL::handleHover(x,y,mask);
 
-	BOOL handled = FALSE;
+	bool handled = false;
 
 	LLMenuItemGL *item = getHighlightedItem();
 
 	if (item && item->getEnabled())
 	{
 		getWindow()->setCursor(UI_CURSOR_ARROW);
-		handled = TRUE;
+		handled = true;
 
 		if (item != mHoverItem)
 		{
 			if (mHoverItem)
 			{
-				mHoverItem->setHighlight( FALSE );
+				mHoverItem->setHighlight( false );
 			}
 			mHoverItem = item;
-			mHoverItem->setHighlight( TRUE );
+			mHoverItem->setHighlight( true );
 		}
-		mHoveredAnyItem = TRUE;
+		mHoveredAnyItem = true;
 	}
 	else
 	{
 		// clear out our selection
 		if (mHoverItem)
 		{
-			mHoverItem->setHighlight(FALSE);
+			mHoverItem->setHighlight(false);
 			mHoverItem = NULL;
 		}
 	}
@@ -4333,7 +4333,7 @@ BOOL LLContextMenu::handleHover( S32 x, S32 y, MASK mask )
 	if( !handled && pointInView( x, y ) )
 	{
 		getWindow()->setCursor(UI_CURSOR_ARROW);
-		handled = TRUE;
+		handled = true;
 	}
 
 	return handled;
@@ -4342,9 +4342,9 @@ BOOL LLContextMenu::handleHover( S32 x, S32 y, MASK mask )
 // handleMouseDown and handleMouseUp are handled by LLMenuGL
 
 
-BOOL LLContextMenu::handleRightMouseDown(S32 x, S32 y, MASK mask)
+bool LLContextMenu::handleRightMouseDown(S32 x, S32 y, MASK mask)
 {
-	BOOL handled = FALSE;
+	bool handled = false;
 
 	// The click was somewhere within our rectangle
 	LLMenuItemGL *item = getHighlightedItem();
@@ -4352,13 +4352,13 @@ BOOL LLContextMenu::handleRightMouseDown(S32 x, S32 y, MASK mask)
 	S32 local_x = x - getRect().mLeft;
 	S32 local_y = y - getRect().mBottom;
 
-	BOOL clicked_in_menu = pointInView(local_x, local_y) ;
+	bool clicked_in_menu = pointInView(local_x, local_y) ;
 
 	// grab mouse if right clicking anywhere within pie (even deadzone in middle), to detect drag outside of pie
 	if (clicked_in_menu)
 	{
 		// capture mouse cursor as if on initial menu show
-		handled = TRUE;
+		handled = true;
 	}
 	
 	if (item)
@@ -4367,14 +4367,14 @@ BOOL LLContextMenu::handleRightMouseDown(S32 x, S32 y, MASK mask)
 		// to make sure it's within the item's rectangle
 		if (item->handleMouseDown( 0, 0, mask ))
 		{
-			handled = TRUE;
+			handled = true;
 		}
 	}
 
 	return handled;
 }
 
-BOOL LLContextMenu::handleRightMouseUp( S32 x, S32 y, MASK mask )
+bool LLContextMenu::handleRightMouseUp( S32 x, S32 y, MASK mask )
 {
 	S32 local_x = x - getRect().mLeft;
 	S32 local_y = y - getRect().mBottom;
@@ -4382,12 +4382,12 @@ BOOL LLContextMenu::handleRightMouseUp( S32 x, S32 y, MASK mask )
 	if (!mHoveredAnyItem && !pointInView(local_x, local_y))
 	{
 		sMenuContainer->hideMenus();
-		return TRUE;
+		return true;
 	}
 
 
 	BOOL result = handleMouseUp( x, y, mask );
-	mHoveredAnyItem = FALSE;
+	mHoveredAnyItem = false;
 	
 	return result;
 }
diff --git a/indra/llui/llmenugl.h b/indra/llui/llmenugl.h
index 87e3f18ebc..88fb30fbb2 100644
--- a/indra/llui/llmenugl.h
+++ b/indra/llui/llmenugl.h
@@ -90,9 +90,9 @@ protected:
 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);
+	/*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);
@@ -163,9 +163,9 @@ public:
 
 	// 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 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);
@@ -241,9 +241,9 @@ public:
 	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*/ 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();
 
@@ -442,9 +442,9 @@ public:
 	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*/ 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);
@@ -643,7 +643,7 @@ protected:
 public:
 	virtual ~LLMenuItemBranchGL();
 	
-	virtual BOOL handleMouseUp(S32 x, S32 y, MASK mask);
+	virtual bool handleMouseUp(S32 x, S32 y, MASK mask);
 
 	virtual bool hasAccelerator(const KEY &key, const MASK &mask) const;
 	virtual BOOL handleAcceleratorKey(KEY key, MASK mask);
@@ -721,9 +721,9 @@ public:
 	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);
 
@@ -788,8 +788,8 @@ public:
 	/*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 handleMouseDown(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool handleDoubleClick(S32 x, S32 y, MASK mask);
 
 	/*virtual*/ void draw();
 	/*virtual*/ BOOL jumpKeysActive();
@@ -798,7 +798,7 @@ public:
 	virtual BOOL addSeparator();
 
 	// LLView Functionality
-	virtual BOOL handleHover( S32 x, S32 y, MASK mask );
+	virtual bool handleHover( S32 x, S32 y, MASK mask );
 
 	// Returns x position of rightmost child, usually Help menu
 	S32 getRightmostMenuEdge();
@@ -837,11 +837,11 @@ public:
 
 	// LLView functionality
 	virtual void draw();
-	virtual BOOL handleMouseDown( S32 x, S32 y, MASK mask );
-	virtual BOOL handleRightMouseDown( S32 x, S32 y, MASK mask );
+	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 );
+	/*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(); }
diff --git a/indra/llui/llmodaldialog.cpp b/indra/llui/llmodaldialog.cpp
index 3e5978eb59..d3afbdb8ba 100644
--- a/indra/llui/llmodaldialog.cpp
+++ b/indra/llui/llmodaldialog.cpp
@@ -169,7 +169,7 @@ void LLModalDialog::setVisible( BOOL visible )
 	LLFloater::setVisible( visible );
 }
 
-BOOL LLModalDialog::handleMouseDown(S32 x, S32 y, MASK mask)
+bool LLModalDialog::handleMouseDown(S32 x, S32 y, MASK mask)
 {
 	LLView* popup_menu = LLMenuGL::sMenuContainer->getVisibleMenu();
 	if (popup_menu != NULL)
@@ -197,10 +197,10 @@ BOOL LLModalDialog::handleMouseDown(S32 x, S32 y, MASK mask)
 	}
 
 
-	return TRUE;
+	return true;
 }
 
-BOOL LLModalDialog::handleHover(S32 x, S32 y, MASK mask)		
+bool LLModalDialog::handleHover(S32 x, S32 y, MASK mask)
 { 
 	if( childrenHandleHover(x, y, mask) == NULL )
 	{
@@ -223,36 +223,36 @@ BOOL LLModalDialog::handleHover(S32 x, S32 y, MASK mask)
 		}
 	}
 
-	return TRUE;
+	return true;
 }
 
-BOOL LLModalDialog::handleMouseUp(S32 x, S32 y, MASK mask)
+bool LLModalDialog::handleMouseUp(S32 x, S32 y, MASK mask)
 {
 	childrenHandleMouseUp(x, y, mask);
-	return TRUE;
+	return true;
 }
 
-BOOL LLModalDialog::handleScrollWheel(S32 x, S32 y, S32 clicks)
+bool LLModalDialog::handleScrollWheel(S32 x, S32 y, S32 clicks)
 {
 	childrenHandleScrollWheel(x, y, clicks);
-	return TRUE;
+	return true;
 }
 
-BOOL LLModalDialog::handleDoubleClick(S32 x, S32 y, MASK mask)
+bool LLModalDialog::handleDoubleClick(S32 x, S32 y, MASK mask)
 {
 	if (!LLFloater::handleDoubleClick(x, y, mask))
 	{
 		// Click outside the panel
 		make_ui_sound("UISndInvalidOp");
 	}
-	return TRUE;
+	return true;
 }
 
-BOOL LLModalDialog::handleRightMouseDown(S32 x, S32 y, MASK mask)
+bool LLModalDialog::handleRightMouseDown(S32 x, S32 y, MASK mask)
 {
 	LLMenuGL::sMenuContainer->hideMenus();
 	childrenHandleRightMouseDown(x, y, mask);
-	return TRUE;
+	return true;
 }
 
 
diff --git a/indra/llui/llmodaldialog.h b/indra/llui/llmodaldialog.h
index f81273b96a..1c7f86a17e 100644
--- a/indra/llui/llmodaldialog.h
+++ b/indra/llui/llmodaldialog.h
@@ -49,12 +49,12 @@ public:
 	
 	/*virtual*/ void 	reshape(S32 width, S32 height, BOOL called_from_parent = TRUE);
 	
-	/*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*/ BOOL	handleScrollWheel(S32 x, S32 y, S32 clicks);
-	/*virtual*/ BOOL	handleDoubleClick(S32 x, S32 y, MASK mask);
-	/*virtual*/ BOOL	handleRightMouseDown(S32 x, S32 y, MASK mask);
+	/*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*/ bool	handleScrollWheel(S32 x, S32 y, S32 clicks);
+	/*virtual*/ bool	handleDoubleClick(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool	handleRightMouseDown(S32 x, S32 y, MASK mask);
 	/*virtual*/ BOOL	handleKeyHere(KEY key, MASK mask );
 
 	/*virtual*/ void	setVisible(BOOL visible);
diff --git a/indra/llui/llmultislider.cpp b/indra/llui/llmultislider.cpp
index 604d246f12..577e1f0a27 100644
--- a/indra/llui/llmultislider.cpp
+++ b/indra/llui/llmultislider.cpp
@@ -498,7 +498,7 @@ void LLMultiSlider::clear()
 	LLF32UICtrl::clear();
 }
 
-BOOL LLMultiSlider::handleHover(S32 x, S32 y, MASK mask)
+bool LLMultiSlider::handleHover(S32 x, S32 y, MASK mask)
 {
 	if( gFocusMgr.getMouseCapture() == this )
 	{
@@ -531,12 +531,12 @@ BOOL LLMultiSlider::handleHover(S32 x, S32 y, MASK mask)
 		getWindow()->setCursor(UI_CURSOR_ARROW);
 		LL_DEBUGS("UserInput") << "hover handled by " << getName() << " (inactive)" << LL_ENDL;		
 	}
-	return TRUE;
+	return true;
 }
 
-BOOL LLMultiSlider::handleMouseUp(S32 x, S32 y, MASK mask)
+bool LLMultiSlider::handleMouseUp(S32 x, S32 y, MASK mask)
 {
-	BOOL handled = FALSE;
+	bool handled = false;
 
 	if( gFocusMgr.getMouseCapture() == this )
 	{
@@ -545,23 +545,23 @@ BOOL LLMultiSlider::handleMouseUp(S32 x, S32 y, MASK mask)
 		if (mMouseUpSignal)
 			(*mMouseUpSignal)( this, LLSD() );
 
-		handled = TRUE;
+		handled = true;
 		make_ui_sound("UISndClickRelease");
 	}
 	else
 	{
-		handled = TRUE;
+		handled = true;
 	}
 
 	return handled;
 }
 
-BOOL LLMultiSlider::handleMouseDown(S32 x, S32 y, MASK mask)
+bool LLMultiSlider::handleMouseDown(S32 x, S32 y, MASK mask)
 {
 	// only do sticky-focus on non-chrome widgets
 	if (!getIsChrome())
 	{
-		setFocus(TRUE);
+		setFocus(true);
 	}
 	if (mMouseDownSignal)
 		(*mMouseDownSignal)( this, LLSD() );
@@ -611,7 +611,7 @@ BOOL LLMultiSlider::handleMouseDown(S32 x, S32 y, MASK mask)
 	}
 	make_ui_sound("UISndClick");
 
-	return TRUE;
+	return true;
 }
 
 BOOL	LLMultiSlider::handleKeyHere(KEY key, MASK mask)
diff --git a/indra/llui/llmultislider.h b/indra/llui/llmultislider.h
index 3cb4b760b0..b6eacd33f5 100644
--- a/indra/llui/llmultislider.h
+++ b/indra/llui/llmultislider.h
@@ -110,9 +110,9 @@ public:
 	void				deleteCurSlider()			{ deleteSlider(mCurSlider); }
 	/*virtual*/ void	clear() override;
 
-	/*virtual*/ BOOL	handleHover(S32 x, S32 y, MASK mask) override;
-	/*virtual*/ BOOL	handleMouseUp(S32 x, S32 y, MASK mask) override;
-	/*virtual*/ BOOL	handleMouseDown(S32 x, S32 y, MASK mask) override;
+	/*virtual*/ bool	handleHover(S32 x, S32 y, MASK mask) override;
+	/*virtual*/ bool	handleMouseUp(S32 x, S32 y, MASK mask) override;
+	/*virtual*/ bool	handleMouseDown(S32 x, S32 y, MASK mask) override;
 	/*virtual*/ BOOL	handleKeyHere(KEY key, MASK mask) override;
 	/*virtual*/ void	onMouseLeave(S32 x, S32 y, MASK mask) override;
 	/*virtual*/ void	draw() override;
diff --git a/indra/llui/llradiogroup.cpp b/indra/llui/llradiogroup.cpp
index 2c7e7ab13d..32ce5e5575 100644
--- a/indra/llui/llradiogroup.cpp
+++ b/indra/llui/llradiogroup.cpp
@@ -54,7 +54,7 @@ public:
 	/*virtual*/ void setValue(const LLSD& value);
 
 	/*virtual*/ BOOL postBuild();
-	/*virtual*/ BOOL handleMouseDown(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool handleMouseDown(S32 x, S32 y, MASK mask);
 
 	LLSD getPayload() { return mPayload; }
 
@@ -470,12 +470,12 @@ BOOL LLRadioCtrl::postBuild()
 	return TRUE;
 }
 
-BOOL LLRadioCtrl::handleMouseDown(S32 x, S32 y, MASK mask)
+bool LLRadioCtrl::handleMouseDown(S32 x, S32 y, MASK mask)
 {
     // Grab focus preemptively, before button takes mousecapture
     if (hasTabStop() && getEnabled())
     {
-        focusFirstItem(FALSE, FALSE);
+        focusFirstItem(false, false);
     }
     else
     {
diff --git a/indra/llui/llresizebar.cpp b/indra/llui/llresizebar.cpp
index 115c4e23be..c05a7dddf7 100644
--- a/indra/llui/llresizebar.cpp
+++ b/indra/llui/llresizebar.cpp
@@ -89,9 +89,9 @@ LLResizeBar::LLResizeBar(const LLResizeBar::Params& p)
 	}
 }
 
-BOOL LLResizeBar::handleMouseDown(S32 x, S32 y, MASK mask)
+bool LLResizeBar::handleMouseDown(S32 x, S32 y, MASK mask)
 {
-	if (!canResize()) return FALSE;
+	if (!canResize()) return false;
 
 	// Route future Mouse messages here preemptively.  (Release on mouse up.)
 	// No handler needed for focus lost since this clas has no state that depends on it.
@@ -101,31 +101,31 @@ BOOL LLResizeBar::handleMouseDown(S32 x, S32 y, MASK mask)
 	mLastMouseScreenX = mDragLastScreenX;
 	mLastMouseScreenY = mDragLastScreenY;
 
-	return TRUE;
+	return true;
 }
 
 
-BOOL LLResizeBar::handleMouseUp(S32 x, S32 y, MASK mask)
+bool LLResizeBar::handleMouseUp(S32 x, S32 y, MASK mask)
 {
-	BOOL	handled = FALSE;
+	bool	handled = false;
 
 	if( hasMouseCapture() )
 	{
 		// Release the mouse
 		gFocusMgr.setMouseCapture( NULL );
-		handled = TRUE;
+		handled = true;
 	}
 	else
 	{
-		handled = TRUE;
+		handled = true;
 	}
 	return handled;
 }
 
 
-BOOL LLResizeBar::handleHover(S32 x, S32 y, MASK mask)
+bool LLResizeBar::handleHover(S32 x, S32 y, MASK mask)
 {
-	BOOL	handled = FALSE;
+	bool	handled = false;
 
 	// We only handle the click if the click both started and ended within us
 	if( hasMouseCapture() )
@@ -289,11 +289,11 @@ BOOL LLResizeBar::handleHover(S32 x, S32 y, MASK mask)
 			}
 		}
 
-		handled = TRUE;
+		handled = true;
 	}
 	else
 	{
-		handled = TRUE;
+		handled = true;
 	}
 
 	if( handled && canResize() )
@@ -320,7 +320,7 @@ BOOL LLResizeBar::handleHover(S32 x, S32 y, MASK mask)
 	return handled;
 } // end LLResizeBar::handleHover
 
-BOOL LLResizeBar::handleDoubleClick(S32 x, S32 y, MASK mask)
+bool LLResizeBar::handleDoubleClick(S32 x, S32 y, MASK mask)
 {
 	LLRect orig_rect = mResizingView->getRect();
 	LLRect scaled_rect = orig_rect;
@@ -350,7 +350,7 @@ BOOL LLResizeBar::handleDoubleClick(S32 x, S32 y, MASK mask)
 		mResizingView->setShape(scaled_rect, true);
 	}
 
-	return TRUE;
+	return true;
 }
 
 void LLResizeBar::setImagePanel(LLPanel * panelp)
diff --git a/indra/llui/llresizebar.h b/indra/llui/llresizebar.h
index 20a2406484..71e3ec3094 100644
--- a/indra/llui/llresizebar.h
+++ b/indra/llui/llresizebar.h
@@ -53,10 +53,10 @@ protected:
 
 public:
 
-	virtual BOOL	handleHover(S32 x, S32 y, MASK mask);
-	virtual BOOL	handleMouseDown(S32 x, S32 y, MASK mask);
-	virtual BOOL	handleMouseUp(S32 x, S32 y, MASK mask);
-	virtual BOOL	handleDoubleClick(S32 x, S32 y, MASK mask);
+	virtual bool	handleHover(S32 x, S32 y, MASK mask);
+	virtual bool	handleMouseDown(S32 x, S32 y, MASK mask);
+	virtual bool	handleMouseUp(S32 x, S32 y, MASK mask);
+	virtual bool	handleDoubleClick(S32 x, S32 y, MASK mask);
 
 	void			setResizeLimits( S32 min_size, S32 max_size ) { mMinSize = min_size; mMaxSize = max_size; }
 	void			setEnableSnapping(BOOL enable) { mSnappingEnabled = enable; }
diff --git a/indra/llui/llresizehandle.cpp b/indra/llui/llresizehandle.cpp
index 13ef0fdb7f..b1f4a6c69d 100644
--- a/indra/llui/llresizehandle.cpp
+++ b/indra/llui/llresizehandle.cpp
@@ -76,12 +76,12 @@ LLResizeHandle::~LLResizeHandle()
 }
 
 
-BOOL LLResizeHandle::handleMouseDown(S32 x, S32 y, MASK mask)
+bool LLResizeHandle::handleMouseDown(S32 x, S32 y, MASK mask)
 {
-	BOOL handled = FALSE;
+	bool handled = false;
 	if( pointInHandle(x, y) )
 	{
-		handled = TRUE;
+		handled = true;
 		// Route future Mouse messages here preemptively.  (Release on mouse up.)
 		// No handler needed for focus lost since this clas has no state that depends on it.
 		gFocusMgr.setMouseCapture( this );
@@ -95,28 +95,28 @@ BOOL LLResizeHandle::handleMouseDown(S32 x, S32 y, MASK mask)
 }
 
 
-BOOL LLResizeHandle::handleMouseUp(S32 x, S32 y, MASK mask)
+bool LLResizeHandle::handleMouseUp(S32 x, S32 y, MASK mask)
 {
-	BOOL	handled = FALSE;
+	bool	handled = false;
 
 	if( hasMouseCapture() )
 	{
 		// Release the mouse
 		gFocusMgr.setMouseCapture( NULL );
-		handled = TRUE;
+		handled = true;
 	}
 	else if( pointInHandle(x, y) )
 	{
-		handled = TRUE;
+		handled = true;
 	}
 
 	return handled;
 }
 
 
-BOOL LLResizeHandle::handleHover(S32 x, S32 y, MASK mask)
+bool LLResizeHandle::handleHover(S32 x, S32 y, MASK mask)
 {
-	BOOL	handled = FALSE;
+	bool	handled = false;
 
 	// We only handle the click if the click both started and ended within us
 	if( hasMouseCapture() )
@@ -327,13 +327,13 @@ BOOL LLResizeHandle::handleHover(S32 x, S32 y, MASK mask)
 			}
 		}
 
-		handled = TRUE;
+		handled = true;
 	}
 	else // don't have mouse capture
 	{
 		if( pointInHandle( x, y ) )
 		{
-			handled = TRUE;
+			handled = true;
 		}
 	}
 
diff --git a/indra/llui/llresizehandle.h b/indra/llui/llresizehandle.h
index ae20ecaa77..d82934f75b 100644
--- a/indra/llui/llresizehandle.h
+++ b/indra/llui/llresizehandle.h
@@ -51,9 +51,9 @@ protected:
 	friend class LLUICtrlFactory;
 public:
 	virtual void	draw();
-	virtual BOOL	handleHover(S32 x, S32 y, MASK mask);
-	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 bool	handleMouseDown(S32 x, S32 y, MASK mask);
+	virtual bool	handleMouseUp(S32 x, S32 y, MASK mask);
 
 	void			setResizeLimits( S32 min_width, S32 min_height ) { mMinWidth = min_width; mMinHeight = min_height; }
 	
diff --git a/indra/llui/llscrollbar.cpp b/indra/llui/llscrollbar.cpp
index 735e2d529e..2cc0644d90 100644
--- a/indra/llui/llscrollbar.cpp
+++ b/indra/llui/llscrollbar.cpp
@@ -238,10 +238,10 @@ void LLScrollbar::updateThumbRect()
 	}
 }
 
-BOOL LLScrollbar::handleMouseDown(S32 x, S32 y, MASK mask)
+bool LLScrollbar::handleMouseDown(S32 x, S32 y, MASK mask)
 {
 	// Check children first
-	BOOL handled_by_child = LLView::childrenHandleMouseDown(x, y, mask) != NULL;
+	bool handled_by_child = LLView::childrenHandleMouseDown(x, y, mask) != NULL;
 	if( !handled_by_child )
 	{
 		if( mThumbRect.pointInRect(x,y) )
@@ -279,16 +279,16 @@ BOOL LLScrollbar::handleMouseDown(S32 x, S32 y, MASK mask)
 		}
 	}
 
-	return TRUE;
+	return true;
 }
 
 
-BOOL LLScrollbar::handleHover(S32 x, S32 y, MASK mask)
+bool LLScrollbar::handleHover(S32 x, S32 y, MASK mask)
 {
 	// Note: we don't bother sending the event to the children (the arrow buttons)
 	// because they'll capture the mouse whenever they need hover events.
 	
-	BOOL handled = FALSE;
+	bool handled = false;
 	if( hasMouseCapture() )
 	{
 		S32 height = getRect().getHeight();
@@ -382,7 +382,7 @@ BOOL LLScrollbar::handleHover(S32 x, S32 y, MASK mask)
 
 		getWindow()->setCursor(UI_CURSOR_ARROW);
 		LL_DEBUGS("UserInput") << "hover handled by " << getName() << " (active)" << LL_ENDL;		
-		handled = TRUE;
+		handled = true;
 	}
 	else
 	{
@@ -394,26 +394,26 @@ BOOL LLScrollbar::handleHover(S32 x, S32 y, MASK mask)
 	{
 		getWindow()->setCursor(UI_CURSOR_ARROW);
 		LL_DEBUGS("UserInput") << "hover handled by " << getName() << " (inactive)"  << LL_ENDL;		
-		handled = TRUE;
+		handled = true;
 	}
 
-	mDocChanged = FALSE;
+	mDocChanged = false;
 	return handled;
 } // end handleHover
 
 
-BOOL LLScrollbar::handleScrollWheel(S32 x, S32 y, S32 clicks)
+bool LLScrollbar::handleScrollWheel(S32 x, S32 y, S32 clicks)
 {
-	BOOL handled = changeLine( clicks * mStepSize, TRUE );
+	bool handled = changeLine( clicks * mStepSize, true );
 	return handled;
 }
 
-BOOL LLScrollbar::handleScrollHWheel(S32 x, S32 y, S32 clicks)
+bool LLScrollbar::handleScrollHWheel(S32 x, S32 y, S32 clicks)
 {
-	BOOL handled = FALSE;
+	bool handled = FALSE;
 	if (LLScrollbar::HORIZONTAL == mOrientation)
 	{
-		handled = changeLine(clicks * mStepSize, TRUE);
+		handled = changeLine(clicks * mStepSize, true);
 	}
 	return handled;
 }
@@ -440,13 +440,13 @@ BOOL LLScrollbar::handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
 	return FALSE;
 }
 
-BOOL LLScrollbar::handleMouseUp(S32 x, S32 y, MASK mask)
+bool LLScrollbar::handleMouseUp(S32 x, S32 y, MASK mask)
 {
-	BOOL handled = FALSE;
+	bool handled = false;
 	if( hasMouseCapture() )
 	{
 		gFocusMgr.setMouseCapture( NULL );
-		handled = TRUE;
+		handled = true;
 	}
 	else
 	{
@@ -457,7 +457,7 @@ BOOL LLScrollbar::handleMouseUp(S32 x, S32 y, MASK mask)
 	return handled;
 }
 
-BOOL LLScrollbar::handleDoubleClick(S32 x, S32 y, MASK mask)
+bool LLScrollbar::handleDoubleClick(S32 x, S32 y, MASK mask)
 {
 	// just treat a double click as a second click
 	return handleMouseDown(x, y, mask);
diff --git a/indra/llui/llscrollbar.h b/indra/llui/llscrollbar.h
index 9be9d22db8..82607f2dd0 100644
--- a/indra/llui/llscrollbar.h
+++ b/indra/llui/llscrollbar.h
@@ -83,12 +83,12 @@ public:
 
 	// Overrides from LLView
 	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	handleDoubleClick(S32 x, S32 y, MASK mask);
-	virtual BOOL	handleHover(S32 x, S32 y, MASK mask);
-	virtual BOOL	handleScrollWheel(S32 x, S32 y, S32 clicks);
-	virtual BOOL	handleScrollHWheel(S32 x, S32 y, S32 clicks);
+	virtual bool	handleMouseDown(S32 x, S32 y, MASK mask);
+	virtual bool	handleMouseUp(S32 x, S32 y, MASK mask);
+	virtual bool	handleDoubleClick(S32 x, S32 y, MASK mask);
+	virtual bool	handleHover(S32 x, S32 y, MASK mask);
+	virtual bool	handleScrollWheel(S32 x, S32 y, S32 clicks);
+	virtual bool	handleScrollHWheel(S32 x, S32 y, S32 clicks);
 	virtual BOOL	handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop, 
 		EDragAndDropType cargo_type, void *cargo_data, EAcceptance *accept, std::string &tooltip_msg);
 
diff --git a/indra/llui/llscrollcontainer.cpp b/indra/llui/llscrollcontainer.cpp
index ad32f7186c..48b55a1d87 100644
--- a/indra/llui/llscrollcontainer.cpp
+++ b/indra/llui/llscrollcontainer.cpp
@@ -227,21 +227,21 @@ BOOL LLScrollContainer::handleKeyHere(KEY key, MASK mask)
 	return FALSE;
 }
 
-BOOL LLScrollContainer::handleUnicodeCharHere(llwchar uni_char)
+bool LLScrollContainer::handleUnicodeCharHere(llwchar uni_char)
 {
 	if (mScrolledView && mScrolledView->handleUnicodeCharHere(uni_char))
 	{
-		return TRUE;
+		return true;
 	}
-	return FALSE;
+	return false;
 }
 
-BOOL LLScrollContainer::handleScrollWheel( S32 x, S32 y, S32 clicks )
+bool LLScrollContainer::handleScrollWheel( S32 x, S32 y, S32 clicks )
 {
 	// Give event to my child views - they may have scroll bars
 	// (Bad UI design, but technically possible.)
 	if (LLUICtrl::handleScrollWheel(x,y,clicks))
-		return TRUE;
+		return true;
 
 	// When the vertical scrollbar is visible, scroll wheel
 	// only affects vertical scrolling.  It's confusing to have
@@ -257,7 +257,7 @@ BOOL LLScrollContainer::handleScrollWheel( S32 x, S32 y, S32 clicks )
 			updateScroll();
 		}
 		// Always eat the event
-		return TRUE;
+		return true;
 	}
 
 	LLScrollbar* horizontal = mScrollbar[HORIZONTAL];
@@ -268,16 +268,16 @@ BOOL LLScrollContainer::handleScrollWheel( S32 x, S32 y, S32 clicks )
 		&& horizontal->handleScrollWheel( 0, 0, clicks ) )
 	{
 		updateScroll();
-		return TRUE;
+		return true;
 	}
-	return FALSE;
+	return false;
 }
 
-BOOL LLScrollContainer::handleScrollHWheel(S32 x, S32 y, S32 clicks)
+bool LLScrollContainer::handleScrollHWheel(S32 x, S32 y, S32 clicks)
 {
 	if (LLUICtrl::handleScrollHWheel(x,y,clicks))
 	{
-		return TRUE;
+		return true;
 	}
 
 	LLScrollbar* horizontal = mScrollbar[HORIZONTAL];
@@ -286,10 +286,10 @@ BOOL LLScrollContainer::handleScrollHWheel(S32 x, S32 y, S32 clicks)
 		&& horizontal->handleScrollHWheel( 0, 0, clicks ) )
 	{
 		updateScroll();
-		return TRUE;
+		return true;
 	}
 
-	return FALSE;
+	return false;
 }
 
 BOOL LLScrollContainer::handleDragAndDrop(S32 x, S32 y, MASK mask,
diff --git a/indra/llui/llscrollcontainer.h b/indra/llui/llscrollcontainer.h
index dacea2a987..2875f95526 100644
--- a/indra/llui/llscrollcontainer.h
+++ b/indra/llui/llscrollcontainer.h
@@ -107,9 +107,9 @@ public:
 	// LLView functionality
 	virtual void	reshape(S32 width, S32 height, BOOL called_from_parent = TRUE);
 	virtual BOOL	handleKeyHere(KEY key, MASK mask);
-	virtual BOOL	handleUnicodeCharHere(llwchar uni_char);
-	virtual BOOL	handleScrollWheel( S32 x, S32 y, S32 clicks );
-	virtual BOOL	handleScrollHWheel( S32 x, S32 y, S32 clicks );
+	virtual bool	handleUnicodeCharHere(llwchar uni_char);
+	virtual bool	handleScrollWheel( S32 x, S32 y, S32 clicks );
+	virtual bool	handleScrollHWheel( S32 x, S32 y, S32 clicks );
 	virtual BOOL	handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
 								   EDragAndDropType cargo_type,
 								   void* cargo_data,
diff --git a/indra/llui/llscrolllistcolumn.cpp b/indra/llui/llscrolllistcolumn.cpp
index 82b0415624..3dff93af98 100644
--- a/indra/llui/llscrolllistcolumn.cpp
+++ b/indra/llui/llscrolllistcolumn.cpp
@@ -93,7 +93,7 @@ void LLScrollColumnHeader::draw()
 	LLButton::draw();
 }
 
-BOOL LLScrollColumnHeader::handleDoubleClick(S32 x, S32 y, MASK mask)
+bool LLScrollColumnHeader::handleDoubleClick(S32 x, S32 y, MASK mask)
 {
 	if (canResize() && mResizeBar->getRect().pointInRect(x, y))
 	{
@@ -107,7 +107,7 @@ BOOL LLScrollColumnHeader::handleDoubleClick(S32 x, S32 y, MASK mask)
 	{
 		onClick(LLSD());
 	}
-	return TRUE;
+	return true;
 }
 
 void LLScrollColumnHeader::onClick(const LLSD& data)
diff --git a/indra/llui/llscrolllistcolumn.h b/indra/llui/llscrolllistcolumn.h
index b4d4a6d05e..1699c3d4e9 100644
--- a/indra/llui/llscrolllistcolumn.h
+++ b/indra/llui/llscrolllistcolumn.h
@@ -50,7 +50,7 @@ public:
 	~LLScrollColumnHeader();
 
 	/*virtual*/ void draw();
-	/*virtual*/ BOOL handleDoubleClick(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool handleDoubleClick(S32 x, S32 y, MASK mask);
 
 	/*virtual*/ LLView*	findSnapEdge(S32& new_edge_val, const LLCoordGL& mouse_dir, ESnapEdge snap_edge, ESnapType snap_type, S32 threshold, S32 padding);
 	/*virtual*/ void handleReshape(const LLRect& new_rect, bool by_user = false);
diff --git a/indra/llui/llscrolllistctrl.cpp b/indra/llui/llscrolllistctrl.cpp
index 219667f766..56873ec11a 100644
--- a/indra/llui/llscrolllistctrl.cpp
+++ b/indra/llui/llscrolllistctrl.cpp
@@ -1743,29 +1743,29 @@ void LLScrollListCtrl::setEnabled(BOOL enabled)
 	mScrollbar->setTabStop(!enabled && mScrollbar->getPageSize() < mScrollbar->getDocSize());
 }
 
-BOOL LLScrollListCtrl::handleScrollWheel(S32 x, S32 y, S32 clicks)
+bool LLScrollListCtrl::handleScrollWheel(S32 x, S32 y, S32 clicks)
 {
-	BOOL handled = FALSE;
+	bool handled = false;
 	// Pretend the mouse is over the scrollbar
 	handled = mScrollbar->handleScrollWheel( 0, 0, clicks );
 
 	if (mMouseWheelOpaque)
 	{
-		return TRUE;
+		return true;
 	}
 
 	return handled;
 }
 
-BOOL LLScrollListCtrl::handleScrollHWheel(S32 x, S32 y, S32 clicks)
+bool LLScrollListCtrl::handleScrollHWheel(S32 x, S32 y, S32 clicks)
 {
-	BOOL handled = FALSE;
+	bool handled = false;
 	// Pretend the mouse is over the scrollbar
 	handled = mScrollbar->handleScrollHWheel( 0, 0, clicks );
 
 	if (mMouseWheelOpaque)
 	{
-		return TRUE;
+		return true;
 	}
 
 	return handled;
@@ -1783,20 +1783,20 @@ LLRect LLScrollListCtrl::getCellRect(S32 row_index, S32 column_index)
 	return cell_rect;
 }
 
-BOOL LLScrollListCtrl::handleToolTip(S32 x, S32 y, MASK mask)
+bool LLScrollListCtrl::handleToolTip(S32 x, S32 y, MASK mask)
 {
 	S32 column_index = getColumnIndexFromOffset(x);
 	LLScrollListColumn* columnp = getColumn(column_index);
 
-	if (columnp == NULL) return FALSE;
+	if (columnp == NULL) return false;
 
-	BOOL handled = FALSE;
+	bool handled = false;
 	// show tooltip for full name of hovered item if it has been truncated
 	LLScrollListItem* hit_item = hitItem(x, y);
 	if (hit_item)
 	{
 		LLScrollListCell* hit_cell = hit_item->getColumn(column_index);
-		if (!hit_cell) return FALSE;
+		if (!hit_cell) return false;
 		if (hit_cell 
 			&& hit_cell->isText()
 			&& hit_cell->needsToolTip())
@@ -1815,7 +1815,7 @@ BOOL LLScrollListCtrl::handleToolTip(S32 x, S32 y, MASK mask)
 										.delay_time(0.2f)
 										.sticky_rect(sticky_rect));		
 		}
-		handled = TRUE;
+		handled = true;
 	}
 
 	// otherwise, look for a tooltip associated with this column
@@ -1934,14 +1934,14 @@ BOOL LLScrollListCtrl::selectItemAt(S32 x, S32 y, MASK mask)
 }
 
 
-BOOL LLScrollListCtrl::handleMouseDown(S32 x, S32 y, MASK mask)
+bool LLScrollListCtrl::handleMouseDown(S32 x, S32 y, MASK mask)
 {
-	BOOL handled = childrenHandleMouseDown(x, y, mask) != NULL;
+	bool handled = childrenHandleMouseDown(x, y, mask) != NULL;
 
 	if( !handled )
 	{
 		// set keyboard focus first, in case click action wants to move focus elsewhere
-		setFocus(TRUE);
+		setFocus(true);
 
 		// clear selection changed flag because user is starting a selection operation
 		mSelectionChanged = false;
@@ -1952,7 +1952,7 @@ BOOL LLScrollListCtrl::handleMouseDown(S32 x, S32 y, MASK mask)
 	return TRUE;
 }
 
-BOOL LLScrollListCtrl::handleMouseUp(S32 x, S32 y, MASK mask)
+bool LLScrollListCtrl::handleMouseUp(S32 x, S32 y, MASK mask)
 {	
 	if (hasMouseCapture())
 	{
@@ -1978,7 +1978,7 @@ BOOL LLScrollListCtrl::handleMouseUp(S32 x, S32 y, MASK mask)
 }
 
 // virtual
-BOOL LLScrollListCtrl::handleRightMouseDown(S32 x, S32 y, MASK mask)
+bool LLScrollListCtrl::handleRightMouseDown(S32 x, S32 y, MASK mask)
 {
 	LLScrollListItem *item = hitItem(x, y);
 	if (item)
@@ -2035,7 +2035,7 @@ BOOL LLScrollListCtrl::handleRightMouseDown(S32 x, S32 y, MASK mask)
 		}
 		return LLUICtrl::handleRightMouseDown(x, y, mask);
 	}
-	return FALSE;
+	return false;
 }
 
 void LLScrollListCtrl::showProfile(std::string id, bool is_group)
@@ -2108,10 +2108,10 @@ void LLScrollListCtrl::copySLURLToClipboard(std::string id, bool is_group)
 	LLUrlAction::copyURLToClipboard(slurl);
 }
 
-BOOL LLScrollListCtrl::handleDoubleClick(S32 x, S32 y, MASK mask)
+bool LLScrollListCtrl::handleDoubleClick(S32 x, S32 y, MASK mask)
 {
 	//BOOL handled = FALSE;
-	BOOL handled = handleClick(x, y, mask);
+	bool handled = handleClick(x, y, mask);
 
 	if (!handled)
 	{
@@ -2127,7 +2127,7 @@ BOOL LLScrollListCtrl::handleDoubleClick(S32 x, S32 y, MASK mask)
 		}
 	}
 
-	return TRUE;
+	return true;
 }
 
 BOOL LLScrollListCtrl::handleClick(S32 x, S32 y, MASK mask)
@@ -2279,9 +2279,9 @@ S32 LLScrollListCtrl::getRowOffsetFromIndex(S32 index)
 }
 
 
-BOOL LLScrollListCtrl::handleHover(S32 x,S32 y,MASK mask)
+bool LLScrollListCtrl::handleHover(S32 x,S32 y,MASK mask)
 {
-	BOOL	handled = FALSE;
+	bool	handled = false;
 
 	if (hasMouseCapture())
 	{
@@ -2521,11 +2521,11 @@ BOOL LLScrollListCtrl::handleKeyHere(KEY key,MASK mask )
 	return handled;
 }
 
-BOOL LLScrollListCtrl::handleUnicodeCharHere(llwchar uni_char)
+bool LLScrollListCtrl::handleUnicodeCharHere(llwchar uni_char)
 {
 	if ((uni_char < 0x20) || (uni_char == 0x7F)) // Control character or DEL
 	{
-		return FALSE;
+		return false;
 	}
 
 	// perform incremental search based on keyboard input
@@ -2538,7 +2538,7 @@ BOOL LLScrollListCtrl::handleUnicodeCharHere(llwchar uni_char)
 	// type ahead search is case insensitive
 	uni_char = LLStringOps::toLower((llwchar)uni_char);
 
-	if (selectItemByPrefix(wstring_to_utf8str(mSearchString + (llwchar)uni_char), FALSE))
+	if (selectItemByPrefix(wstring_to_utf8str(mSearchString + (llwchar)uni_char), false))
 	{
 		// update search string only on successful match
 		mNeedsScroll = true;
@@ -2609,7 +2609,7 @@ BOOL LLScrollListCtrl::handleUnicodeCharHere(llwchar uni_char)
 		}
 	}
 
-	return TRUE;
+	return true;
 }
 
 
diff --git a/indra/llui/llscrolllistctrl.h b/indra/llui/llscrolllistctrl.h
index 73b4fb036a..a121913579 100644
--- a/indra/llui/llscrolllistctrl.h
+++ b/indra/llui/llscrolllistctrl.h
@@ -337,16 +337,16 @@ public:
 
 	// Overridden from LLView
 	/*virtual*/ void    draw();
-	/*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	handleDoubleClick(S32 x, S32 y, MASK mask);
-	/*virtual*/ BOOL	handleHover(S32 x, S32 y, MASK mask);
+	/*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	handleDoubleClick(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool	handleHover(S32 x, S32 y, MASK mask);
 	/*virtual*/ BOOL	handleKeyHere(KEY key, MASK mask);
-	/*virtual*/ BOOL	handleUnicodeCharHere(llwchar uni_char);
-	/*virtual*/ BOOL	handleScrollWheel(S32 x, S32 y, S32 clicks);
-	/*virtual*/ BOOL	handleScrollHWheel(S32 x, S32 y, S32 clicks);
-	/*virtual*/ BOOL	handleToolTip(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool	handleUnicodeCharHere(llwchar uni_char);
+	/*virtual*/ bool	handleScrollWheel(S32 x, S32 y, S32 clicks);
+	/*virtual*/ bool	handleScrollHWheel(S32 x, S32 y, S32 clicks);
+	/*virtual*/ bool	handleToolTip(S32 x, S32 y, MASK mask);
 	/*virtual*/ void	setEnabled(BOOL enabled);
 	/*virtual*/ void	setFocus( BOOL b );
 	/*virtual*/ void	onFocusReceived();
diff --git a/indra/llui/llslider.cpp b/indra/llui/llslider.cpp
index 62df5a2c38..e759e7716e 100644
--- a/indra/llui/llslider.cpp
+++ b/indra/llui/llslider.cpp
@@ -157,7 +157,7 @@ void LLSlider::setValueAndCommit(F32 value)
 }
 
 
-BOOL LLSlider::handleHover(S32 x, S32 y, MASK mask)
+bool LLSlider::handleHover(S32 x, S32 y, MASK mask)
 {
 	if( hasMouseCapture() )
 	{
@@ -193,12 +193,12 @@ BOOL LLSlider::handleHover(S32 x, S32 y, MASK mask)
 		getWindow()->setCursor(UI_CURSOR_ARROW);
 		LL_DEBUGS("UserInput") << "hover handled by " << getName() << " (inactive)" << LL_ENDL;		
 	}
-	return TRUE;
+	return true;
 }
 
-BOOL LLSlider::handleMouseUp(S32 x, S32 y, MASK mask)
+bool LLSlider::handleMouseUp(S32 x, S32 y, MASK mask)
 {
-	BOOL handled = FALSE;
+	bool handled = false;
 
 	if( hasMouseCapture() )
 	{
@@ -207,23 +207,23 @@ BOOL LLSlider::handleMouseUp(S32 x, S32 y, MASK mask)
 		if (mMouseUpSignal)
 			(*mMouseUpSignal)( this, getValueF32() );
 
-		handled = TRUE;
+		handled = true;
 		make_ui_sound("UISndClickRelease");
 	}
 	else
 	{
-		handled = TRUE;
+		handled = true;
 	}
 
 	return handled;
 }
 
-BOOL LLSlider::handleMouseDown(S32 x, S32 y, MASK mask)
+bool LLSlider::handleMouseDown(S32 x, S32 y, MASK mask)
 {
 	// only do sticky-focus on non-chrome widgets
 	if (!getIsChrome())
 	{
-		setFocus(TRUE);
+		setFocus(true);
 	}
 	if (mMouseDownSignal)
 		(*mMouseDownSignal)( this, getValueF32() );
@@ -253,7 +253,7 @@ BOOL LLSlider::handleMouseDown(S32 x, S32 y, MASK mask)
 	}
 	make_ui_sound("UISndClick");
 
-	return TRUE;
+	return true;
 }
 
 BOOL LLSlider::handleKeyHere(KEY key, MASK mask)
@@ -277,13 +277,13 @@ BOOL LLSlider::handleKeyHere(KEY key, MASK mask)
 	return handled;
 }
 
-BOOL LLSlider::handleScrollWheel(S32 x, S32 y, S32 clicks)
+bool LLSlider::handleScrollWheel(S32 x, S32 y, S32 clicks)
 {
 	if ( mOrientation == VERTICAL )
 	{
 		F32 new_val = getValueF32() - clicks * getIncrement();
 		setValueAndCommit(new_val);
-		return TRUE;
+		return true;
 	}
 	return LLF32UICtrl::handleScrollWheel(x,y,clicks);
 }
diff --git a/indra/llui/llslider.h b/indra/llui/llslider.h
index 484a5373b3..ad3df1da82 100644
--- a/indra/llui/llslider.h
+++ b/indra/llui/llslider.h
@@ -72,11 +72,11 @@ public:
 	boost::signals2::connection setMouseDownCallback( const commit_signal_t::slot_type& cb );
 	boost::signals2::connection setMouseUpCallback(	const commit_signal_t::slot_type& cb );
 
-	virtual BOOL	handleHover(S32 x, S32 y, MASK mask);
-	virtual BOOL	handleMouseUp(S32 x, S32 y, MASK mask);
-	virtual BOOL	handleMouseDown(S32 x, S32 y, MASK mask);
+	virtual bool	handleHover(S32 x, S32 y, MASK mask);
+	virtual bool	handleMouseUp(S32 x, S32 y, MASK mask);
+	virtual bool	handleMouseDown(S32 x, S32 y, MASK mask);
 	virtual BOOL	handleKeyHere(KEY key, MASK mask);
-	virtual BOOL	handleScrollWheel(S32 x, S32 y, S32 clicks);
+	virtual bool	handleScrollWheel(S32 x, S32 y, S32 clicks);
 	virtual void	draw();
 
 private:
diff --git a/indra/llui/llspinctrl.cpp b/indra/llui/llspinctrl.cpp
index c411aafb1a..3a3ecb2d85 100644
--- a/indra/llui/llspinctrl.cpp
+++ b/indra/llui/llspinctrl.cpp
@@ -457,7 +457,7 @@ void LLSpinCtrl::reportInvalidData()
 	make_ui_sound("UISndBadKeystroke");
 }
 
-BOOL LLSpinCtrl::handleScrollWheel(S32 x, S32 y, S32 clicks)
+bool LLSpinCtrl::handleScrollWheel(S32 x, S32 y, S32 clicks)
 {
 	if( clicks > 0 )
 	{
@@ -472,7 +472,7 @@ BOOL LLSpinCtrl::handleScrollWheel(S32 x, S32 y, S32 clicks)
 		onUpBtn(getValue());
 	}
 
-	return TRUE;
+	return true;
 }
 
 BOOL LLSpinCtrl::handleKeyHere(KEY key, MASK mask)
diff --git a/indra/llui/llspinctrl.h b/indra/llui/llspinctrl.h
index cab99c35bd..8d22693021 100644
--- a/indra/llui/llspinctrl.h
+++ b/indra/llui/llspinctrl.h
@@ -88,7 +88,7 @@ public:
 
 	void 			forceEditorCommit();			// for commit on external button
 
-	virtual BOOL	handleScrollWheel(S32 x,S32 y,S32 clicks);
+	virtual bool	handleScrollWheel(S32 x,S32 y,S32 clicks);
 	virtual BOOL	handleKeyHere(KEY key, MASK mask);
 
 	void			onEditorCommit(const LLSD& data);
diff --git a/indra/llui/llstatbar.cpp b/indra/llui/llstatbar.cpp
index 2449100952..1ddb15473a 100644
--- a/indra/llui/llstatbar.cpp
+++ b/indra/llui/llstatbar.cpp
@@ -209,7 +209,7 @@ LLStatBar::LLStatBar(const Params& p)
 	setStat(p.stat);
 }
 
-BOOL LLStatBar::handleHover(S32 x, S32 y, MASK mask)
+bool LLStatBar::handleHover(S32 x, S32 y, MASK mask)
 {
 	switch(mStatType)
 	{
@@ -228,38 +228,38 @@ BOOL LLStatBar::handleHover(S32 x, S32 y, MASK mask)
 	default:
 		break;
 	}
-	return TRUE;
+	return true;
 }
 
-BOOL LLStatBar::handleMouseDown(S32 x, S32 y, MASK mask)
+bool LLStatBar::handleMouseDown(S32 x, S32 y, MASK mask)
 {
-	BOOL handled = LLView::handleMouseDown(x, y, mask);
+	bool handled = LLView::handleMouseDown(x, y, mask);
 	if (!handled)
 	{
 		if (mDisplayBar)
 		{
 			if (mDisplayHistory || mOrientation == HORIZONTAL)
 			{
-				mDisplayBar = FALSE;
-				mDisplayHistory = FALSE;
+				mDisplayBar = false;
+				mDisplayHistory = false;
 			}
 			else
 			{
-				mDisplayHistory = TRUE;
+				mDisplayHistory = true;
 			}
 		}
 		else
 		{
-			mDisplayBar = TRUE;
+			mDisplayBar = true;
 			if (mOrientation == HORIZONTAL)
 			{
-				mDisplayHistory = TRUE;
+				mDisplayHistory = true;
 			}
 		}
 		LLView* parent = getParent();
-		parent->reshape(parent->getRect().getWidth(), parent->getRect().getHeight(), FALSE);
+		parent->reshape(parent->getRect().getWidth(), parent->getRect().getHeight(), false);
 	}
-	return TRUE;
+	return true;
 }
 
 template<typename T>
diff --git a/indra/llui/llstatbar.h b/indra/llui/llstatbar.h
index 6b481ca68f..8c74aaf4ad 100644
--- a/indra/llui/llstatbar.h
+++ b/indra/llui/llstatbar.h
@@ -61,8 +61,8 @@ public:
 	LLStatBar(const Params&);
 
 	virtual void draw();
-	virtual BOOL handleMouseDown(S32 x, S32 y, MASK mask);
-	virtual BOOL handleHover(S32 x, S32 y, MASK mask);
+	virtual bool handleMouseDown(S32 x, S32 y, MASK mask);
+	virtual bool handleHover(S32 x, S32 y, MASK mask);
 
 	void setStat(const std::string& stat_name);
 
diff --git a/indra/llui/lltabcontainer.cpp b/indra/llui/lltabcontainer.cpp
index cb36f72f6e..512b2a9a30 100644
--- a/indra/llui/lltabcontainer.cpp
+++ b/indra/llui/lltabcontainer.cpp
@@ -541,11 +541,11 @@ void LLTabContainer::draw()
 
 
 // virtual
-BOOL LLTabContainer::handleMouseDown( S32 x, S32 y, MASK mask )
+bool LLTabContainer::handleMouseDown( S32 x, S32 y, MASK mask )
 {
 	static LLUICachedControl<S32> tabcntrv_pad ("UITabCntrvPad", 0);
-	BOOL handled = FALSE;
-	BOOL has_scroll_arrows = !mHideScrollArrows && (getMaxScrollPos() > 0) && !getTabsHidden();
+	bool handled = false;
+	bool has_scroll_arrows = !mHideScrollArrows && (getMaxScrollPos() > 0) && !getTabsHidden();
 
 	if (has_scroll_arrows)
 	{
@@ -617,10 +617,10 @@ BOOL LLTabContainer::handleMouseDown( S32 x, S32 y, MASK mask )
 }
 
 // virtual
-BOOL LLTabContainer::handleHover( S32 x, S32 y, MASK mask )
+bool LLTabContainer::handleHover( S32 x, S32 y, MASK mask )
 {
-	BOOL handled = FALSE;
-	BOOL has_scroll_arrows = !mHideScrollArrows && (getMaxScrollPos() > 0) && !getTabsHidden();
+	bool handled = false;
+	bool has_scroll_arrows = !mHideScrollArrows && (getMaxScrollPos() > 0) && !getTabsHidden();
 
 	if (has_scroll_arrows)
 	{
@@ -663,10 +663,10 @@ BOOL LLTabContainer::handleHover( S32 x, S32 y, MASK mask )
 }
 
 // virtual
-BOOL LLTabContainer::handleMouseUp( S32 x, S32 y, MASK mask )
+bool LLTabContainer::handleMouseUp( S32 x, S32 y, MASK mask )
 {
-	BOOL handled = FALSE;
-	BOOL has_scroll_arrows = !mHideScrollArrows && (getMaxScrollPos() > 0)  && !getTabsHidden();
+	bool handled = false;
+	bool has_scroll_arrows = !mHideScrollArrows && (getMaxScrollPos() > 0)  && !getTabsHidden();
 
 	S32 local_x = x - getRect().mLeft;
 	S32 local_y = y - getRect().mBottom;
@@ -710,11 +710,11 @@ BOOL LLTabContainer::handleMouseUp( S32 x, S32 y, MASK mask )
 	{
 		if (cur_panel)
 		{
-			if (!cur_panel->focusFirstItem(FALSE))
+			if (!cur_panel->focusFirstItem(false))
 			{
 				// if nothing in the panel gets focus, make sure the new tab does
 				// otherwise the last tab might keep focus
-				getTab(getCurrentPanelIndex())->mButton->setFocus(TRUE);
+				getTab(getCurrentPanelIndex())->mButton->setFocus(true);
 			}
 		}
 		gFocusMgr.setMouseCapture(NULL);
@@ -727,15 +727,15 @@ BOOL LLTabContainer::handleMouseUp( S32 x, S32 y, MASK mask )
 }
 
 // virtual
-BOOL LLTabContainer::handleToolTip( S32 x, S32 y, MASK mask)
+bool LLTabContainer::handleToolTip( S32 x, S32 y, MASK mask)
 {
 	static LLUICachedControl<S32> tabcntrv_pad ("UITabCntrvPad", 0);
-	BOOL handled = LLPanel::handleToolTip( x, y, mask);
+	bool handled = LLPanel::handleToolTip( x, y, mask);
 	if (!handled && getTabCount() > 0 && !getTabsHidden()) 
 	{
 		LLTabTuple* firsttuple = getTab(0);
 
-		BOOL has_scroll_arrows = !mHideScrollArrows && (getMaxScrollPos() > 0);
+		bool has_scroll_arrows = !mHideScrollArrows && (getMaxScrollPos() > 0);
 		LLRect clip;
 		if (mIsVertical)
 		{
diff --git a/indra/llui/lltabcontainer.h b/indra/llui/lltabcontainer.h
index aa4a08c4ff..1615d72758 100644
--- a/indra/llui/lltabcontainer.h
+++ b/indra/llui/lltabcontainer.h
@@ -139,10 +139,10 @@ public:
 
 	/*virtual*/ void reshape(S32 width, S32 height, BOOL called_from_parent = TRUE);
 	/*virtual*/ void draw();
-	/*virtual*/ BOOL handleMouseDown( S32 x, S32 y, MASK mask );
-	/*virtual*/ BOOL handleHover( S32 x, S32 y, MASK mask );
-	/*virtual*/ BOOL handleMouseUp( S32 x, S32 y, MASK mask );
-	/*virtual*/ BOOL handleToolTip(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool handleMouseDown( S32 x, S32 y, MASK mask );
+	/*virtual*/ bool handleHover( S32 x, S32 y, MASK mask );
+	/*virtual*/ bool handleMouseUp( S32 x, S32 y, MASK mask );
+	/*virtual*/ bool handleToolTip(S32 x, S32 y, MASK mask);
 	/*virtual*/ BOOL handleKeyHere(KEY key, MASK mask);
 	/*virtual*/ BOOL handleDragAndDrop(S32 x, S32 y, MASK mask,	BOOL drop,
 									   EDragAndDropType type, void* cargo_data,
diff --git a/indra/llui/lltextbase.cpp b/indra/llui/lltextbase.cpp
index e0697cb454..d53e7154ba 100644
--- a/indra/llui/lltextbase.cpp
+++ b/indra/llui/lltextbase.cpp
@@ -1079,14 +1079,14 @@ void LLTextBase::insertSegment(LLTextSegmentPtr segment_to_insert)
 	needsReflow(reflow_start_index);
 }
 
-BOOL LLTextBase::handleMouseDown(S32 x, S32 y, MASK mask)
+bool LLTextBase::handleMouseDown(S32 x, S32 y, MASK mask)
 {
 	// handle triple click
 	if (!mTripleClickTimer.hasExpired())
 	{
 		if (mSkipTripleClick)
 		{
-			return TRUE;
+			return true;
 		}
 		
 		S32 real_line = getLineNumFromDocIndex(mCursorPos, false);
@@ -1114,26 +1114,26 @@ BOOL LLTextBase::handleMouseDown(S32 x, S32 y, MASK mask)
 
 		if (line_start == -1)
 		{
-			return TRUE;
+			return true;
 		}
 
 		mSelectionEnd = line_start;
 		mSelectionStart = line_end;
 		setCursorPos(line_start);
 
-		return TRUE;
+		return true;
 	}
 
 	LLTextSegmentPtr cur_segment = getSegmentAtLocalPos(x, y);
 	if (cur_segment && cur_segment->handleMouseDown(x, y, mask))
 	{
-		return TRUE;
+		return true;
 	}
 
 	return LLUICtrl::handleMouseDown(x, y, mask);
 }
 
-BOOL LLTextBase::handleMouseUp(S32 x, S32 y, MASK mask)
+bool LLTextBase::handleMouseUp(S32 x, S32 y, MASK mask)
 {
 	LLTextSegmentPtr cur_segment = getSegmentAtLocalPos(x, y);
 	if (hasMouseCapture() && cur_segment && cur_segment->handleMouseUp(x, y, mask))
@@ -1146,57 +1146,57 @@ BOOL LLTextBase::handleMouseUp(S32 x, S32 y, MASK mask)
 			// *TODO: send URL here?
 			(*mURLClickSignal)(this, LLSD() );
 		}
-		return TRUE;
+		return true;
 	}
 
 	return LLUICtrl::handleMouseUp(x, y, mask);
 }
 
-BOOL LLTextBase::handleMiddleMouseDown(S32 x, S32 y, MASK mask)
+bool LLTextBase::handleMiddleMouseDown(S32 x, S32 y, MASK mask)
 {
 	LLTextSegmentPtr cur_segment = getSegmentAtLocalPos(x, y);
 	if (cur_segment && cur_segment->handleMiddleMouseDown(x, y, mask))
 	{
-		return TRUE;
+		return true;
 	}
 
 	return LLUICtrl::handleMiddleMouseDown(x, y, mask);
 }
 
-BOOL LLTextBase::handleMiddleMouseUp(S32 x, S32 y, MASK mask)
+bool LLTextBase::handleMiddleMouseUp(S32 x, S32 y, MASK mask)
 {
 	LLTextSegmentPtr cur_segment = getSegmentAtLocalPos(x, y);
 	if (cur_segment && cur_segment->handleMiddleMouseUp(x, y, mask))
 	{
-		return TRUE;
+		return true;
 	}
 
 	return LLUICtrl::handleMiddleMouseUp(x, y, mask);
 }
 
-BOOL LLTextBase::handleRightMouseDown(S32 x, S32 y, MASK mask)
+bool LLTextBase::handleRightMouseDown(S32 x, S32 y, MASK mask)
 {
 	LLTextSegmentPtr cur_segment = getSegmentAtLocalPos(x, y);
 	if (cur_segment && cur_segment->handleRightMouseDown(x, y, mask))
 	{
-		return TRUE;
+		return true;
 	}
 
 	return LLUICtrl::handleRightMouseDown(x, y, mask);
 }
 
-BOOL LLTextBase::handleRightMouseUp(S32 x, S32 y, MASK mask)
+bool LLTextBase::handleRightMouseUp(S32 x, S32 y, MASK mask)
 {
 	LLTextSegmentPtr cur_segment = getSegmentAtLocalPos(x, y);
 	if (cur_segment && cur_segment->handleRightMouseUp(x, y, mask))
 	{
-		return TRUE;
+		return true;
 	}
 
 	return LLUICtrl::handleRightMouseUp(x, y, mask);
 }
 
-BOOL LLTextBase::handleDoubleClick(S32 x, S32 y, MASK mask)
+bool LLTextBase::handleDoubleClick(S32 x, S32 y, MASK mask)
 {
 	//Don't start triple click timer if user have clicked on scrollbar
 	mVisibleTextRect = mScroller ? mScroller->getContentWindowRect() : getLocalRect();
@@ -1209,40 +1209,40 @@ BOOL LLTextBase::handleDoubleClick(S32 x, S32 y, MASK mask)
 	LLTextSegmentPtr cur_segment = getSegmentAtLocalPos(x, y);
 	if (cur_segment && cur_segment->handleDoubleClick(x, y, mask))
 	{
-		return TRUE;
+		return true;
 	}
 
 	return LLUICtrl::handleDoubleClick(x, y, mask);
 }
 
-BOOL LLTextBase::handleHover(S32 x, S32 y, MASK mask)
+bool LLTextBase::handleHover(S32 x, S32 y, MASK mask)
 {
 	LLTextSegmentPtr cur_segment = getSegmentAtLocalPos(x, y);
 	if (cur_segment && cur_segment->handleHover(x, y, mask))
 	{
-		return TRUE;
+		return true;
 	}
 
 	return LLUICtrl::handleHover(x, y, mask);
 }
 
-BOOL LLTextBase::handleScrollWheel(S32 x, S32 y, S32 clicks)
+bool LLTextBase::handleScrollWheel(S32 x, S32 y, S32 clicks)
 {
 	LLTextSegmentPtr cur_segment = getSegmentAtLocalPos(x, y);
 	if (cur_segment && cur_segment->handleScrollWheel(x, y, clicks))
 	{
-		return TRUE;
+		return true;
 	}
 
 	return LLUICtrl::handleScrollWheel(x, y, clicks);
 }
 
-BOOL LLTextBase::handleToolTip(S32 x, S32 y, MASK mask)
+bool LLTextBase::handleToolTip(S32 x, S32 y, MASK mask)
 {
 	LLTextSegmentPtr cur_segment = getSegmentAtLocalPos(x, y);
 	if (cur_segment && cur_segment->handleToolTip(x, y, mask))
 	{
-		return TRUE;
+		return true;
 	}
 
 	return LLUICtrl::handleToolTip(x, y, mask);
@@ -3228,17 +3228,17 @@ void LLTextSegment::setToken( LLKeywordToken* token ) {}
 LLKeywordToken*	LLTextSegment::getToken() const { return NULL; }
 void LLTextSegment::setToolTip( const std::string &msg ) {}
 void LLTextSegment::dump() const {}
-BOOL LLTextSegment::handleMouseDown(S32 x, S32 y, MASK mask) { return FALSE; }
-BOOL LLTextSegment::handleMouseUp(S32 x, S32 y, MASK mask) { return FALSE; }
-BOOL LLTextSegment::handleMiddleMouseDown(S32 x, S32 y, MASK mask) { return FALSE; }
-BOOL LLTextSegment::handleMiddleMouseUp(S32 x, S32 y, MASK mask) { return FALSE; }
-BOOL LLTextSegment::handleRightMouseDown(S32 x, S32 y, MASK mask) { return FALSE; }
-BOOL LLTextSegment::handleRightMouseUp(S32 x, S32 y, MASK mask) { return FALSE; }
-BOOL LLTextSegment::handleDoubleClick(S32 x, S32 y, MASK mask) { return FALSE; }
-BOOL LLTextSegment::handleHover(S32 x, S32 y, MASK mask) { return FALSE; }
-BOOL LLTextSegment::handleScrollWheel(S32 x, S32 y, S32 clicks) { return FALSE; }
-BOOL LLTextSegment::handleScrollHWheel(S32 x, S32 y, S32 clicks) { return FALSE; }
-BOOL LLTextSegment::handleToolTip(S32 x, S32 y, MASK mask) { return FALSE; }
+bool LLTextSegment::handleMouseDown(S32 x, S32 y, MASK mask) { return false; }
+bool LLTextSegment::handleMouseUp(S32 x, S32 y, MASK mask) { return false; }
+bool LLTextSegment::handleMiddleMouseDown(S32 x, S32 y, MASK mask) { return false; }
+bool LLTextSegment::handleMiddleMouseUp(S32 x, S32 y, MASK mask) { return false; }
+bool LLTextSegment::handleRightMouseDown(S32 x, S32 y, MASK mask) { return false; }
+bool LLTextSegment::handleRightMouseUp(S32 x, S32 y, MASK mask) { return false; }
+bool LLTextSegment::handleDoubleClick(S32 x, S32 y, MASK mask) { return false; }
+bool LLTextSegment::handleHover(S32 x, S32 y, MASK mask) { return false; }
+bool LLTextSegment::handleScrollWheel(S32 x, S32 y, S32 clicks) { return false; }
+bool LLTextSegment::handleScrollHWheel(S32 x, S32 y, S32 clicks) { return false; }
+bool LLTextSegment::handleToolTip(S32 x, S32 y, MASK mask) { return false; }
 const std::string&	LLTextSegment::getName() const 
 {
 	return LLStringUtil::null;
@@ -3246,7 +3246,7 @@ const std::string&	LLTextSegment::getName() const
 void LLTextSegment::onMouseCaptureLost() {}
 void LLTextSegment::screenPointToLocal(S32 screen_x, S32 screen_y, S32* local_x, S32* local_y) const {}
 void LLTextSegment::localPointToScreen(S32 local_x, S32 local_y, S32* screen_x, S32* screen_y) const {}
-BOOL LLTextSegment::hasMouseCapture() { return FALSE; }
+bool LLTextSegment::hasMouseCapture() { return false; }
 
 //
 // LLNormalTextSegment
@@ -3364,7 +3364,7 @@ F32 LLNormalTextSegment::drawClippedSegment(S32 seg_start, S32 seg_end, S32 sele
     return right_x;
 }
 
-BOOL LLNormalTextSegment::handleHover(S32 x, S32 y, MASK mask)
+bool LLNormalTextSegment::handleHover(S32 x, S32 y, MASK mask)
 {
 	if (getStyle() && getStyle()->isLink())
 	{
@@ -3372,13 +3372,13 @@ BOOL LLNormalTextSegment::handleHover(S32 x, S32 y, MASK mask)
 		if(mEditor.getSegmentAtLocalPos(x, y, false) == this)
 		{
 			LLUI::getInstance()->getWindow()->setCursor(UI_CURSOR_HAND);
-			return TRUE;
+			return true;
 		}
 	}
-	return FALSE;
+	return false;
 }
 
-BOOL LLNormalTextSegment::handleRightMouseDown(S32 x, S32 y, MASK mask)
+bool LLNormalTextSegment::handleRightMouseDown(S32 x, S32 y, MASK mask)
 {
 	if (getStyle() && getStyle()->isLink())
 	{
@@ -3386,13 +3386,13 @@ BOOL LLNormalTextSegment::handleRightMouseDown(S32 x, S32 y, MASK mask)
 		if(mEditor.getSegmentAtLocalPos(x, y, false) == this)
 		{
 			mEditor.createUrlContextMenu(x, y, getStyle()->getLinkHREF());
-			return TRUE;
+			return true;
 		}
 	}
-	return FALSE;
+	return false;
 }
 
-BOOL LLNormalTextSegment::handleMouseDown(S32 x, S32 y, MASK mask)
+bool LLNormalTextSegment::handleMouseDown(S32 x, S32 y, MASK mask)
 {
 	if (getStyle() && getStyle()->isLink())
 	{
@@ -3400,14 +3400,14 @@ BOOL LLNormalTextSegment::handleMouseDown(S32 x, S32 y, MASK mask)
 		if(mEditor.getSegmentAtLocalPos(x, y, false) == this)
 		{
 			// eat mouse down event on hyperlinks, so we get the mouse up
-			return TRUE;
+			return true;
 		}
 	}
 
-	return FALSE;
+	return false;
 }
 
-BOOL LLNormalTextSegment::handleMouseUp(S32 x, S32 y, MASK mask)
+bool LLNormalTextSegment::handleMouseUp(S32 x, S32 y, MASK mask)
 {
 	if (getStyle() && getStyle()->isLink())
 	{
@@ -3423,14 +3423,14 @@ BOOL LLNormalTextSegment::handleMouseUp(S32 x, S32 y, MASK mask)
             {
                 LLUrlAction::openURLExternal(url);
             }
-			return TRUE;
+			return true;
 		}
 	}
 
-	return FALSE;
+	return false;
 }
 
-BOOL LLNormalTextSegment::handleToolTip(S32 x, S32 y, MASK mask)
+bool LLNormalTextSegment::handleToolTip(S32 x, S32 y, MASK mask)
 {
 	std::string msg;
 	// do we have a tooltip for a loaded keyword (for script editor)?
@@ -3438,16 +3438,16 @@ BOOL LLNormalTextSegment::handleToolTip(S32 x, S32 y, MASK mask)
 	{
 		const LLWString& wmsg = mToken->getToolTip();
 		LLToolTipMgr::instance().show(wstring_to_utf8str(wmsg));
-		return TRUE;
+		return true;
 	}
 	// or do we have an explicitly set tooltip (e.g., for Urls)
 	if (!mTooltip.empty())
 	{
 		LLToolTipMgr::instance().show(mTooltip);
-		return TRUE;
+		return true;
 	}
 
-	return FALSE;
+	return false;
 }
 
 void LLNormalTextSegment::setToolTip(const std::string& tooltip)
@@ -3611,7 +3611,7 @@ F32 LLOnHoverChangeableTextSegment::draw(S32 start, S32 end, S32 selection_start
 }
 
 /*virtual*/
-BOOL LLOnHoverChangeableTextSegment::handleHover(S32 x, S32 y, MASK mask)
+bool LLOnHoverChangeableTextSegment::handleHover(S32 x, S32 y, MASK mask)
 {
 	mStyle = mEditor.getSkipLinkUnderline() ? mNormalStyle : mHoveredStyle;
 	return LLNormalTextSegment::handleHover(x, y, mask);
@@ -3786,15 +3786,15 @@ S32	 LLImageTextSegment::getNumChars(S32 num_pixels, S32 segment_offset, S32 lin
 	return 0;
 }
 
-BOOL LLImageTextSegment::handleToolTip(S32 x, S32 y, MASK mask)
+bool LLImageTextSegment::handleToolTip(S32 x, S32 y, MASK mask)
 {
 	if (!mTooltip.empty())
 	{
 		LLToolTipMgr::instance().show(mTooltip);
-		return TRUE;
+		return true;
 	}
 
-	return FALSE;
+	return false;
 }
 
 void LLImageTextSegment::setToolTip(const std::string& tooltip)
diff --git a/indra/llui/lltextbase.h b/indra/llui/lltextbase.h
index 3611ab0499..1dd91eef32 100644
--- a/indra/llui/lltextbase.h
+++ b/indra/llui/lltextbase.h
@@ -94,22 +94,22 @@ public:
 	virtual void				dump() const;
 
 	// LLMouseHandler interface
-	/*virtual*/ BOOL			handleMouseDown(S32 x, S32 y, MASK mask);
-	/*virtual*/ BOOL			handleMouseUp(S32 x, S32 y, MASK mask);
-	/*virtual*/ BOOL			handleMiddleMouseDown(S32 x, S32 y, MASK mask);
-	/*virtual*/ BOOL			handleMiddleMouseUp(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			handleDoubleClick(S32 x, S32 y, MASK mask);
-	/*virtual*/ BOOL			handleHover(S32 x, S32 y, MASK mask);
-	/*virtual*/ BOOL			handleScrollWheel(S32 x, S32 y, S32 clicks);
-	/*virtual*/ BOOL			handleScrollHWheel(S32 x, S32 y, S32 clicks);
-	/*virtual*/ BOOL			handleToolTip(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool			handleMouseDown(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool			handleMouseUp(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool			handleMiddleMouseDown(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool			handleMiddleMouseUp(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			handleDoubleClick(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool			handleHover(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool			handleScrollWheel(S32 x, S32 y, S32 clicks);
+	/*virtual*/ bool			handleScrollHWheel(S32 x, S32 y, S32 clicks);
+	/*virtual*/ bool			handleToolTip(S32 x, S32 y, MASK mask);
 	/*virtual*/ const std::string&	getName() const;
 	/*virtual*/ void			onMouseCaptureLost();
 	/*virtual*/ void			screenPointToLocal(S32 screen_x, S32 screen_y, S32* local_x, S32* local_y) const;
 	/*virtual*/ void			localPointToScreen(S32 local_x, S32 local_y, S32* screen_x, S32* screen_y) const;
-	/*virtual*/ BOOL			hasMouseCapture();
+	/*virtual*/ bool			hasMouseCapture();
 
 	S32						getStart() const 					{ return mStart; }
 	void					setStart(S32 start)					{ mStart = start; }
@@ -142,11 +142,11 @@ public:
 	/*virtual*/ void				setToolTip(const std::string& tooltip);
 	/*virtual*/ void				dump() const;
 
-	/*virtual*/ BOOL				handleHover(S32 x, S32 y, MASK mask);
-	/*virtual*/ BOOL				handleRightMouseDown(S32 x, S32 y, MASK mask);
-	/*virtual*/ BOOL				handleMouseDown(S32 x, S32 y, MASK mask);
-	/*virtual*/ BOOL				handleMouseUp(S32 x, S32 y, MASK mask);
-	/*virtual*/ BOOL				handleToolTip(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				handleMouseDown(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool				handleMouseUp(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool				handleToolTip(S32 x, S32 y, MASK mask);
 
 protected:
 	F32					drawClippedSegment(S32 seg_start, S32 seg_end, S32 selection_start, S32 selection_end, LLRectf rect);
@@ -184,7 +184,7 @@ class LLOnHoverChangeableTextSegment : public LLNormalTextSegment
 public:
 	LLOnHoverChangeableTextSegment( LLStyleConstSP style, LLStyleConstSP normal_style, S32 start, S32 end, LLTextBase& editor );
 	/*virtual*/ F32 draw(S32 start, S32 end, S32 selection_start, S32 selection_end, const LLRectf& draw_rect);
-	/*virtual*/ BOOL handleHover(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool handleHover(S32 x, S32 y, MASK mask);
 protected:
 	// Style used for text when mouse pointer is over segment
 	LLStyleConstSP		mHoveredStyle;
@@ -255,7 +255,7 @@ public:
 	S32			getNumChars(S32 num_pixels, S32 segment_offset, S32 char_offset, S32 max_chars, S32 line_ind) const;
 	F32			draw(S32 start, S32 end, S32 selection_start, S32 selection_end, const LLRectf& draw_rect);
 
-	/*virtual*/ BOOL	handleToolTip(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool	handleToolTip(S32 x, S32 y, MASK mask);
 	/*virtual*/ void	setToolTip(const std::string& tooltip);
 
 private:
@@ -339,16 +339,16 @@ public:
 	};
 
 	// LLMouseHandler interface
-	/*virtual*/ BOOL		handleMouseDown(S32 x, S32 y, MASK mask);
-	/*virtual*/ BOOL		handleMouseUp(S32 x, S32 y, MASK mask);
-	/*virtual*/ BOOL		handleMiddleMouseDown(S32 x, S32 y, MASK mask);
-	/*virtual*/ BOOL		handleMiddleMouseUp(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		handleDoubleClick(S32 x, S32 y, MASK mask);
-	/*virtual*/ BOOL		handleHover(S32 x, S32 y, MASK mask);
-	/*virtual*/ BOOL		handleScrollWheel(S32 x, S32 y, S32 clicks);
-	/*virtual*/ BOOL		handleToolTip(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool		handleMouseDown(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool		handleMouseUp(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool		handleMiddleMouseDown(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool		handleMiddleMouseUp(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		handleDoubleClick(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool		handleHover(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool		handleScrollWheel(S32 x, S32 y, S32 clicks);
+	/*virtual*/ bool		handleToolTip(S32 x, S32 y, MASK mask);
 
 	// LLView interface
 	/*virtual*/ void		reshape(S32 width, S32 height, BOOL called_from_parent = TRUE);
diff --git a/indra/llui/lltextbox.cpp b/indra/llui/lltextbox.cpp
index 521dabf9d4..739b46bb07 100644
--- a/indra/llui/lltextbox.cpp
+++ b/indra/llui/lltextbox.cpp
@@ -52,9 +52,9 @@ LLTextBox::LLTextBox(const LLTextBox::Params& p)
 LLTextBox::~LLTextBox()
 {}
 
-BOOL LLTextBox::handleMouseDown(S32 x, S32 y, MASK mask)
+bool LLTextBox::handleMouseDown(S32 x, S32 y, MASK mask)
 {
-	BOOL	handled = LLTextBase::handleMouseDown(x, y, mask);
+	bool	handled = LLTextBase::handleMouseDown(x, y, mask);
 
 	if (getSoundFlags() & MOUSE_DOWN)
 	{
@@ -63,7 +63,7 @@ BOOL LLTextBox::handleMouseDown(S32 x, S32 y, MASK mask)
 
 	if (!handled && mClickedCallback)
 	{
-		handled = TRUE;
+		handled = true;
 	}
 
 	if (handled)
@@ -75,9 +75,9 @@ BOOL LLTextBox::handleMouseDown(S32 x, S32 y, MASK mask)
 	return handled;
 }
 
-BOOL LLTextBox::handleMouseUp(S32 x, S32 y, MASK mask)
+bool LLTextBox::handleMouseUp(S32 x, S32 y, MASK mask)
 {
-	BOOL	handled = LLTextBase::handleMouseUp(x, y, mask);
+	bool	handled = LLTextBase::handleMouseUp(x, y, mask);
 
 	if (getSoundFlags() & MOUSE_UP)
 	{
@@ -96,21 +96,21 @@ BOOL LLTextBox::handleMouseUp(S32 x, S32 y, MASK mask)
 		if (mClickedCallback && !handled)
 		{
 			mClickedCallback();
-			handled = TRUE;
+			handled = true;
 		}
 	}
 
 	return handled;
 }
 
-BOOL LLTextBox::handleHover(S32 x, S32 y, MASK mask)
+bool LLTextBox::handleHover(S32 x, S32 y, MASK mask)
 {
-	BOOL handled = LLTextBase::handleHover(x, y, mask);
+	bool handled = LLTextBase::handleHover(x, y, mask);
 	if (!handled && mClickedCallback && mShowCursorHand)
 	{
 		// Clickable text boxes change the cursor to a hand
 		LLUI::getInstance()->getWindow()->setCursor(UI_CURSOR_HAND);
-		return TRUE;
+		return true;
 	}
 	return handled;
 }
diff --git a/indra/llui/lltextbox.h b/indra/llui/lltextbox.h
index c3e3b61912..bf0348723b 100644
--- a/indra/llui/lltextbox.h
+++ b/indra/llui/lltextbox.h
@@ -48,9 +48,9 @@ protected:
 public:
 	virtual ~LLTextBox();
 
-	/*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*/ 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 setEnabled(BOOL enabled);
 
diff --git a/indra/llui/lltexteditor.cpp b/indra/llui/lltexteditor.cpp
index 3d2a426913..eabeeddcd4 100644
--- a/indra/llui/lltexteditor.cpp
+++ b/indra/llui/lltexteditor.cpp
@@ -668,15 +668,15 @@ void LLTextEditor::selectByCursorPosition(S32 prev_cursor_pos, S32 next_cursor_p
 	endSelection();
 }
 
-BOOL LLTextEditor::handleMouseDown(S32 x, S32 y, MASK mask)
+bool LLTextEditor::handleMouseDown(S32 x, S32 y, MASK mask)
 {
-	BOOL	handled = FALSE;
+	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 );
+		setFocus( true );
 	}
 
 	// Let scrollbar have first dibs
@@ -689,7 +689,7 @@ BOOL LLTextEditor::handleMouseDown(S32 x, S32 y, MASK mask)
 			deselect();
 		}
 
-		BOOL start_select = TRUE;
+		bool start_select = true;
 		if( start_select )
 		{
 			// If we're not scrolling (handled by child), then we're selecting
@@ -717,7 +717,7 @@ BOOL LLTextEditor::handleMouseDown(S32 x, S32 y, MASK mask)
 			}
 		}
 
-		handled = TRUE;
+		handled = true;
 	}
 
 	// Delay cursor flashing
@@ -730,11 +730,11 @@ BOOL LLTextEditor::handleMouseDown(S32 x, S32 y, MASK mask)
 	return handled;
 }
 
-BOOL LLTextEditor::handleRightMouseDown(S32 x, S32 y, MASK mask)
+bool LLTextEditor::handleRightMouseDown(S32 x, S32 y, MASK mask)
 {
 	if (hasTabStop())
 	{
-		setFocus(TRUE);
+		setFocus(true);
 	}
 
 	bool show_menu = false;
@@ -742,7 +742,7 @@ BOOL LLTextEditor::handleRightMouseDown(S32 x, S32 y, MASK mask)
 	// Prefer editor menu if it has selection. See EXT-6806.
 	if (hasSelection())
 	{
-		S32 click_pos = getDocIndexFromLocalCoord(x, y, FALSE);
+		S32 click_pos = getDocIndexFromLocalCoord(x, y, false);
 		if (click_pos > mSelectionStart && click_pos < mSelectionEnd)
 		{
 			show_menu = true;
@@ -760,16 +760,16 @@ BOOL LLTextEditor::handleRightMouseDown(S32 x, S32 y, MASK mask)
 		showContextMenu(x, y);
 	}
 
-	return TRUE;
+	return true;
 }
 
 
 
-BOOL LLTextEditor::handleMiddleMouseDown(S32 x, S32 y, MASK mask)
+bool LLTextEditor::handleMiddleMouseDown(S32 x, S32 y, MASK mask)
 {
 	if (hasTabStop())
 	{
-		setFocus(TRUE);
+		setFocus(true);
 	}
 
 	if (!LLTextBase::handleMouseDown(x, y, mask))
@@ -781,13 +781,13 @@ BOOL LLTextEditor::handleMiddleMouseDown(S32 x, S32 y, MASK mask)
 			pastePrimary();
 		}
 	}
-	return TRUE;
+	return true;
 }
 
 
-BOOL LLTextEditor::handleHover(S32 x, S32 y, MASK mask)
+bool LLTextEditor::handleHover(S32 x, S32 y, MASK mask)
 {
-	BOOL handled = FALSE;
+	bool handled = false;
 
 	if(hasMouseCapture() )
 	{
@@ -804,7 +804,7 @@ BOOL LLTextEditor::handleHover(S32 x, S32 y, MASK mask)
 		}
 		LL_DEBUGS("UserInput") << "hover handled by " << getName() << " (active)" << LL_ENDL;		
 		getWindow()->setCursor(UI_CURSOR_IBEAM);
-		handled = TRUE;
+		handled = true;
 	}
 
 	if( !handled )
@@ -822,16 +822,16 @@ BOOL LLTextEditor::handleHover(S32 x, S32 y, MASK mask)
 	if( !handled )
 	{
 		getWindow()->setCursor(UI_CURSOR_IBEAM);
-		handled = TRUE;
+		handled = true;
 	}
 
 	return handled;
 }
 
 
-BOOL LLTextEditor::handleMouseUp(S32 x, S32 y, MASK mask)
+bool LLTextEditor::handleMouseUp(S32 x, S32 y, MASK mask)
 {
-	BOOL	handled = FALSE;
+	bool	handled = false;
 
 	// if I'm not currently selecting text
 	if (!(mIsSelecting && hasMouseCapture()))
@@ -857,7 +857,7 @@ BOOL LLTextEditor::handleMouseUp(S32 x, S32 y, MASK mask)
 		// take selection to 'primary' clipboard
 		updatePrimary();
 
-		handled = TRUE;
+		handled = true;
 	}
 
 	// Delay cursor flashing
@@ -867,16 +867,16 @@ BOOL LLTextEditor::handleMouseUp(S32 x, S32 y, MASK mask)
 	{
 		gFocusMgr.setMouseCapture( NULL );
 		
-		handled = TRUE;
+		handled = true;
 	}
 
 	return handled;
 }
 
 
-BOOL LLTextEditor::handleDoubleClick(S32 x, S32 y, MASK mask)
+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);
@@ -914,7 +914,7 @@ BOOL LLTextEditor::handleDoubleClick(S32 x, S32 y, MASK mask)
 
 		// 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;  
+		mIsSelecting = false;  
 
 		// delay cursor flashing
 		resetCursorBlink();
@@ -922,7 +922,7 @@ BOOL LLTextEditor::handleDoubleClick(S32 x, S32 y, MASK mask)
 		// take selection to 'primary' clipboard
 		updatePrimary();
 
-		handled = TRUE;
+		handled = true;
 	}
 
 	return handled;
@@ -1825,14 +1825,14 @@ BOOL LLTextEditor::handleKeyHere(KEY key, MASK mask )
 }
 
 
-BOOL LLTextEditor::handleUnicodeCharHere(llwchar uni_char)
+bool LLTextEditor::handleUnicodeCharHere(llwchar uni_char)
 {
 	if ((uni_char < 0x20) || (uni_char == 0x7F)) // Control character or DEL
 	{
-		return FALSE;
+		return false;
 	}
 
-	BOOL	handled = FALSE;
+	bool	handled = false;
 
 	// Handle most keys only if the text editor is writeable.
 	if( !mReadOnly )
@@ -1848,7 +1848,7 @@ BOOL LLTextEditor::handleUnicodeCharHere(llwchar uni_char)
 		// Keys that add characters temporarily hide the cursor
 		getWindow()->hideCursorUntilMouseMove();
 
-		handled = TRUE;
+		handled = true;
 	}
 
 	if( handled )
@@ -2755,7 +2755,7 @@ void LLTextEditor::updatePreedit(const LLWString &preedit_string,
 	onKeyStroke();
 }
 
-BOOL LLTextEditor::getPreeditLocation(S32 query_offset, LLCoordGL *coord, LLRect *bounds, LLRect *control) const
+bool LLTextEditor::getPreeditLocation(S32 query_offset, LLCoordGL *coord, LLRect *bounds, LLRect *control) const
 {
 	if (control)
 	{
@@ -2778,13 +2778,13 @@ BOOL LLTextEditor::getPreeditLocation(S32 query_offset, LLCoordGL *coord, LLRect
 	const S32 query = (query_offset >= 0 ? preedit_left_position + query_offset : mCursorPos);
 	if (query < preedit_left_position || query > preedit_right_position)
 	{
-		return FALSE;
+		return false;
 	}
 
 	const S32 first_visible_line = getFirstVisibleLine();
 	if (query < getLineStart(first_visible_line))
 	{
-		return FALSE;
+		return false;
 	}
 
 	S32 current_line = first_visible_line;
@@ -2845,7 +2845,7 @@ BOOL LLTextEditor::getPreeditLocation(S32 query_offset, LLCoordGL *coord, LLRect
 		LLUI::getInstance()->screenRectToGL(preedit_rect_screen, bounds);
 	}
 
-	return TRUE;
+	return true;
 }
 
 void LLTextEditor::getSelectionRange(S32 *position, S32 *length) const
@@ -2891,7 +2891,7 @@ void LLTextEditor::markAsPreedit(S32 position, S32 length)
 		mPreeditPositions[0] = position;
 		mPreeditPositions[1] = position + length;
 		mPreeditStandouts.resize(1);
-		mPreeditStandouts[0] = FALSE;
+		mPreeditStandouts[0] = false;
 	}
 	else
 	{
diff --git a/indra/llui/lltexteditor.h b/indra/llui/lltexteditor.h
index f3939248c2..2b1986ff41 100644
--- a/indra/llui/lltexteditor.h
+++ b/indra/llui/lltexteditor.h
@@ -92,15 +92,15 @@ public:
 	static S32		spacesPerTab();
 
 	// 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	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	handleUnicodeCharHere(llwchar uni_char);
 
 	virtual void	onMouseCaptureLost();
 
@@ -259,7 +259,7 @@ protected:
 	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 bool	getPreeditLocation(S32 query_offset, LLCoordGL *coord, LLRect *bounds, LLRect *control) const;
 	virtual S32		getPreeditFontSize() const;
 	virtual LLWString getPreeditString() const { return getWText(); }
 	//
@@ -276,7 +276,7 @@ protected:
 	LLWString			mPreeditWString;
 	LLWString			mPreeditOverwrittenWString;
 	std::vector<S32> 	mPreeditPositions;
-	std::vector<BOOL> 	mPreeditStandouts;
+	std::vector<bool> 	mPreeditStandouts;
 
 protected:
 	LLUIColor			mDefaultColor;
diff --git a/indra/llui/lltoolbar.cpp b/indra/llui/lltoolbar.cpp
index 2707f7a15c..7925c1048d 100644
--- a/indra/llui/lltoolbar.cpp
+++ b/indra/llui/lltoolbar.cpp
@@ -406,11 +406,11 @@ bool LLToolBar::flashCommand(const LLCommandId& commandId, bool flash, bool forc
 	return (command_button != NULL);
 }
 
-BOOL LLToolBar::handleRightMouseDown(S32 x, S32 y, MASK mask)
+bool LLToolBar::handleRightMouseDown(S32 x, S32 y, MASK mask)
 {
 	LLRect button_panel_rect;
 	mButtonPanel->localRectToOtherView(mButtonPanel->getLocalRect(), &button_panel_rect, this);
-	BOOL handle_it_here = !mReadOnly && button_panel_rect.pointInRect(x, y);
+	bool handle_it_here = !mReadOnly && button_panel_rect.pointInRect(x, y);
 
 	if (handle_it_here)
 	{
@@ -1122,16 +1122,16 @@ LLToolBarButton::~LLToolBarButton()
 	delete mIsStartingSignal;
 }
 
-BOOL LLToolBarButton::handleMouseDown(S32 x, S32 y, MASK mask)
+bool LLToolBarButton::handleMouseDown(S32 x, S32 y, MASK mask)
 {
 	mMouseDownX = x;
 	mMouseDownY = y;
 	return LLButton::handleMouseDown(x, y, mask);
 }
 
-BOOL LLToolBarButton::handleHover(S32 x, S32 y, MASK mask)
+bool LLToolBarButton::handleHover(S32 x, S32 y, MASK mask)
 {
-	BOOL handled = FALSE;
+	bool handled = false;
 		
 	S32 mouse_distance_squared = (x - mMouseDownX) * (x - mMouseDownX) + (y - mMouseDownY) * (y - mMouseDownY);
 	static LLCachedControl<S32> drag_threshold(*LLUI::getInstance()->mSettingGroups["config"], "DragAndDropDistanceThreshold", 3);
@@ -1143,7 +1143,7 @@ BOOL LLToolBarButton::handleHover(S32 x, S32 y, MASK mask)
 		{
 			mStartDragItemCallback(x, y, this);
 			mIsDragged = true;
-			handled = TRUE;
+			handled = true;
 		}
 		else 
 		{
diff --git a/indra/llui/lltoolbar.h b/indra/llui/lltoolbar.h
index 370941c787..3a4f2fb76e 100644
--- a/indra/llui/lltoolbar.h
+++ b/indra/llui/lltoolbar.h
@@ -62,8 +62,8 @@ public:
 	LLToolBarButton(const Params& p);
 	~LLToolBarButton();
 
-	BOOL handleMouseDown(S32 x, S32 y, MASK mask);
-	BOOL handleHover(S32 x, S32 y, MASK mask);
+	bool handleMouseDown(S32 x, S32 y, MASK mask);
+	bool handleHover(S32 x, S32 y, MASK mask);
 
 	void reshape(S32 width, S32 height, BOOL called_from_parent = true);
 	void setEnabled(BOOL enabled);
@@ -215,7 +215,7 @@ public:
 	// virtuals
 	void draw();
 	void reshape(S32 width, S32 height, BOOL called_from_parent = TRUE);
-	BOOL handleRightMouseDown(S32 x, S32 y, MASK mask);
+	bool handleRightMouseDown(S32 x, S32 y, MASK mask);
 	virtual BOOL handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
 								   EDragAndDropType cargo_type,
 								   void* cargo_data,
diff --git a/indra/llui/lltooltip.cpp b/indra/llui/lltooltip.cpp
index a6552d4ff1..0c5a1adcb3 100644
--- a/indra/llui/lltooltip.cpp
+++ b/indra/llui/lltooltip.cpp
@@ -71,7 +71,7 @@ void LLToolTipView::draw()
 	LLView::draw();
 }
 
-BOOL LLToolTipView::handleHover(S32 x, S32 y, MASK mask)
+bool LLToolTipView::handleHover(S32 x, S32 y, MASK mask)
 {
 	static S32 last_x = x;
 	static S32 last_y = y;
@@ -89,7 +89,7 @@ BOOL LLToolTipView::handleHover(S32 x, S32 y, MASK mask)
 	return LLView::handleHover(x, y, mask);
 }
 
-BOOL LLToolTipView::handleMouseDown(S32 x, S32 y, MASK mask)
+bool LLToolTipView::handleMouseDown(S32 x, S32 y, MASK mask)
 {
 	LLToolTipMgr::instance().blockToolTips();
 
@@ -98,29 +98,29 @@ BOOL LLToolTipView::handleMouseDown(S32 x, S32 y, MASK mask)
 		// If we are handling the mouse event menu holder 
 		// won't get a chance to close menus so do this here 
 		LLMenuGL::sMenuContainer->hideMenus();
-		return TRUE;
+		return true;
 	}
 
-	return FALSE;
+	return false;
 }
 
-BOOL LLToolTipView::handleMiddleMouseDown(S32 x, S32 y, MASK mask)
+bool LLToolTipView::handleMiddleMouseDown(S32 x, S32 y, MASK mask)
 {
 	LLToolTipMgr::instance().blockToolTips();
 	return LLView::handleMiddleMouseDown(x, y, mask);
 }
 
-BOOL LLToolTipView::handleRightMouseDown(S32 x, S32 y, MASK mask)
+bool LLToolTipView::handleRightMouseDown(S32 x, S32 y, MASK mask)
 {
 	LLToolTipMgr::instance().blockToolTips();
 	return LLView::handleRightMouseDown(x, y, mask);
 }
 
 
-BOOL LLToolTipView::handleScrollWheel( S32 x, S32 y, S32 clicks )
+bool LLToolTipView::handleScrollWheel( S32 x, S32 y, S32 clicks )
 {
 	LLToolTipMgr::instance().blockToolTips();
-	return FALSE;
+	return false;
 }
 
 void LLToolTipView::drawStickyRect()
@@ -341,7 +341,7 @@ void LLToolTip::setVisible(BOOL visible)
 	}
 }
 
-BOOL LLToolTip::handleHover(S32 x, S32 y, MASK mask)
+bool LLToolTip::handleHover(S32 x, S32 y, MASK mask)
 {
 	//mInfoButton->setFlashing(true);
 	if(mInfoButton)
@@ -352,7 +352,7 @@ BOOL LLToolTip::handleHover(S32 x, S32 y, MASK mask)
 	{
 		getWindow()->setCursor(UI_CURSOR_HAND);
 	}
-	return TRUE;
+	return true;
 }
 
 void LLToolTip::onMouseLeave(S32 x, S32 y, MASK mask)
diff --git a/indra/llui/lltooltip.h b/indra/llui/lltooltip.h
index 86943625ff..e95a1754d0 100644
--- a/indra/llui/lltooltip.h
+++ b/indra/llui/lltooltip.h
@@ -44,11 +44,11 @@ public:
 		Params();
 	};
 	LLToolTipView(const LLToolTipView::Params&);
-	/*virtual*/ BOOL handleHover(S32 x, S32 y, MASK mask);
-	/*virtual*/ BOOL handleMouseDown(S32 x, S32 y, MASK mask);
-	/*virtual*/ BOOL handleMiddleMouseDown(S32 x, S32 y, MASK mask);
-	/*virtual*/ BOOL handleRightMouseDown(S32 x, S32 y, MASK mask);
-	/*virtual*/ BOOL handleScrollWheel( S32 x, S32 y, S32 clicks );
+	/*virtual*/ bool handleHover(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool handleMouseDown(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool handleMiddleMouseDown(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool handleRightMouseDown(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool handleScrollWheel( S32 x, S32 y, S32 clicks );
 
 	void drawStickyRect();
 
@@ -97,7 +97,7 @@ public:
 		Params();
 	};
 	/*virtual*/ void draw();
-	/*virtual*/ BOOL handleHover(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool handleHover(S32 x, S32 y, MASK mask);
 	/*virtual*/ void onMouseLeave(S32 x, S32 y, MASK mask);
 	/*virtual*/ void setVisible(BOOL visible);
 
diff --git a/indra/llui/lluictrl.cpp b/indra/llui/lluictrl.cpp
index 21afcae7c3..a5a1f7ac1a 100644
--- a/indra/llui/lluictrl.cpp
+++ b/indra/llui/lluictrl.cpp
@@ -342,12 +342,12 @@ void LLUICtrl::onMouseLeave(S32 x, S32 y, MASK mask)
 }
 
 //virtual 
-BOOL LLUICtrl::handleMouseDown(S32 x, S32 y, MASK mask)
+bool LLUICtrl::handleMouseDown(S32 x, S32 y, MASK mask)
 {
 
 	LL_DEBUGS() << "LLUICtrl::handleMouseDown calling	LLView)'s handleMouseUp (first initialized xui to: " << getPathname() << " )" << LL_ENDL;
   
-	BOOL handled  = LLView::handleMouseDown(x,y,mask);
+	bool handled  = LLView::handleMouseDown(x,y,mask);
 	
 	if (mMouseDownSignal)
 	{
@@ -362,12 +362,12 @@ BOOL LLUICtrl::handleMouseDown(S32 x, S32 y, MASK mask)
 }
 
 //virtual
-BOOL LLUICtrl::handleMouseUp(S32 x, S32 y, MASK mask)
+bool LLUICtrl::handleMouseUp(S32 x, S32 y, MASK mask)
 {
 
 	LL_DEBUGS() << "LLUICtrl::handleMouseUp calling LLView)'s handleMouseUp (first initialized xui to: " << getPathname() << " )" << LL_ENDL;
 
-	BOOL handled  = LLView::handleMouseUp(x,y,mask);
+	bool handled  = LLView::handleMouseUp(x,y,mask);
 	if (handled) {
 		LLViewerEventRecorder::instance().updateMouseEventInfo(x,y,-56,-56,getPathname()); 
 	}
@@ -382,9 +382,9 @@ BOOL LLUICtrl::handleMouseUp(S32 x, S32 y, MASK mask)
 }
 
 //virtual
-BOOL LLUICtrl::handleRightMouseDown(S32 x, S32 y, MASK mask)
+bool LLUICtrl::handleRightMouseDown(S32 x, S32 y, MASK mask)
 {
-	BOOL handled  = LLView::handleRightMouseDown(x,y,mask);
+	bool handled  = LLView::handleRightMouseDown(x,y,mask);
 	if (mRightMouseDownSignal)
 	{
 		(*mRightMouseDownSignal)(this,x,y,mask);
@@ -393,9 +393,9 @@ BOOL LLUICtrl::handleRightMouseDown(S32 x, S32 y, MASK mask)
 }
 
 //virtual
-BOOL LLUICtrl::handleRightMouseUp(S32 x, S32 y, MASK mask)
+bool LLUICtrl::handleRightMouseUp(S32 x, S32 y, MASK mask)
 {
-	BOOL handled  = LLView::handleRightMouseUp(x,y,mask);
+	bool handled  = LLView::handleRightMouseUp(x,y,mask);
 	if(mRightMouseUpSignal)
 	{
 		(*mRightMouseUpSignal)(this,x,y,mask);
@@ -403,9 +403,9 @@ BOOL LLUICtrl::handleRightMouseUp(S32 x, S32 y, MASK mask)
 	return handled;
 }
 
-BOOL LLUICtrl::handleDoubleClick(S32 x, S32 y, MASK mask)
+bool LLUICtrl::handleDoubleClick(S32 x, S32 y, MASK mask)
 {
-	BOOL handled = LLView::handleDoubleClick(x, y, mask);
+	bool handled = LLView::handleDoubleClick(x, y, mask);
 	if (mDoubleClickSignal)
 	{
 		(*mDoubleClickSignal)(this, x, y, mask);
diff --git a/indra/llui/lluictrl.h b/indra/llui/lluictrl.h
index f1b6746ea0..c5182fefe9 100644
--- a/indra/llui/lluictrl.h
+++ b/indra/llui/lluictrl.h
@@ -155,11 +155,11 @@ public:
 	/*virtual*/ void	onMouseEnter(S32 x, S32 y, MASK mask) override;
 	/*virtual*/ void	onMouseLeave(S32 x, S32 y, MASK mask) override;
 	/*virtual*/ BOOL	canFocusChildren() const override;
-	/*virtual*/ BOOL 	handleMouseDown(S32 x, S32 y, MASK mask) override;
-	/*virtual*/ BOOL 	handleMouseUp(S32 x, S32 y, MASK mask) override;
-	/*virtual*/ BOOL	handleRightMouseDown(S32 x, S32 y, MASK mask) override;
-	/*virtual*/ BOOL	handleRightMouseUp(S32 x, S32 y, MASK mask) override;
-	/*virtual*/ BOOL	handleDoubleClick(S32 x, S32 y, MASK mask) override;
+	/*virtual*/ bool 	handleMouseDown(S32 x, S32 y, MASK mask) override;
+	/*virtual*/ bool 	handleMouseUp(S32 x, S32 y, MASK mask) override;
+	/*virtual*/ bool	handleRightMouseDown(S32 x, S32 y, MASK mask) override;
+	/*virtual*/ bool	handleRightMouseUp(S32 x, S32 y, MASK mask) override;
+	/*virtual*/ bool	handleDoubleClick(S32 x, S32 y, MASK mask) override;
 
 	// From LLFocusableElement
 	/*virtual*/ void	setFocus( BOOL b ) override;
diff --git a/indra/llui/llview.cpp b/indra/llui/llview.cpp
index da7868d804..4a6d10a790 100644
--- a/indra/llui/llview.cpp
+++ b/indra/llui/llview.cpp
@@ -683,7 +683,7 @@ void LLView::setSnappedTo(const LLView* snap_view)
 {
 }
 
-BOOL LLView::handleHover(S32 x, S32 y, MASK mask)
+bool LLView::handleHover(S32 x, S32 y, MASK mask)
 {
 	return childrenHandleHover( x, y, mask ) != NULL;
 }
@@ -897,9 +897,9 @@ F32 LLView::getTooltipTimeout()
     : tooltip_delay);
 }
 
-BOOL LLView::handleToolTip(S32 x, S32 y, MASK mask)
+bool LLView::handleToolTip(S32 x, S32 y, MASK mask)
 {
-	BOOL handled = FALSE;
+	bool handled = false;
 
 	// parents provide tooltips first, which are optionally
 	// overridden by children, in case child is mouse_opaque
@@ -916,14 +916,14 @@ BOOL LLView::handleToolTip(S32 x, S32 y, MASK mask)
 			                              .sticky_rect(calcScreenRect())
 			                              .delay_time(getTooltipTimeout()));
 		}
-		handled = TRUE;
+		handled = true;
 	}
 
 	// child tooltips will override our own
 	LLView* child_handler = childrenHandleToolTip(x, y, mask);
 	if (child_handler)
 	{
-		handled = TRUE;
+		handled = true;
 	}
 
 	return handled;
@@ -1044,9 +1044,9 @@ BOOL LLView::handleUnicodeChar(llwchar uni_char, BOOL called_from_parent)
 }
 
 
-BOOL LLView::handleUnicodeCharHere(llwchar uni_char )
+bool LLView::handleUnicodeCharHere(llwchar uni_char )
 {
-	return FALSE;
+	return false;
 }
 
 
@@ -1062,56 +1062,56 @@ void LLView::onMouseCaptureLost()
 {
 }
 
-BOOL LLView::hasMouseCapture()
+bool LLView::hasMouseCapture()
 { 
 	return gFocusMgr.getMouseCapture() == this; 
 }
 
-BOOL LLView::handleMouseUp(S32 x, S32 y, MASK mask)
+bool LLView::handleMouseUp(S32 x, S32 y, MASK mask)
 {
 	LLView* r = childrenHandleMouseUp( x, y, mask );
 
 	return (r!=NULL);
 }
 
-BOOL LLView::handleMouseDown(S32 x, S32 y, MASK mask)
+bool LLView::handleMouseDown(S32 x, S32 y, MASK mask)
 {
 	LLView* r= childrenHandleMouseDown(x, y, mask );
 
 	return (r!=NULL);
 }
 
-BOOL LLView::handleDoubleClick(S32 x, S32 y, MASK mask)
+bool LLView::handleDoubleClick(S32 x, S32 y, MASK mask)
 {
 	return childrenHandleDoubleClick( x, y, mask ) != NULL;
 }
 
-BOOL LLView::handleScrollWheel(S32 x, S32 y, S32 clicks)
+bool LLView::handleScrollWheel(S32 x, S32 y, S32 clicks)
 {
 	return childrenHandleScrollWheel( x, y, clicks ) != NULL;
 }
 
-BOOL LLView::handleScrollHWheel(S32 x, S32 y, S32 clicks)
+bool LLView::handleScrollHWheel(S32 x, S32 y, S32 clicks)
 {
 	return childrenHandleScrollHWheel( x, y, clicks ) != NULL;
 }
 
-BOOL LLView::handleRightMouseDown(S32 x, S32 y, MASK mask)
+bool LLView::handleRightMouseDown(S32 x, S32 y, MASK mask)
 {
 	return childrenHandleRightMouseDown( x, y, mask ) != NULL;
 }
 
-BOOL LLView::handleRightMouseUp(S32 x, S32 y, MASK mask)
+bool LLView::handleRightMouseUp(S32 x, S32 y, MASK mask)
 {
 	return childrenHandleRightMouseUp( x, y, mask ) != NULL;
 }
  
-BOOL LLView::handleMiddleMouseDown(S32 x, S32 y, MASK mask)
+bool LLView::handleMiddleMouseDown(S32 x, S32 y, MASK mask)
 {
 	return childrenHandleMiddleMouseDown( x, y, mask ) != NULL;
 }
 
-BOOL LLView::handleMiddleMouseUp(S32 x, S32 y, MASK mask)
+bool LLView::handleMiddleMouseUp(S32 x, S32 y, MASK mask)
 {
 	return childrenHandleMiddleMouseUp( x, y, mask ) != NULL;
 }
diff --git a/indra/llui/llview.h b/indra/llui/llview.h
index 7360fd0fb9..39eaf12913 100644
--- a/indra/llui/llview.h
+++ b/indra/llui/llview.h
@@ -421,21 +421,21 @@ public:
 
 	// LLMouseHandler functions
 	//  Default behavior is to pass events to children
-	/*virtual*/ BOOL	handleHover(S32 x, S32 y, MASK mask);
-	/*virtual*/ BOOL	handleMouseUp(S32 x, S32 y, MASK mask);
-	/*virtual*/ BOOL	handleMouseDown(S32 x, S32 y, MASK mask);
-	/*virtual*/ BOOL	handleMiddleMouseUp(S32 x, S32 y, MASK mask);
-	/*virtual*/ BOOL	handleMiddleMouseDown(S32 x, S32 y, MASK mask);
-	/*virtual*/ BOOL	handleDoubleClick(S32 x, S32 y, MASK mask);
-	/*virtual*/ BOOL	handleScrollWheel(S32 x, S32 y, S32 clicks);
-	/*virtual*/ BOOL	handleScrollHWheel(S32 x, S32 y, S32 clicks);
-	/*virtual*/ BOOL	handleRightMouseDown(S32 x, S32 y, MASK mask);
-	/*virtual*/ BOOL	handleRightMouseUp(S32 x, S32 y, MASK mask);	
-	/*virtual*/ BOOL	handleToolTip(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool	handleHover(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool	handleMouseUp(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool	handleMouseDown(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool	handleMiddleMouseUp(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool	handleMiddleMouseDown(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool	handleDoubleClick(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool	handleScrollWheel(S32 x, S32 y, S32 clicks);
+	/*virtual*/ bool	handleScrollHWheel(S32 x, S32 y, S32 clicks);
+	/*virtual*/ bool	handleRightMouseDown(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool	handleRightMouseUp(S32 x, S32 y, MASK mask);
+	/*virtual*/ bool	handleToolTip(S32 x, S32 y, MASK mask);
 
 	/*virtual*/ const std::string& getName() const;
 	/*virtual*/ void	onMouseCaptureLost();
-	/*virtual*/ BOOL	hasMouseCapture();
+	/*virtual*/ bool	hasMouseCapture();
 	/*virtual*/ void	screenPointToLocal(S32 screen_x, S32 screen_y, S32* local_x, S32* local_y) const;
 	/*virtual*/ void	localPointToScreen(S32 local_x, S32 local_y, S32* screen_x, S32* screen_y) const;
 
@@ -514,7 +514,7 @@ public:
 	//virtual BOOL	addChildFromParam(const LLInitParam::BaseBlock& params) { return TRUE; }
 	virtual BOOL	handleKeyHere(KEY key, MASK mask);
 	virtual BOOL	handleKeyUpHere(KEY key, MASK mask);
-	virtual BOOL	handleUnicodeCharHere(llwchar uni_char);
+	virtual bool	handleUnicodeCharHere(llwchar uni_char);
 
 	virtual void	handleReshape(const LLRect& rect, bool by_user);
 	virtual void	dirtyRect();
diff --git a/indra/llui/llvirtualtrackball.cpp b/indra/llui/llvirtualtrackball.cpp
index 6e0aef740d..6e86c4671f 100644
--- a/indra/llui/llvirtualtrackball.cpp
+++ b/indra/llui/llvirtualtrackball.cpp
@@ -384,7 +384,7 @@ void LLVirtualTrackball::getAzimuthAndElevationDeg(const LLQuaternion &quat, F32
     elevation *= RAD_TO_DEG;
 }
 
-BOOL LLVirtualTrackball::handleHover(S32 x, S32 y, MASK mask)
+bool LLVirtualTrackball::handleHover(S32 x, S32 y, MASK mask)
 {
     if (hasMouseCapture())
     {
@@ -413,7 +413,7 @@ BOOL LLVirtualTrackball::handleHover(S32 x, S32 y, MASK mask)
         { // set on click mode
             if (!pointInTouchCircle(x, y))
             {
-                return TRUE; // don't drag outside the circle
+                return true; // don't drag outside the circle
             }
 
             F32 radius = mTouchArea->getRect().getWidth() / 2;
@@ -453,10 +453,10 @@ BOOL LLVirtualTrackball::handleHover(S32 x, S32 y, MASK mask)
         mPrevY = y;
         onCommit();
     }
-    return TRUE;
+    return true;
 }
 
-BOOL LLVirtualTrackball::handleMouseUp(S32 x, S32 y, MASK mask)
+bool LLVirtualTrackball::handleMouseUp(S32 x, S32 y, MASK mask)
 {
     if (hasMouseCapture())
     {
@@ -468,7 +468,7 @@ BOOL LLVirtualTrackball::handleMouseUp(S32 x, S32 y, MASK mask)
     return LLView::handleMouseUp(x, y, mask);
 }
 
-BOOL LLVirtualTrackball::handleMouseDown(S32 x, S32 y, MASK mask)
+bool LLVirtualTrackball::handleMouseDown(S32 x, S32 y, MASK mask)
 {
     if (pointInTouchCircle(x, y))
     {
@@ -481,7 +481,7 @@ BOOL LLVirtualTrackball::handleMouseDown(S32 x, S32 y, MASK mask)
     return LLView::handleMouseDown(x, y, mask);
 }
 
-BOOL LLVirtualTrackball::handleRightMouseDown(S32 x, S32 y, MASK mask)
+bool LLVirtualTrackball::handleRightMouseDown(S32 x, S32 y, MASK mask)
 {
     if (pointInTouchCircle(x, y))
     {
diff --git a/indra/llui/llvirtualtrackball.h b/indra/llui/llvirtualtrackball.h
index c7a893877b..574847de75 100644
--- a/indra/llui/llvirtualtrackball.h
+++ b/indra/llui/llvirtualtrackball.h
@@ -81,10 +81,10 @@ public:
     virtual ~LLVirtualTrackball();
     /*virtual*/ BOOL postBuild();
 
-    virtual BOOL    handleHover(S32 x, S32 y, MASK mask);
-    virtual BOOL    handleMouseUp(S32 x, S32 y, MASK mask);
-    virtual BOOL    handleMouseDown(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    handleMouseUp(S32 x, S32 y, MASK mask);
+    virtual bool    handleMouseDown(S32 x, S32 y, MASK mask);
+    virtual bool    handleRightMouseDown(S32 x, S32 y, MASK mask);
     virtual BOOL    handleKeyHere(KEY key, MASK mask);
 
     virtual void    draw();
diff --git a/indra/llui/llxyvector.cpp b/indra/llui/llxyvector.cpp
index d7ba243e1d..94dc72c86f 100644
--- a/indra/llui/llxyvector.cpp
+++ b/indra/llui/llxyvector.cpp
@@ -275,7 +275,7 @@ void LLXYVector::update()
     mYEntry->setValue(mValueY);
 }
 
-BOOL LLXYVector::handleHover(S32 x, S32 y, MASK mask)
+bool LLXYVector::handleHover(S32 x, S32 y, MASK mask)
 {
     if (hasMouseCapture())
     {
@@ -298,10 +298,10 @@ BOOL LLXYVector::handleHover(S32 x, S32 y, MASK mask)
         }
     }
 
-    return TRUE;
+    return true;
 }
 
-BOOL LLXYVector::handleMouseUp(S32 x, S32 y, MASK mask)
+bool LLXYVector::handleMouseUp(S32 x, S32 y, MASK mask)
 {
     if (hasMouseCapture())
     {
@@ -311,7 +311,7 @@ BOOL LLXYVector::handleMouseUp(S32 x, S32 y, MASK mask)
 
     if (mTouchArea->getRect().pointInRect(x, y))
     {
-        return TRUE;
+        return true;
     }
     else
     {
@@ -319,7 +319,7 @@ BOOL LLXYVector::handleMouseUp(S32 x, S32 y, MASK mask)
     }
 }
 
-BOOL LLXYVector::handleMouseDown(S32 x, S32 y, MASK mask)
+bool LLXYVector::handleMouseDown(S32 x, S32 y, MASK mask)
 {
 
     if (mTouchArea->getRect().pointInRect(x, y))
@@ -327,7 +327,7 @@ BOOL LLXYVector::handleMouseDown(S32 x, S32 y, MASK mask)
         gFocusMgr.setMouseCapture(this);
         make_ui_sound("UISndClick");
 
-        return TRUE;
+        return true;
     }
     else
     {
diff --git a/indra/llui/llxyvector.h b/indra/llui/llxyvector.h
index bb3822dd26..1f6c73387e 100644
--- a/indra/llui/llxyvector.h
+++ b/indra/llui/llxyvector.h
@@ -68,9 +68,9 @@ public:
     virtual ~LLXYVector();
     /*virtual*/ BOOL postBuild();
 
-    virtual BOOL	handleHover(S32 x, S32 y, MASK mask);
-    virtual BOOL	handleMouseUp(S32 x, S32 y, MASK mask);
-    virtual BOOL	handleMouseDown(S32 x, S32 y, MASK mask);
+    virtual bool	handleHover(S32 x, S32 y, MASK mask);
+    virtual bool	handleMouseUp(S32 x, S32 y, MASK mask);
+    virtual bool	handleMouseDown(S32 x, S32 y, MASK mask);
 
     virtual void	draw();