summaryrefslogtreecommitdiff
path: root/indra/newview/llchiclet.h
diff options
context:
space:
mode:
Diffstat (limited to 'indra/newview/llchiclet.h')
-rw-r--r--indra/newview/llchiclet.h1271
1 files changed, 1128 insertions, 143 deletions
diff --git a/indra/newview/llchiclet.h b/indra/newview/llchiclet.h
index f2b859a090..a6e12006a1 100644
--- a/indra/newview/llchiclet.h
+++ b/indra/newview/llchiclet.h
@@ -1,286 +1,1271 @@
/**
-* @file llchiclet.h
-* @brief LLChiclet class header file
-*
-* $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$
-*/
+ * @file llchiclet.h
+ * @brief LLChiclet class header file
+ *
+ * $LicenseInfo:firstyear=2002&license=viewerlgpl$
+ * Second Life Viewer Source Code
+ * Copyright (C) 2010, Linden Research, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation;
+ * version 2.1 of the License only.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA
+ * $/LicenseInfo$
+ */
#ifndef LL_LLCHICLET_H
#define LL_LLCHICLET_H
+#include "llavatariconctrl.h"
+#include "llbutton.h"
#include "llpanel.h"
+#include "lltextbox.h"
+#include "lloutputmonitorctrl.h"
+#include "llgroupmgr.h"
+#include "llimview.h"
+
+class LLMenuGL;
+class LLIMFloater;
+
+/**
+ * Class for displaying amount of messages/notifications(unread).
+ */
+class LLChicletNotificationCounterCtrl : public LLTextBox
+{
+public:
+
+ struct Params : public LLInitParam::Block<Params, LLTextBox::Params>
+ {
+ /**
+ * Contains maximum displayed count of unread messages. Default value is 9.
+ *
+ * If count is less than "max_unread_count" will be displayed as is.
+ * Otherwise 9+ will be shown (for default value).
+ */
+ Optional<S32> max_displayed_count;
+
+ Params();
+ };
+
+ /**
+ * Sets number of notifications
+ */
+ virtual void setCounter(S32 counter);
+
+ /**
+ * Returns number of notifications
+ */
+ virtual S32 getCounter() const { return mCounter; }
+
+ /**
+ * Returns width, required to display amount of notifications in text form.
+ * Width is the only valid value.
+ */
+ /*virtual*/ LLRect getRequiredRect();
+
+ /**
+ * Sets number of notifications using LLSD
+ */
+ /*virtual*/ void setValue(const LLSD& value);
+
+ /**
+ * Returns number of notifications wrapped in LLSD
+ */
+ /*virtual*/ LLSD getValue() const;
+
+protected:
+
+ LLChicletNotificationCounterCtrl(const Params& p);
+ friend class LLUICtrlFactory;
+
+private:
+
+ S32 mCounter;
+ S32 mInitialWidth;
+ S32 mMaxDisplayedCount;
+};
+
+/**
+ * Class for displaying avatar's icon in P2P chiclet.
+ */
+class LLChicletAvatarIconCtrl : public LLAvatarIconCtrl
+{
+public:
+
+ struct Params : public LLInitParam::Block<Params, LLAvatarIconCtrl::Params>
+ {
+ Params()
+ {
+ draw_tooltip(FALSE);
+ mouse_opaque(FALSE);
+ default_icon_name("Generic_Person");
+ };
+ };
+
+protected:
-class LLTextBox;
-class LLIconCtrl;
-class LLAvatarIconCtrl;
-class LLVoiceControlPanel;
-class LLOutputMonitorCtrl;
+ LLChicletAvatarIconCtrl(const Params& p);
+ friend class LLUICtrlFactory;
+};
+
+/**
+ * Class for displaying group's icon in Group chiclet.
+ */
+class LLChicletGroupIconCtrl : public LLIconCtrl
+{
+public:
+
+ struct Params : public LLInitParam::Block<Params, LLIconCtrl::Params>
+ {
+ Optional<std::string> default_icon;
+
+ Params()
+ : default_icon("default_icon", "Generic_Group")
+ {
+ };
+ };
+ /**
+ * Sets icon, if value is LLUUID::null - default icon will be set.
+ */
+ virtual void setValue(const LLSD& value );
+
+protected:
+
+ LLChicletGroupIconCtrl(const Params& p);
+ friend class LLUICtrlFactory;
+
+ std::string mDefaultIcon;
+};
+
+/**
+ * Class for displaying icon in inventory offer chiclet.
+ */
+class LLChicletInvOfferIconCtrl : public LLChicletAvatarIconCtrl
+{
+public:
+
+ struct Params :
+ public LLInitParam::Block<Params, LLChicletAvatarIconCtrl::Params>
+ {
+ Optional<std::string> default_icon;
+
+ Params()
+ : default_icon("default_icon", "Generic_Object_Small")
+ {
+ avatar_id = LLUUID::null;
+ };
+ };
+
+ /**
+ * Sets icon, if value is LLUUID::null - default icon will be set.
+ */
+ virtual void setValue(const LLSD& value );
+
+protected:
+
+ LLChicletInvOfferIconCtrl(const Params& p);
+ friend class LLUICtrlFactory;
+
+private:
+ std::string mDefaultIcon;
+};
+
+/**
+ * Class for displaying of speaker's voice indicator
+ */
+class LLChicletSpeakerCtrl : public LLOutputMonitorCtrl
+{
+public:
+
+ struct Params : public LLInitParam::Block<Params, LLOutputMonitorCtrl::Params>
+ {
+ Params(){};
+ };
+protected:
+
+ LLChicletSpeakerCtrl(const Params&p);
+ friend class LLUICtrlFactory;
+};
+
+/**
+ * Base class for all chiclets.
+ */
class LLChiclet : public LLUICtrl
{
public:
struct Params : public LLInitParam::Block<Params, LLUICtrl::Params>
{
- Params(){};
+ Optional<bool> show_counter,
+ enable_counter;
+
+ Params();
};
- virtual ~LLChiclet();
+ /*virtual*/ ~LLChiclet();
+
+ /**
+ * Associates chat session id with chiclet.
+ */
+ virtual void setSessionId(const LLUUID& session_id) { mSessionId = session_id; }
+ /**
+ * Returns associated chat session.
+ */
+ virtual const LLUUID& getSessionId() const { return mSessionId; }
+
+ /**
+ * Sets number of unread notifications.
+ */
virtual void setCounter(S32 counter) = 0;
+ /**
+ * Returns number of unread notifications.
+ */
virtual S32 getCounter() = 0;
- virtual void setShowCounter(bool show) {mShowCounter = show;};
+ /**
+ * Sets show counter state.
+ */
+ virtual void setShowCounter(bool show) { mShowCounter = show; }
+ /**
+ * Returns show counter state.
+ */
virtual bool getShowCounter() {return mShowCounter;};
- virtual boost::signals::connection setLeftButtonClickCallback(
+ /**
+ * Connects chiclet clicked event with callback.
+ */
+ /*virtual*/ boost::signals2::connection setLeftButtonClickCallback(
const commit_callback_t& cb);
+ typedef boost::function<void (LLChiclet* ctrl, const LLSD& param)>
+ chiclet_size_changed_callback_t;
+
+ /**
+ * Connects chiclets size changed event with callback.
+ */
+ virtual boost::signals2::connection setChicletSizeChangedCallback(
+ const chiclet_size_changed_callback_t& cb);
+
+ /**
+ * Sets IM Session id using LLSD
+ */
+ /*virtual*/ LLSD getValue() const;
+
+ /**
+ * Returns IM Session id using LLSD
+ */
+ /*virtual*/ void setValue(const LLSD& value);
+
protected:
friend class LLUICtrlFactory;
LLChiclet(const Params& p);
- virtual BOOL handleMouseDown(S32 x, S32 y, MASK mask);
+ /**
+ * Notifies subscribers about click on chiclet.
+ */
+ /*virtual*/ BOOL handleMouseDown(S32 x, S32 y, MASK mask);
+
+ /**
+ * Notifies subscribers about chiclet size changed event.
+ */
+ virtual void onChicletSizeChanged();
+
+private:
+
+ LLUUID mSessionId;
-protected:
- S32 mCounter;
bool mShowCounter;
+
+ typedef boost::signals2::signal<void (LLChiclet* ctrl, const LLSD& param)>
+ chiclet_size_changed_signal_t;
+
+ chiclet_size_changed_signal_t mChicletSizeChangedSignal;
};
+
+/**
+ * Base class for Instant Message chiclets.
+ * IMChiclet displays icon, number of unread messages(optional)
+ * and voice chat status(optional).
+ */
class LLIMChiclet : public LLChiclet
{
public:
- static LLChiclet* create(LLSD* imSessionId = NULL);
+ enum EType {
+ TYPE_UNKNOWN,
+ TYPE_IM,
+ TYPE_GROUP,
+ TYPE_AD_HOC
+ };
+ struct Params : public LLInitParam::Block<Params, LLChiclet::Params>
+ {
+ Params(){}
+ };
- void setCounter(S32);
+
+ virtual ~LLIMChiclet() {};
- S32 getCounter() {return mCounter;};
+ /**
+ * It is used for default setting up of chicklet:click handler, etc.
+ */
+ BOOL postBuild();
+ /**
+ * Sets IM session name. This name will be displayed in chiclet tooltip.
+ */
+ virtual void setIMSessionName(const std::string& name) { setToolTip(name); }
+
+ /**
+ * Sets id of person/group user is chatting with.
+ * Session id should be set before calling this
+ */
+ virtual void setOtherParticipantId(const LLUUID& other_participant_id) { mOtherParticipantId = other_participant_id; }
+
+ /**
+ * Gets id of person/group user is chatting with.
+ */
+ virtual LLUUID getOtherParticipantId() { return mOtherParticipantId; }
+
+ /**
+ * Init Speaker Control with speaker's ID
+ */
+ virtual void initSpeakerControl();
+
+ /**
+ * set status (Shows/Hide) for voice control.
+ */
+ virtual void setShowSpeaker(bool show);
+
+ /**
+ * Returns voice chat status control visibility.
+ */
+ virtual bool getShowSpeaker() {return mShowSpeaker;};
+
+ /**
+ * Shows/Hides for voice control for a chiclet.
+ */
+ virtual void toggleSpeakerControl();
+
+ /**
+ * Sets number of unread messages. Will update chiclet's width if number text
+ * exceeds size of counter and notify it's parent about size change.
+ */
+ virtual void setCounter(S32);
+
+ /**
+ * Enables/disables the counter control for a chiclet.
+ */
+ virtual void enableCounterControl(bool enable);
+
+ /**
+ * Sets show counter state.
+ */
+ virtual void setShowCounter(bool show);
+
+ /**
+ * Shows/Hides for counter control for a chiclet.
+ */
+ virtual void toggleCounterControl();
+
+ /**
+ * Sets required width for a chiclet according to visible controls.
+ */
+ virtual void setRequiredWidth();
+
+ /**
+ * Shows/hides overlay icon concerning new unread messages.
+ */
+ virtual void setShowNewMessagesIcon(bool show);
+
+ /**
+ * Returns visibility of overlay icon concerning new unread messages.
+ */
+ virtual bool getShowNewMessagesIcon();
+
+ virtual void draw();
+
+ /**
+ * Determine whether given ID refers to a group or an IM chat session.
+ *
+ * This is used when we need to chose what IM chiclet (P2P/group)
+ * class to instantiate.
+ *
+ * @param session_id session ID.
+ * @return TYPE_GROUP in case of group chat session,
+ * TYPE_IM in case of P2P session,
+ * TYPE_UNKNOWN otherwise.
+ */
+ static EType getIMSessionType(const LLUUID& session_id);
+
+ /**
+ * The action taken on mouse down event.
+ *
+ * Made public so that it can be triggered from outside
+ * (more specifically, from the Active IM window).
+ */
+ virtual void onMouseDown();
+
+ virtual void setToggleState(bool toggle);
+
+ /**
+ * Displays popup menu.
+ */
+ virtual BOOL handleRightMouseDown(S32 x, S32 y, MASK mask);
- const LLSD& getIMSessionId() const {return mIMSessionId;};
+protected:
+
+ LLIMChiclet(const LLIMChiclet::Params& p);
+
+protected:
+
+ /**
+ * Creates chiclet popup menu.
+ */
+ virtual void createPopupMenu() = 0;
- void setIMSessionId(LLSD* imSessionId) {if (imSessionId) mIMSessionId = *imSessionId;};
- void setIMSessionName(const std::string& name);
- void setOtherParticipantId(const LLUUID& other_participant_id);
+ /**
+ * Enables/disables menus.
+ */
+ virtual void updateMenuItems() {};
- void setShowSpeaker(bool show);
+ bool canCreateMenu();
+
+ LLMenuGL* mPopupMenu;
+
+ bool mShowSpeaker;
+ bool mCounterEnabled;
+ /* initial width of chiclet, should not include counter or speaker width */
+ S32 mDefaultWidth;
+
+ LLIconCtrl* mNewMessagesIcon;
+ LLChicletNotificationCounterCtrl* mCounterCtrl;
+ LLChicletSpeakerCtrl* mSpeakerCtrl;
+ LLButton* mChicletButton;
+
+ /** the id of another participant, either an avatar id or a group id*/
+ LLUUID mOtherParticipantId;
+
+ template<typename Container>
+ struct CollectChicletCombiner {
+ typedef Container result_type;
+
+ template<typename InputIterator>
+ Container operator()(InputIterator first, InputIterator last) const {
+ Container c = Container();
+ for (InputIterator iter = first; iter != last; iter++) {
+ if (*iter != NULL) {
+ c.push_back(*iter);
+ }
+ }
+ return c;
+ }
+ };
- bool getShowSpeaker() {return mShowSpeaker;};
+public:
+ static boost::signals2::signal<LLChiclet* (const LLUUID&),
+ CollectChicletCombiner<std::list<LLChiclet*> > >
+ sFindChicletsSignal;
+};
- enum SpeakerStatus
+/**
+ * Implements P2P chiclet.
+ */
+class LLIMP2PChiclet : public LLIMChiclet
+{
+public:
+ struct Params : public LLInitParam::Block<Params, LLIMChiclet::Params>
{
- SPREAKER_ACTIVE,
- SPEAKER_IDLE
+ Optional<LLButton::Params> chiclet_button;
+
+ Optional<LLChicletAvatarIconCtrl::Params> avatar_icon;
+
+ Optional<LLChicletNotificationCounterCtrl::Params> unread_notifications;
+
+ Optional<LLChicletSpeakerCtrl::Params> speaker;
+
+ Optional<LLIconCtrl::Params> new_message_icon;
+
+ Optional<bool> show_speaker;
+
+ Params();
};
- void setSpeakerStatus(SpeakerStatus status);
+ /* virtual */ void setOtherParticipantId(const LLUUID& other_participant_id);
- SpeakerStatus getSpeakerStatus() {return mSpeakerStatus;};
+ /**
+ * Init Speaker Control with speaker's ID
+ */
+ /*virtual*/ void initSpeakerControl();
- ~LLIMChiclet();
+ /**
+ * Returns number of unread messages.
+ */
+ /*virtual*/ S32 getCounter() { return mCounterCtrl->getCounter(); }
protected:
- LLIMChiclet(const LLChiclet::Params& p);
+ LLIMP2PChiclet(const Params& p);
friend class LLUICtrlFactory;
- S32 calcCounterWidth();
+ /**
+ * Creates chiclet popup menu. Will create P2P or Group IM Chat menu
+ * based on other participant's id.
+ */
+ virtual void createPopupMenu();
+
+ /**
+ * Processes clicks on chiclet popup menu.
+ */
+ virtual void onMenuItemClicked(const LLSD& user_data);
+
+ /**
+ * Enables/disables menus based on relationship with other participant.
+ * Enables/disables "show session" menu item depending on visible IM floater existence.
+ */
+ virtual void updateMenuItems();
+
+private:
+
+ LLChicletAvatarIconCtrl* mChicletIconCtrl;
+};
- //overrides
+/**
+ * Implements AD-HOC chiclet.
+ */
+class LLAdHocChiclet : public LLIMChiclet
+{
public:
+ struct Params : public LLInitParam::Block<Params, LLIMChiclet::Params>
+ {
+ Optional<LLButton::Params> chiclet_button;
+
+ Optional<LLChicletAvatarIconCtrl::Params> avatar_icon;
+
+ Optional<LLChicletNotificationCounterCtrl::Params> unread_notifications;
+
+ Optional<LLChicletSpeakerCtrl::Params> speaker;
+
+ Optional<LLIconCtrl::Params> new_message_icon;
+
+ Optional<bool> show_speaker;
+
+ Optional<LLColor4> avatar_icon_color;
+
+ Params();
+ };
- void setShowCounter(bool show);
+ /**
+ * Sets session id.
+ * Session ID for group chat is actually Group ID.
+ */
+ /*virtual*/ void setSessionId(const LLUUID& session_id);
- void draw();
+ /**
+ * Keep Speaker Control with actual speaker's ID
+ */
+ /*virtual*/ void draw();
- LLRect getRequiredRect();
+ /**
+ * Init Speaker Control with speaker's ID
+ */
+ /*virtual*/ void initSpeakerControl();
+
+ /**
+ * Returns number of unread messages.
+ */
+ /*virtual*/ S32 getCounter() { return mCounterCtrl->getCounter(); }
protected:
- LLAvatarIconCtrl* mAvatar;
- LLTextBox* mCounterText;
- LLIconCtrl* mSpeaker;
+ LLAdHocChiclet(const Params& p);
+ friend class LLUICtrlFactory;
- LLSD mIMSessionId;
- bool mShowSpeaker;
- SpeakerStatus mSpeakerStatus;
+ /**
+ * Creates chiclet popup menu. Will create AdHoc Chat menu
+ * based on other participant's id.
+ */
+ virtual void createPopupMenu();
+
+ /**
+ * Processes clicks on chiclet popup menu.
+ */
+ virtual void onMenuItemClicked(const LLSD& user_data);
+
+ /**
+ * Finds a current speaker and resets the SpeakerControl with speaker's ID
+ */
+ /*virtual*/ void switchToCurrentSpeaker();
+
+private:
+
+ LLChicletAvatarIconCtrl* mChicletIconCtrl;
+};
+
+/**
+ * Chiclet for script floaters.
+ */
+class LLScriptChiclet : public LLIMChiclet
+{
+public:
+
+ struct Params : public LLInitParam::Block<Params, LLIMChiclet::Params>
+ {
+ Optional<LLButton::Params> chiclet_button;
+
+ Optional<LLIconCtrl::Params> icon;
+
+ Optional<LLIconCtrl::Params> new_message_icon;
+
+ Params();
+ };
+
+ /*virtual*/ void setSessionId(const LLUUID& session_id);
+
+ /*virtual*/ void setCounter(S32 counter);
+
+ /*virtual*/ S32 getCounter() { return 0; }
+
+ /**
+ * Toggle script floater
+ */
+ /*virtual*/ void onMouseDown();
+
+protected:
+
+ LLScriptChiclet(const Params&);
+ friend class LLUICtrlFactory;
+
+ /**
+ * Creates chiclet popup menu.
+ */
+ virtual void createPopupMenu();
+
+ /**
+ * Processes clicks on chiclet popup menu.
+ */
+ virtual void onMenuItemClicked(const LLSD& user_data);
+
+private:
+
+ LLIconCtrl* mChicletIconCtrl;
+};
+
+/**
+ * Chiclet for inventory offer script floaters.
+ */
+class LLInvOfferChiclet: public LLIMChiclet
+{
+public:
+
+ struct Params : public LLInitParam::Block<Params, LLIMChiclet::Params>
+ {
+ Optional<LLButton::Params> chiclet_button;
+
+ Optional<LLChicletInvOfferIconCtrl::Params> icon;
+
+ Optional<LLIconCtrl::Params> new_message_icon;
+
+ Params();
+ };
+
+ /*virtual*/ void setSessionId(const LLUUID& session_id);
+
+ /*virtual*/ void setCounter(S32 counter);
+
+ /*virtual*/ S32 getCounter() { return 0; }
+
+ /**
+ * Toggle script floater
+ */
+ /*virtual*/ void onMouseDown();
+
+protected:
+ LLInvOfferChiclet(const Params&);
+ friend class LLUICtrlFactory;
+
+ /**
+ * Creates chiclet popup menu.
+ */
+ virtual void createPopupMenu();
+
+ /**
+ * Processes clicks on chiclet popup menu.
+ */
+ virtual void onMenuItemClicked(const LLSD& user_data);
+
+private:
+ LLChicletInvOfferIconCtrl* mChicletIconCtrl;
};
-class LLNotificationChiclet : public LLChiclet
+/**
+ * Implements Group chat chiclet.
+ */
+class LLIMGroupChiclet : public LLIMChiclet, public LLGroupMgrObserver
+{
+public:
+
+ struct Params : public LLInitParam::Block<Params, LLIMChiclet::Params>
+ {
+ Optional<LLButton::Params> chiclet_button;
+
+ Optional<LLChicletGroupIconCtrl::Params> group_icon;
+
+ Optional<LLChicletNotificationCounterCtrl::Params> unread_notifications;
+
+ Optional<LLChicletSpeakerCtrl::Params> speaker;
+
+ Optional<LLIconCtrl::Params> new_message_icon;
+
+ Optional<bool> show_speaker;
+
+ Params();
+ };
+
+ /**
+ * Sets session id.
+ * Session ID for group chat is actually Group ID.
+ */
+ /*virtual*/ void setSessionId(const LLUUID& session_id);
+
+ /**
+ * Keep Speaker Control with actual speaker's ID
+ */
+ /*virtual*/ void draw();
+
+ /**
+ * Callback for LLGroupMgrObserver, we get this when group data is available or changed.
+ * Sets group icon.
+ */
+ /*virtual*/ void changed(LLGroupChange gc);
+
+ /**
+ * Init Speaker Control with speaker's ID
+ */
+ /*virtual*/ void initSpeakerControl();
+
+ /**
+ * Returns number of unread messages.
+ */
+ /*virtual*/ S32 getCounter() { return mCounterCtrl->getCounter(); }
+
+ ~LLIMGroupChiclet();
+
+protected:
+ LLIMGroupChiclet(const Params& p);
+ friend class LLUICtrlFactory;
+
+ /**
+ * Finds a current speaker and resets the SpeakerControl with speaker's ID
+ */
+ /*virtual*/ void switchToCurrentSpeaker();
+
+ /**
+ * Creates chiclet popup menu. Will create P2P or Group IM Chat menu
+ * based on other participant's id.
+ */
+ virtual void createPopupMenu();
+
+ /**
+ * Processes clicks on chiclet popup menu.
+ */
+ virtual void onMenuItemClicked(const LLSD& user_data);
+
+ /**
+ * Enables/disables "show session" menu item depending on visible IM floater existence.
+ */
+ virtual void updateMenuItems();
+
+private:
+
+ LLChicletGroupIconCtrl* mChicletIconCtrl;
+};
+
+/**
+ * Implements notification chiclet. Used to display total amount of unread messages
+ * across all IM sessions, total amount of system notifications. See EXT-3147 for details
+ */
+class LLSysWellChiclet : public LLChiclet
{
public:
struct Params : public LLInitParam::Block<Params, LLChiclet::Params>
{
- Optional<LLUIImage*>
- image_unselected,
- image_selected,
- image_hover_selected,
- image_hover_unselected,
- image_disabled_selected,
- image_disabled,
- image_overlay;
-
- Optional<S32>
- label_left;
+ Optional<LLButton::Params> button;
+
+ Optional<LLChicletNotificationCounterCtrl::Params> unread_notifications;
+
+ /**
+ * Contains maximum displayed count of unread messages. Default value is 9.
+ *
+ * If count is less than "max_unread_count" will be displayed as is.
+ * Otherwise 9+ will be shown (for default value).
+ */
+ Optional<S32> max_displayed_count;
Params();
};
- static LLChiclet* create(const Params& p);
+ /*virtual*/ void setCounter(S32 counter);
+
+ // *TODO: mantipov: seems getCounter is not necessary for LLNotificationChiclet
+ // but inherited interface requires it to implement.
+ // Probably it can be safe removed.
+ /*virtual*/S32 getCounter() { return mCounter; }
- void setCounter(S32 counter);
+ boost::signals2::connection setClickCallback(const commit_callback_t& cb);
- S32 getCounter() {return mCounter;};
+ /*virtual*/ ~LLSysWellChiclet();
- boost::signals::connection setClickCallback(const commit_callback_t& cb);
+ void setToggleState(BOOL toggled);
- virtual ~ LLNotificationChiclet();
+ void setNewMessagesState(bool new_messages);
+ //this method should change a widget according to state of the SysWellWindow
+ virtual void updateWidget(bool is_window_empty);
protected:
- LLNotificationChiclet(const Params& p);
+
+ LLSysWellChiclet(const Params& p);
friend class LLUICtrlFactory;
+ /**
+ * Change Well 'Lit' state from 'Lit' to 'Unlit' and vice-versa.
+ *
+ * There is an assumption that it will be called 2*N times to do not change its start state.
+ * @see FlashToLitTimer
+ */
+ void changeLitState();
+
+ /**
+ * Displays menu.
+ */
+ virtual BOOL handleRightMouseDown(S32 x, S32 y, MASK mask);
+
+ virtual void createMenu() = 0;
+
protected:
+ class FlashToLitTimer;
LLButton* mButton;
- LLTextBox* mCounterText;
+ S32 mCounter;
+ S32 mMaxDisplayedCount;
+ bool mIsNewMessagesState;
+
+ FlashToLitTimer* mFlashToLitTimer;
+ LLContextMenu* mContextMenu;
+};
+
+/**
+ * Class represented a chiclet for IM Well Icon.
+ *
+ * It displays a count of unread messages from other participants in all IM sessions.
+ */
+class LLIMWellChiclet : public LLSysWellChiclet, LLIMSessionObserver
+{
+ friend class LLUICtrlFactory;
+public:
+ virtual void sessionAdded(const LLUUID& session_id, const std::string& name, const LLUUID& other_participant_id) {}
+ virtual void sessionRemoved(const LLUUID& session_id) { messageCountChanged(LLSD()); }
+ virtual void sessionIDUpdated(const LLUUID& old_session_id, const LLUUID& new_session_id) {}
+
+ ~LLIMWellChiclet();
+protected:
+ LLIMWellChiclet(const Params& p);
+
+ /**
+ * Processes clicks on chiclet popup menu.
+ */
+ virtual void onMenuItemClicked(const LLSD& user_data);
+
+ /**
+ * Enables chiclet menu items.
+ */
+ bool enableMenuItem(const LLSD& user_data);
+
+ /**
+ * Creates menu.
+ */
+ /*virtual*/ void createMenu();
+
+ /**
+ * Handles changes in a session (message was added, messages were read, etc.)
+ *
+ * It get total count of unread messages from a LLIMMgr in all opened sessions and display it.
+ *
+ * @param[in] session_data contains session related data, is not used now
+ * ["session_id"] - id of an appropriate session
+ * ["participant_unread"] - count of unread messages from "real" participants.
+ *
+ * @see LLIMMgr::getNumberOfUnreadParticipantMessages()
+ */
+ void messageCountChanged(const LLSD& session_data);
};
+class LLNotificationChiclet : public LLSysWellChiclet
+{
+ friend class LLUICtrlFactory;
+public:
+ struct Params : public LLInitParam::Block<Params, LLSysWellChiclet::Params>{};
+
+protected:
+ LLNotificationChiclet(const Params& p);
+
+ /**
+ * Processes clicks on chiclet menu.
+ */
+ void onMenuItemClicked(const LLSD& user_data);
+
+ /**
+ * Enables chiclet menu items.
+ */
+ bool enableMenuItem(const LLSD& user_data);
+
+ /**
+ * Creates menu.
+ */
+ /*virtual*/ void createMenu();
+
+ // connect counter updaters to the corresponding signals
+ void connectCounterUpdatersToSignal(const std::string& notification_type);
+
+ // methods for updating a number of unread System notifications
+ void incUreadSystemNotifications() { setCounter(++mUreadSystemNotifications); }
+ void decUreadSystemNotifications() { setCounter(--mUreadSystemNotifications); }
+ /*virtual*/ void setCounter(S32 counter);
+ S32 mUreadSystemNotifications;
+};
+
+/**
+ * Storage class for all IM chiclets. Provides mechanism to display,
+ * scroll, create, remove chiclets.
+ */
class LLChicletPanel : public LLPanel
{
public:
struct Params : public LLInitParam::Block<Params, LLPanel::Params>
{
- Params(){};
- };
+ Optional<S32> chiclet_padding,
+ scrolling_offset,
+ scroll_button_hpad,
+ scroll_ratio;
- static LLChicletPanel* create();
+ Optional<S32> min_width;
- LLChiclet* createChiclet(LLSD* imSessionId = NULL, S32 pos = 0);
+ Params();
+ };
- bool addChiclet(LLChiclet*, S32 pos);
+ virtual ~LLChicletPanel();
- LLChiclet* getChiclet(S32 pos);
+ /**
+ * Creates chiclet and adds it to chiclet list at specified index.
+ */
+ template<class T> T* createChiclet(const LLUUID& session_id, S32 index);
- LLChiclet* findIMChiclet(LLSD* imSessionId);
+ /**
+ * Creates chiclet and adds it to chiclet list at right.
+ */
+ template<class T> T* createChiclet(const LLUUID& session_id);
- S32 getChicletCount() {return mChicletList.size();};
+ /**
+ * Returns pointer to chiclet of specified type at specified index.
+ */
+ template<class T> T* getChiclet(S32 index);
- void removeChiclet(S32 pos);
+ /**
+ * Returns pointer to LLChiclet at specified index.
+ */
+ LLChiclet* getChiclet(S32 index) { return getChiclet<LLChiclet>(index); }
- void removeChiclet(LLChiclet*);
+ /**
+ * Searches a chiclet using IM session id.
+ */
+ template<class T> T* findChiclet(const LLUUID& im_session_id);
- void removeIMChiclet(LLSD* imSessionId);
+ /**
+ * Returns number of hosted chiclets.
+ */
+ S32 getChicletCount() {return mChicletList.size();};
+ /**
+ * Returns index of chiclet in list.
+ */
+ S32 getChicletIndex(const LLChiclet* chiclet);
+
+ /**
+ * Removes chiclet by index.
+ */
+ void removeChiclet(S32 index);
+
+ /**
+ * Removes chiclet by pointer.
+ */
+ void removeChiclet(LLChiclet* chiclet);
+
+ /**
+ * Removes chiclet by IM session id.
+ */
+ void removeChiclet(const LLUUID& im_session_id);
+
+ /**
+ * Removes all chiclets.
+ */
void removeAll();
- void arrange();
+ /**
+ * Scrolls the panel to the specified chiclet
+ */
+ void scrollToChiclet(const LLChiclet* chiclet);
- ~LLChicletPanel();
-
- void scrollLeft();
-
- void scrollRight();
+ boost::signals2::connection setChicletClickedCallback(
+ const commit_callback_t& cb);
- void onLeftScrollClick();
+ /*virtual*/ BOOL postBuild();
- void onRightScrollClick();
+ /**
+ * Handler for the Voice Client's signal. Finds a corresponding chiclet and toggles its SpeakerControl
+ */
+ void onCurrentVoiceChannelChanged(const LLUUID& session_id);
- boost::signals::connection setChicletClickCallback(
- const commit_callback_t& cb);
+ /**
+ * Reshapes controls and rearranges chiclets if needed.
+ */
+ /*virtual*/ void reshape(S32 width, S32 height, BOOL called_from_parent = TRUE );
- void onChicletClick(LLUICtrl*ctrl,const LLSD&param);
+ /*virtual*/ void draw();
- //overrides
-public:
+ S32 getMinWidth() const { return mMinWidth; }
- void reshape(S32 width, S32 height, BOOL called_from_parent = TRUE );
+ S32 getTotalUnreadIMCount();
- void draw();
+ S32 notifyParent(const LLSD& info);
- BOOL postBuild();
+ /**
+ * Toggle chiclet by session id ON and toggle OFF all other chiclets.
+ */
+ void setChicletToggleState(const LLUUID& session_id, bool toggle);
protected:
LLChicletPanel(const Params&p);
friend class LLUICtrlFactory;
- bool needsScrolling();
+ /**
+ * Adds chiclet to list and rearranges all chiclets.
+ * They should be right aligned, most recent right. See EXT-1293
+ *
+ * It calculates position of the first chiclet in the list. Other chiclets are placed in arrange().
+ *
+ * @see arrange()
+ */
+ bool addChiclet(LLChiclet*, S32 index);
+
+ /**
+ * Arranges chiclets to have them in correct positions.
+ *
+ * Method bases on assumption that first chiclet has correct rect and starts from the its position.
+ *
+ * @see addChiclet()
+ */
+ void arrange();
+ /**
+ * Returns true if chiclets can be scrolled right.
+ */
bool canScrollRight();
+ /**
+ * Returns true if we need to show scroll buttons
+ */
+ bool needShowScroll();
+
+ /**
+ * Returns true if chiclets can be scrolled left.
+ */
bool canScrollLeft();
- enum ScrollDirection
- {
- SCROLL_LEFT = 1,
- SCROLL_RIGHT = -1
- };
+ /**
+ * Shows or hides chiclet scroll buttons if chiclets can or can not be scrolled.
+ */
+ void showScrollButtonsIfNeeded();
+
+ /**
+ * Shifts chiclets left or right.
+ */
+ void shiftChiclets(S32 offset, S32 start_index = 0);
+
+ /**
+ * Removes gaps between first chiclet and scroll area left side,
+ * last chiclet and scroll area right side.
+ */
+ void trimChiclets();
+
+ /**
+ * Scrolls chiclets to right or left.
+ */
+ void scroll(S32 offset);
+
+ /**
+ * Verifies that chiclets can be scrolled left, then calls scroll()
+ */
+ void scrollLeft();
+
+ /**
+ * Verifies that chiclets can be scrolled right, then calls scroll()
+ */
+ void scrollRight();
+
+ /**
+ * Callback for left scroll button clicked
+ */
+ void onLeftScrollClick();
+
+ /**
+ * Callback for right scroll button clicked
+ */
+ void onRightScrollClick();
+
+ /**
+ * Callback for right scroll button held down event
+ */
+ void onLeftScrollHeldDown();
- void scroll(ScrollDirection direction);
+ /**
+ * Callback for left scroll button held down event
+ */
+ void onRightScrollHeldDown();
+
+ /**
+ * Callback for mouse wheel scrolled, calls scrollRight() or scrollLeft()
+ */
+ BOOL handleScrollWheel(S32 x, S32 y, S32 clicks);
+
+ /**
+ * Notifies subscribers about click on chiclet.
+ * Do not place any code here, instead subscribe on event (see setChicletClickedCallback).
+ */
+ void onChicletClick(LLUICtrl*ctrl,const LLSD&param);
+
+ /**
+ * Callback for chiclet size changed event, rearranges chiclets.
+ */
+ void onChicletSizeChanged(LLChiclet* ctrl, const LLSD& param);
typedef std::vector<LLChiclet*> chiclet_list_t;
+ /**
+ * Removes chiclet from scroll area and chiclet list.
+ */
void removeChiclet(chiclet_list_t::iterator it);
- BOOL handleScrollWheel(S32 x, S32 y, S32 clicks);
+ S32 getChicletPadding() { return mChicletPadding; }
+
+ S32 getScrollingOffset() { return mScrollingOffset; }
+
+ bool isAnyIMFloaterDoked();
protected:
chiclet_list_t mChicletList;
- LLButton* mLeftScroll;
- LLButton* mRightScroll;
- S32 mFirstToShow;
- S32 mLastToShow;
+ LLButton* mLeftScrollButton;
+ LLButton* mRightScrollButton;
LLPanel* mScrollArea;
-};
+ S32 mChicletPadding;
+ S32 mScrollingOffset;
+ S32 mScrollButtonHPad;
+ S32 mScrollRatio;
+ S32 mMinWidth;
+ bool mShowControls;
+ static const S32 s_scroll_ratio;
+};
-class LLTalkButton : public LLUICtrl
+template<class T>
+T* LLChicletPanel::createChiclet(const LLUUID& session_id, S32 index)
{
-public:
+ typename T::Params params;
+ T* chiclet = LLUICtrlFactory::create<T>(params);
+ if(!chiclet)
+ {
+ llwarns << "Could not create chiclet" << llendl;
+ return NULL;
+ }
+ if(!addChiclet(chiclet, index))
+ {
+ delete chiclet;
+ llwarns << "Could not add chiclet to chiclet panel" << llendl;
+ return NULL;
+ }
- virtual ~LLTalkButton();
+ if (!isAnyIMFloaterDoked())
+ {
+ scrollToChiclet(chiclet);
+ }
- void onClick_SpeakBtn();
- void onClick_ShowBtn();
+ chiclet->setSessionId(session_id);
- void draw();
+ return chiclet;
+}
-protected:
- friend class LLUICtrlFactory;
- LLTalkButton(const LLUICtrl::Params& p);
+template<class T>
+T* LLChicletPanel::createChiclet(const LLUUID& session_id)
+{
+ return createChiclet<T>(session_id, mChicletList.size());
+}
-private:
- LLButton* mSpeakBtn;
- LLButton* mShowBtn;
- LLVoiceControlPanel* mPrivateCallPanel;
- LLOutputMonitorCtrl* mOutputMonitor;
-};
+template<class T>
+T* LLChicletPanel::findChiclet(const LLUUID& im_session_id)
+{
+ if(im_session_id.isNull())
+ {
+ return NULL;
+ }
+
+ chiclet_list_t::const_iterator it = mChicletList.begin();
+ for( ; mChicletList.end() != it; ++it)
+ {
+ LLChiclet* chiclet = *it;
+
+ llassert(chiclet);
+ if (!chiclet) continue;
+ if(chiclet->getSessionId() == im_session_id)
+ {
+ T* result = dynamic_cast<T*>(chiclet);
+ if(!result)
+ {
+ llwarns << "Found chiclet but of wrong type " << llendl;
+ continue;
+ }
+ return result;
+ }
+ }
+ return NULL;
+}
+
+template<class T> T* LLChicletPanel::getChiclet(S32 index)
+{
+ if(index < 0 || index >= getChicletCount())
+ {
+ return NULL;
+ }
+
+ LLChiclet* chiclet = mChicletList[index];
+ T*result = dynamic_cast<T*>(chiclet);
+ if(!result && chiclet)
+ {
+ llwarns << "Found chiclet but of wrong type " << llendl;
+ }
+ return result;
+}
#endif // LL_LLCHICLET_H
generated by cgit v1.2.3 (git 2.25.1) at 2024-12-25 23:58:50 +0000