3bdf6e553d
Dear Users, This removes FloaterUnfocusedBackgroundOpaque, to achieve the same effect, modify InactiveFloaterTransparency, 1.5 should do the trick. PS: The settings are in the Vanity tab at the bottom. Now for developer nonsense: Also sync a bunch of the UI code with upstream Alchemy for opts and shtuff. Also let's translate the tooltips on the buttons on the top right of floaters Translators note that not all new strings have been translated yet as not all are upstream.
445 lines
14 KiB
C++
445 lines
14 KiB
C++
/**
|
|
* @file llfloater.h
|
|
* @brief LLFloater base class
|
|
*
|
|
* $LicenseInfo:firstyear=2002&license=viewergpl$
|
|
*
|
|
* Copyright (c) 2002-2009, Linden Research, Inc.
|
|
*
|
|
* Second Life Viewer Source Code
|
|
* The source code in this file ("Source Code") is provided by Linden Lab
|
|
* to you under the terms of the GNU General Public License, version 2.0
|
|
* ("GPL"), unless you have obtained a separate licensing agreement
|
|
* ("Other License"), formally executed by you and Linden Lab. Terms of
|
|
* the GPL can be found in doc/GPL-license.txt in this distribution, or
|
|
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
|
|
*
|
|
* There are special exceptions to the terms and conditions of the GPL as
|
|
* it is applied to this Source Code. View the full text of the exception
|
|
* in the file doc/FLOSS-exception.txt in this software distribution, or
|
|
* online at
|
|
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
|
|
*
|
|
* By copying, modifying or distributing this software, you acknowledge
|
|
* that you have read and understood your obligations described above,
|
|
* and agree to abide by those obligations.
|
|
*
|
|
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
|
|
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
|
|
* COMPLETENESS OR PERFORMANCE.
|
|
* $/LicenseInfo$
|
|
*/
|
|
|
|
// Floating "windows" within the GL display, like the inventory floater,
|
|
// mini-map floater, etc.
|
|
|
|
|
|
#ifndef LL_FLOATER_H
|
|
#define LL_FLOATER_H
|
|
|
|
#include "llpanel.h"
|
|
#include "lluuid.h"
|
|
#include "lltabcontainer.h"
|
|
#include "llnotificationcontext.h"
|
|
#include "llnotificationptr.h"
|
|
#include <set>
|
|
|
|
class LLDragHandle;
|
|
class LLResizeHandle;
|
|
class LLResizeBar;
|
|
class LLButton;
|
|
class LLMultiFloater;
|
|
class LLFloater;
|
|
|
|
const S32 LLFLOATER_VPAD = 6;
|
|
const S32 LLFLOATER_HPAD = 6;
|
|
const S32 LLFLOATER_CLOSE_BOX_SIZE = 16;
|
|
const S32 LLFLOATER_HEADER_SIZE = 18;
|
|
|
|
const BOOL RESIZE_YES = TRUE;
|
|
const BOOL RESIZE_NO = FALSE;
|
|
|
|
const S32 DEFAULT_MIN_WIDTH = 100;
|
|
const S32 DEFAULT_MIN_HEIGHT = 100;
|
|
|
|
const BOOL DRAG_ON_TOP = FALSE;
|
|
const BOOL DRAG_ON_LEFT = TRUE;
|
|
|
|
const BOOL MINIMIZE_YES = TRUE;
|
|
const BOOL MINIMIZE_NO = FALSE;
|
|
|
|
const BOOL CLOSE_YES = TRUE;
|
|
const BOOL CLOSE_NO = FALSE;
|
|
|
|
const BOOL ADJUST_VERTICAL_YES = TRUE;
|
|
const BOOL ADJUST_VERTICAL_NO = FALSE;
|
|
|
|
// associates a given notification instance with a particular floater
|
|
class LLFloaterNotificationContext :
|
|
public LLNotificationContext
|
|
{
|
|
public:
|
|
LLFloaterNotificationContext(LLHandle<LLFloater> floater_handle) :
|
|
mFloaterHandle(floater_handle)
|
|
{}
|
|
|
|
LLFloater* getFloater() { return mFloaterHandle.get(); }
|
|
private:
|
|
LLHandle<LLFloater> mFloaterHandle;
|
|
};
|
|
|
|
|
|
class LLFloater : public LLPanel
|
|
{
|
|
friend class LLFloaterView;
|
|
friend class LLMultiFloater;
|
|
public:
|
|
enum EFloaterButton
|
|
{
|
|
BUTTON_CLOSE = 0,
|
|
BUTTON_RESTORE,
|
|
BUTTON_MINIMIZE,
|
|
BUTTON_TEAR_OFF,
|
|
BUTTON_EDIT,
|
|
BUTTON_COUNT
|
|
};
|
|
|
|
// Load translations for tooltips for standard buttons
|
|
static void initClass();
|
|
|
|
LLFloater();
|
|
LLFloater(const std::string& name); //simple constructor for data-driven initialization
|
|
LLFloater( const std::string& name, const LLRect& rect, const std::string& title,
|
|
BOOL resizable = FALSE,
|
|
S32 min_width = DEFAULT_MIN_WIDTH,
|
|
S32 min_height = DEFAULT_MIN_HEIGHT,
|
|
BOOL drag_on_left = FALSE,
|
|
BOOL minimizable = TRUE,
|
|
BOOL close_btn = TRUE,
|
|
BOOL bordered = BORDER_NO);
|
|
|
|
LLFloater( const std::string& name, const std::string& rect_control, const std::string& title,
|
|
BOOL resizable = FALSE,
|
|
S32 min_width = DEFAULT_MIN_WIDTH,
|
|
S32 min_height = DEFAULT_MIN_HEIGHT,
|
|
BOOL drag_on_left = FALSE,
|
|
BOOL minimizable = TRUE,
|
|
BOOL close_btn = TRUE,
|
|
BOOL bordered = BORDER_NO);
|
|
|
|
virtual ~LLFloater();
|
|
|
|
virtual LLXMLNodePtr getXML(bool save_children = true) const;
|
|
static LLView* fromXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory);
|
|
void initFloaterXML(LLXMLNodePtr node, LLView *parent, LLUICtrlFactory *factory, BOOL open = TRUE);
|
|
|
|
/*virtual*/ void handleReshape(const LLRect& new_rect, bool by_user = false);
|
|
/*virtual*/ BOOL canSnapTo(const LLView* other_view);
|
|
/*virtual*/ void setSnappedTo(const LLView* snap_view);
|
|
/*virtual*/ void setFocus( BOOL b );
|
|
/*virtual*/ void setIsChrome(BOOL is_chrome);
|
|
|
|
// Can be called multiple times to reset floater parameters.
|
|
// Deletes all children of the floater.
|
|
virtual void initFloater(const std::string& title, BOOL resizable,
|
|
S32 min_width, S32 min_height, BOOL drag_on_left,
|
|
BOOL minimizable, BOOL close_btn);
|
|
|
|
virtual void open(); /* Flawfinder: ignore */
|
|
|
|
// If allowed, close the floater cleanly, releasing focus.
|
|
// app_quitting is passed to onClose() below.
|
|
virtual void close(bool app_quitting = false);
|
|
|
|
/*virtual*/ void reshape(S32 width, S32 height, BOOL called_from_parent = TRUE);
|
|
|
|
// Release keyboard and mouse focus
|
|
void releaseFocus();
|
|
|
|
// moves to center of gFloaterView
|
|
void center();
|
|
// applies rectangle stored in mRectControl, if any
|
|
void applyRectControl();
|
|
|
|
|
|
LLMultiFloater* getHost() { return (LLMultiFloater*)mHostHandle.get(); }
|
|
|
|
void applyTitle();
|
|
const std::string& getCurrentTitle() const;
|
|
void setTitle( const std::string& title);
|
|
std::string getTitle() const;
|
|
void setShortTitle( const std::string& short_title );
|
|
std::string getShortTitle() const;
|
|
void setTitleVisible(bool visible);
|
|
virtual void setMinimized(BOOL b);
|
|
void moveResizeHandlesToFront();
|
|
void addDependentFloater(LLFloater* dependent, BOOL reposition = TRUE);
|
|
void addDependentFloater(LLHandle<LLFloater> dependent_handle, BOOL reposition = TRUE);
|
|
LLFloater* getDependee() { return (LLFloater*)mDependeeHandle.get(); }
|
|
void removeDependentFloater(LLFloater* dependent);
|
|
BOOL isMinimized() const { return mMinimized; }
|
|
virtual BOOL isFrontmost();
|
|
BOOL isDependent() { return !mDependeeHandle.isDead(); }
|
|
void setCanMinimize(BOOL can_minimize);
|
|
void setCanClose(BOOL can_close);
|
|
void setCanTearOff(BOOL can_tear_off);
|
|
virtual void setCanResize(BOOL can_resize);
|
|
void setCanDrag(BOOL can_drag);
|
|
void setHost(LLMultiFloater* host);
|
|
BOOL isResizable() const { return mResizable; }
|
|
void setResizeLimits( S32 min_width, S32 min_height );
|
|
void getResizeLimits( S32* min_width, S32* min_height ) { *min_width = mMinWidth; *min_height = mMinHeight; }
|
|
|
|
bool isMinimizeable() const{ return mButtonsEnabled[BUTTON_MINIMIZE]; }
|
|
// Does this window have a close button, NOT can we close it right now.
|
|
bool isCloseable() const{ return (mButtonsEnabled[BUTTON_CLOSE]); }
|
|
bool isDragOnLeft() const{ return mDragOnLeft; }
|
|
S32 getMinWidth() const{ return mMinWidth; }
|
|
S32 getMinHeight() const{ return mMinHeight; }
|
|
|
|
virtual BOOL handleMouseDown(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 void draw();
|
|
virtual void drawShadow(LLPanel* panel);
|
|
|
|
virtual void onOpen() {}
|
|
|
|
// Call destroy() to free memory, or setVisible(FALSE) to keep it
|
|
// If app_quitting, you might not want to save your visibility.
|
|
// Defaults to destroy().
|
|
virtual void onClose(bool app_quitting) { destroy(); }
|
|
|
|
// This cannot be "const" until all derived floater canClose()
|
|
// methods are const as well. JC
|
|
virtual BOOL canClose() { return TRUE; }
|
|
|
|
virtual void setVisible(BOOL visible);
|
|
void setFrontmost(BOOL take_focus = TRUE);
|
|
|
|
// Defaults to false.
|
|
virtual BOOL canSaveAs() const { return FALSE; }
|
|
|
|
virtual void saveAs() {}
|
|
|
|
void setSnapTarget(LLHandle<LLFloater> handle) { mSnappedTo = handle; }
|
|
void clearSnapTarget() { mSnappedTo.markDead(); }
|
|
LLHandle<LLFloater> getSnapTarget() const { return mSnappedTo; }
|
|
|
|
LLHandle<LLFloater> getHandle() const { return getDerivedHandle<LLFloater>(); }
|
|
|
|
// Return a closeable floater, if any, given the current focus.
|
|
static LLFloater* getClosableFloaterFromFocus();
|
|
|
|
// Close the floater returned by getClosableFloaterFromFocus() and
|
|
// handle refocusing.
|
|
static void closeFocusedFloater();
|
|
|
|
LLNotificationPtr addContextualNotification(const std::string& name, const LLSD& substitutions = LLSD());
|
|
|
|
void onClickClose();
|
|
void onClickMinimize();
|
|
void onClickTearOff();
|
|
void onClickEdit();
|
|
|
|
static void setFloaterHost(LLMultiFloater* hostp) {sHostp = hostp; }
|
|
static void setEditModeEnabled(BOOL enable);
|
|
static BOOL getEditModeEnabled() { return sEditModeEnabled; }
|
|
static LLMultiFloater* getFloaterHost() {return sHostp; }
|
|
|
|
void updateTransparency(ETypeTransparency transparency_type);
|
|
|
|
void enableResizeCtrls(bool enable, bool width = true, bool height = true);
|
|
protected:
|
|
|
|
virtual void bringToFront(S32 x, S32 y);
|
|
virtual void setVisibleAndFrontmost(BOOL take_focus=TRUE);
|
|
|
|
void setExpandedRect(const LLRect& rect) { mExpandedRect = rect; } // size when not minimized
|
|
const LLRect& getExpandedRect() const { return mExpandedRect; }
|
|
|
|
void setAutoFocus(BOOL focus) { mAutoFocus = focus; } // whether to automatically take focus when opened
|
|
LLDragHandle* getDragHandle() const { return mDragHandle; }
|
|
|
|
void destroy() { die(); } // Don't call this directly. You probably want to call close(). JC
|
|
|
|
private:
|
|
void setForeground(BOOL b); // called only by floaterview
|
|
void cleanupHandles(); // remove handles to dead floaters
|
|
void createMinimizeButton();
|
|
void updateButtons();
|
|
void buildButtons();
|
|
BOOL offerClickToButton(S32 x, S32 y, MASK mask, EFloaterButton index);
|
|
void addResizeCtrls();
|
|
void layoutResizeCtrls();
|
|
|
|
static void updateActiveFloaterTransparency();
|
|
static void updateInactiveFloaterTransparency();
|
|
void updateTransparency(LLView* view, ETypeTransparency transparency_type);
|
|
|
|
LLRect mExpandedRect;
|
|
|
|
protected:
|
|
LLDragHandle* mDragHandle;
|
|
LLResizeBar* mResizeBar[4];
|
|
LLResizeHandle* mResizeHandle[4];
|
|
LLButton *mMinimizeButton;
|
|
|
|
LLButton* mButtons[BUTTON_COUNT];
|
|
private:
|
|
BOOL mCanTearOff;
|
|
BOOL mMinimized;
|
|
BOOL mForeground;
|
|
LLHandle<LLFloater> mDependeeHandle;
|
|
std::string mTitle;
|
|
std::string mShortTitle;
|
|
|
|
BOOL mFirstLook; // TRUE if the _next_ time this floater is visible will be the first time in the session that it is visible.
|
|
|
|
BOOL mResizable;
|
|
S32 mMinWidth;
|
|
S32 mMinHeight;
|
|
|
|
BOOL mEditing;
|
|
|
|
typedef std::set<LLHandle<LLFloater> > handle_set_t;
|
|
typedef std::set<LLHandle<LLFloater> >::iterator handle_set_iter_t;
|
|
handle_set_t mDependents;
|
|
bool mDragOnLeft;
|
|
|
|
bool mButtonsEnabled[BUTTON_COUNT];
|
|
F32 mButtonScale;
|
|
BOOL mAutoFocus;
|
|
LLHandle<LLFloater> mSnappedTo;
|
|
|
|
LLHandle<LLFloater> mHostHandle;
|
|
LLHandle<LLFloater> mLastHostHandle;
|
|
|
|
static LLMultiFloater* sHostp;
|
|
static BOOL sEditModeEnabled;
|
|
static std::string sButtonActiveImageNames[BUTTON_COUNT];
|
|
static std::string sButtonInactiveImageNames[BUTTON_COUNT];
|
|
static std::string sButtonPressedImageNames[BUTTON_COUNT];
|
|
static std::string sButtonNames[BUTTON_COUNT];
|
|
static std::string sButtonToolTips[BUTTON_COUNT];
|
|
|
|
typedef void (LLFloater::*button_callback)();
|
|
|
|
static button_callback sButtonCallbacks[BUTTON_COUNT];
|
|
|
|
typedef std::map<LLHandle<LLFloater>, LLFloater*> handle_map_t;
|
|
typedef std::map<LLHandle<LLFloater>, LLFloater*>::iterator handle_map_iter_t;
|
|
static handle_map_t sFloaterMap;
|
|
|
|
std::vector<LLHandle<LLView> > mMinimizedHiddenChildren;
|
|
|
|
BOOL mHasBeenDraggedWhileMinimized;
|
|
S32 mPreviousMinimizedBottom;
|
|
S32 mPreviousMinimizedLeft;
|
|
|
|
LLFloaterNotificationContext* mNotificationContext;
|
|
};
|
|
|
|
/////////////////////////////////////////////////////////////
|
|
// LLFloaterView
|
|
// Parent of all floating panels
|
|
|
|
class LLFloaterView : public LLUICtrl
|
|
{
|
|
public:
|
|
LLFloaterView( const std::string& name, const LLRect& rect );
|
|
|
|
/*virtual*/ void reshape(S32 width, S32 height, BOOL called_from_parent = TRUE);
|
|
void reshapeFloater(S32 width, S32 height, BOOL called_from_parent, BOOL adjust_vertical);
|
|
|
|
/*virtual*/ void draw();
|
|
/*virtual*/ LLRect getSnapRect() const;
|
|
/*virtual*/ void refresh();
|
|
|
|
void getNewFloaterPosition( S32* left, S32* top );
|
|
void resetStartingFloaterPosition();
|
|
LLRect findNeighboringPosition( LLFloater* reference_floater, LLFloater* neighbor );
|
|
|
|
// Given a child of gFloaterView, make sure this view can fit entirely onscreen.
|
|
void adjustToFitScreen(LLFloater* floater, BOOL allow_partial_outside);
|
|
|
|
void getMinimizePosition( S32 *left, S32 *bottom);
|
|
void restoreAll(); // un-minimize all floaters
|
|
typedef std::set<LLView*> skip_list_t;
|
|
void pushVisibleAll(BOOL visible, const skip_list_t& skip_list = skip_list_t());
|
|
void popVisibleAll(const skip_list_t& skip_list = skip_list_t());
|
|
|
|
void setCycleMode(BOOL mode) { mFocusCycleMode = mode; }
|
|
BOOL getCycleMode() const { return mFocusCycleMode; }
|
|
void bringToFront( LLFloater* child, BOOL give_focus = TRUE );
|
|
void highlightFocusedFloater();
|
|
void unhighlightFocusedFloater();
|
|
void focusFrontFloater();
|
|
void destroyAllChildren();
|
|
// attempt to close all floaters
|
|
void closeAllChildren(bool app_quitting);
|
|
BOOL allChildrenClosed();
|
|
// <edit>
|
|
void minimizeAllChildren();
|
|
// </edit>
|
|
|
|
LLFloater* getFrontmost() const;
|
|
LLFloater* getBackmost() const;
|
|
LLFloater* getParentFloater(LLView* viewp) const;
|
|
LLFloater* getFocusedFloater() const;
|
|
void syncFloaterTabOrder();
|
|
|
|
// Returns z order of child provided. 0 is closest, larger numbers
|
|
// are deeper in the screen. If there is no such child, the return
|
|
// value is not defined.
|
|
S32 getZOrder(LLFloater* child);
|
|
|
|
void setSnapOffsetBottom(S32 offset) { mSnapOffsetBottom = offset; }
|
|
|
|
private:
|
|
S32 mColumn;
|
|
S32 mNextLeft;
|
|
S32 mNextTop;
|
|
BOOL mFocusCycleMode;
|
|
S32 mSnapOffsetBottom;
|
|
};
|
|
|
|
// visibility policy specialized for floaters
|
|
template<>
|
|
class VisibilityPolicy<LLFloater>
|
|
{
|
|
public:
|
|
// visibility methods
|
|
static bool visible(LLFloater* instance, const LLSD& key)
|
|
{
|
|
if (instance)
|
|
{
|
|
return !instance->isMinimized() && instance->isInVisibleChain();
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
static void show(LLFloater* instance, const LLSD& key);
|
|
|
|
static void hide(LLFloater* instance, const LLSD& key)
|
|
{
|
|
if (instance) instance->close();
|
|
}
|
|
};
|
|
|
|
|
|
// singleton implementation for floaters (provides visibility policy)
|
|
// https://wiki.lindenlab.com/mediawiki/index.php?title=LLFloaterSingleton&oldid=164990
|
|
|
|
template <class T> class LLFloaterSingleton : public LLUISingleton<T, VisibilityPolicy<LLFloater> >
|
|
{
|
|
};
|
|
|
|
extern LLFloaterView* gFloaterView;
|
|
|
|
#endif // LL_FLOATER_H
|
|
|
|
|
|
|