livie
/
phoenix-firestorm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Automated merge with ssh://hg.lindenlab.com/richard/viewer-chui

meow-7.2.2
Richard Linden 2012-05-21 17:16:34 -07:00
parent 32717690ee 61bc25211b
commit 723f596bf6
9 changed files with 171 additions and 238 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

138
indra/llui/llnotifications.cpp
View File

@ -105,39 +105,7 @@ LLNotificationForm::Params::Params()
form_elements("")
{}
// Local channel for persistent notifications
// Stores only persistent notifications.
// Class users can use connectChanged() to process persistent notifications
// (see LLNotificationStorage for example).
class LLPersistentNotificationChannel : public LLNotificationChannel
{
LOG_CLASS(LLPersistentNotificationChannel);
public:
LLPersistentNotificationChannel() :
LLNotificationChannel("Persistent", "Visible", &notificationFilter, LLNotificationComparators::orderByUUID())
{
}
private:
// The channel gets all persistent notifications except those that have been canceled
static bool notificationFilter(LLNotificationPtr pNotification)
{
bool handle_notification = false;
handle_notification = pNotification->isPersistent()
&& !pNotification->isCancelled();
return handle_notification;
}
void onDelete(LLNotificationPtr pNotification)
{
// we want to keep deleted notifications in our log, otherwise some
// notifications will be lost on exit.
mItems.insert(pNotification);
}
};
bool filterIgnoredNotifications(LLNotificationPtr notification)
{
@ -502,18 +470,18 @@ LLNotificationVisibilityRule::LLNotificationVisibilityRule(const LLNotificationV
}
}
LLNotification::LLNotification(const LLNotification::Params& p) :
LLNotification::LLNotification(const LLSDParamAdapter<Params>& p) :
mTimestamp(p.time_stamp),
mSubstitutions(p.substitutions),
mPayload(p.payload),
mExpiresAt(0),
mExpiresAt(p.expiry),
mTemporaryResponder(false),
mRespondedTo(false),
mPriority(p.priority),
mCancelled(false),
mIgnored(false),
mResponderObj(NULL),
mIsReusable(false)
mId(p.id.isProvided() ? p.id : LLUUID::generateNewID())
{
if (p.functor.name.isChosen())
{
@ -536,52 +504,32 @@ LLNotification::LLNotification(const LLNotification::Params& p) :
mResponderObj = p.responder;
}
mId.generate();
init(p.name, p.form_elements);
}
LLNotification::LLNotification(const LLSD& sd) :
mTemporaryResponder(false),
mRespondedTo(false),
mCancelled(false),
mIgnored(false),
mResponderObj(NULL),
mIsReusable(false)
{
mId.generate();
mSubstitutions = sd["substitutions"];
mPayload = sd["payload"];
mTimestamp = sd["time"];
mExpiresAt = sd["expiry"];
mPriority = (ENotificationPriority)sd["priority"].asInteger();
mResponseFunctorName = sd["responseFunctor"].asString();
std::string templatename = sd["name"].asString();
init(templatename, LLSD());
// replace form with serialized version
mForm = LLNotificationFormPtr(new LLNotificationForm(sd["form"]));
}
LLSD LLNotification::asLLSD()
{
LLSD output;
output["id"] = mId;
output["name"] = mTemplatep->mName;
output["form"] = getForm()->asLLSD();
output["substitutions"] = mSubstitutions;
output["payload"] = mPayload;
output["time"] = mTimestamp;
output["expiry"] = mExpiresAt;
output["priority"] = (S32)mPriority;
output["responseFunctor"] = mResponseFunctorName;
output["reusable"] = mIsReusable;
LLParamSDParser parser;
if(mResponder)
Params p;
p.id = mId;
p.name = mTemplatep->mName;
p.form_elements = getForm()->asLLSD();
p.substitutions = mSubstitutions;
p.payload = mPayload;
p.time_stamp = mTimestamp;
p.expiry = mExpiresAt;
p.priority = mPriority;
if(!mResponseFunctorName.empty())
{
output["responder"] = mResponder->asLLSD();
p.functor.name = mResponseFunctorName;
}
LLSD output;
parser.writeSD(output, p);
return output;
}
@ -1056,8 +1004,8 @@ bool LLNotificationChannelBase::updateItem(const LLSD& payload, LLNotificationPt
{
// not in our list, add it and say so
mItems.insert(pNotification);
abortProcessing = mChanged(payload);
onLoad(pNotification);
abortProcessing = mChanged(payload);
}
}
else if (cmd == "change")
@ -1072,18 +1020,18 @@ bool LLNotificationChannelBase::updateItem(const LLSD& payload, LLNotificationPt
{
// it already existed, so this is a change
// since it changed in place, all we have to do is resend the signal
abortProcessing = mChanged(payload);
onChange(pNotification);
abortProcessing = mChanged(payload);
}
else
{
// not in our list, add it and say so
mItems.insert(pNotification);
onChange(pNotification);
// our payload is const, so make a copy before changing it
LLSD newpayload = payload;
newpayload["sigtype"] = "add";
abortProcessing = mChanged(newpayload);
onChange(pNotification);
}
}
else
@ -1092,11 +1040,11 @@ bool LLNotificationChannelBase::updateItem(const LLSD& payload, LLNotificationPt
{
// it already existed, so this is a delete
mItems.erase(pNotification);
onChange(pNotification);
// our payload is const, so make a copy before changing it
LLSD newpayload = payload;
newpayload["sigtype"] = "delete";
abortProcessing = mChanged(newpayload);
onChange(pNotification);
}
// didn't pass, not on our list, do nothing
}
@ -1110,8 +1058,8 @@ bool LLNotificationChannelBase::updateItem(const LLSD& payload, LLNotificationPt
{
// not in our list, add it and say so
mItems.insert(pNotification);
abortProcessing = mChanged(payload);
onAdd(pNotification);
abortProcessing = mChanged(payload);
}
}
else if (cmd == "delete")
@ -1119,16 +1067,16 @@ bool LLNotificationChannelBase::updateItem(const LLSD& payload, LLNotificationPt
// if we have it in our list, pass on the delete, then delete it, else do nothing
if (wasFound)
{
abortProcessing = mChanged(payload);
mItems.erase(pNotification);
onDelete(pNotification);
abortProcessing = mChanged(payload);
}
}
return abortProcessing;
}
LLNotificationChannel::LLNotificationChannel(const Params& p)
: LLNotificationChannelBase(p.filter(), p.comparator()),
: LLNotificationChannelBase(p.filter()),
LLInstanceTracker<LLNotificationChannel, std::string>(p.name.isProvided() ? p.name : LLUUID::generateNewID().asString()),
mName(p.name.isProvided() ? p.name : LLUUID::generateNewID().asString())
{
@ -1141,9 +1089,8 @@ LLNotificationChannel::LLNotificationChannel(const Params& p)
LLNotificationChannel::LLNotificationChannel(const std::string& name,
const std::string& parent,
LLNotificationFilter filter,
LLNotificationComparator comparator)
: LLNotificationChannelBase(filter, comparator),
LLNotificationFilter filter)
: LLNotificationChannelBase(filter),
LLInstanceTracker<LLNotificationChannel, std::string>(name),
mName(name)
{
@ -1151,18 +1098,6 @@ LLNotificationChannel::LLNotificationChannel(const std::string& name,
connectToChannel(parent);
}
void LLNotificationChannel::setComparator(LLNotificationComparator comparator)
{
mComparator = comparator;
LLNotificationSet s2(mComparator);
s2.insert(mItems.begin(), mItems.end());
mItems.swap(s2);
// notify clients that we've been resorted
mChanged(LLSD().with("sigtype", "sort"));
}
bool LLNotificationChannel::isEmpty() const
{
return mItems.empty();
@ -1178,6 +1113,11 @@ LLNotificationChannel::Iterator LLNotificationChannel::end()
return mItems.end();
}
size_t LLNotificationChannel::size()
{
return mItems.size();
}
std::string LLNotificationChannel::summarize()
{
std::string s("Channel '");
@ -1205,19 +1145,17 @@ void LLNotificationChannel::connectToChannel( const std::string& channel_name )
}
}
// ---
// END OF LLNotificationChannel implementation
// =========================================================
// =========================================================
// ============================================== ===========
// LLNotifications implementation
// ---
LLNotifications::LLNotifications() : LLNotificationChannelBase(LLNotificationFilters::includeEverything,
LLNotificationComparators::orderByUUID()),
mIgnoreAllNotifications(false)
LLNotifications::LLNotifications()
: LLNotificationChannelBase(LLNotificationFilters::includeEverything),
mIgnoreAllNotifications(false)
{
LLUICtrl::CommitCallbackRegistry::currentRegistrar().add("Notification.Show", boost::bind(&LLNotifications::addFromCallback, this, _2));
@ -1705,7 +1643,7 @@ void LLNotifications::update(const LLNotificationPtr pNotif)
LLNotificationPtr LLNotifications::find(LLUUID uuid)
{
LLNotificationPtr target = LLNotificationPtr(new LLNotification(uuid));
LLNotificationPtr target = LLNotificationPtr(new LLNotification(LLNotification::Params().id(uuid)));
LLNotificationSet::iterator it=mItems.find(target);
if (it == mItems.end())
{

148
indra/llui/llnotifications.h
View File

@ -88,10 +88,6 @@
#include <boost/enable_shared_from_this.hpp>
#include <boost/type_traits.hpp>
// we want to minimize external dependencies, but this one is important
#include "llsd.h"
// and we need this to manage the notification callbacks
#include "llevents.h"
#include "llfunctorregistry.h"
#include "llinitparam.h"
@ -99,6 +95,7 @@
#include "llnotificationptr.h"
#include "llpointer.h"
#include "llrefcount.h"
#include "llsdparam.h"
class LLAvatarName;
typedef enum e_notification_priority
@ -309,13 +306,13 @@ public:
friend class LLNotification;
Mandatory<std::string> name;
// optional
Optional<LLSD> substitutions;
Optional<LLSD> payload;
Optional<LLUUID> id;
Optional<LLSD> substitutions,
form_elements,
payload;
Optional<ENotificationPriority, NotificationPriorityValues> priority;
Optional<LLSD> form_elements;
Optional<LLDate> time_stamp;
Optional<LLDate> time_stamp,
expiry;
Optional<LLNotificationContext*> context;
Optional<void*> responder;
@ -326,7 +323,7 @@ public:
Alternative<LLNotificationResponderPtr> responder;
Functor()
: name("functor_name"),
: name("responseFunctor"),
function("functor"),
responder("responder")
{}
@ -335,10 +332,13 @@ public:
Params()
: name("name"),
id("id"),
priority("priority", NOTIFICATION_PRIORITY_UNSPECIFIED),
time_stamp("time_stamp"),
time_stamp("time"),
payload("payload"),
form_elements("form_elements")
form_elements("form"),
substitutions("substitutions"),
expiry("expiry")
{
time_stamp = LLDate::now();
responder = NULL;
@ -347,9 +347,11 @@ public:
Params(const std::string& _name)
: name("name"),
priority("priority", NOTIFICATION_PRIORITY_UNSPECIFIED),
time_stamp("time_stamp"),
time_stamp("time"),
payload("payload"),
form_elements("form_elements")
form_elements("form"),
substitutions("substitutions"),
expiry("expiry")
{
functor.name = _name;
name = _name;
@ -362,7 +364,7 @@ public:
private:
LLUUID mId;
const LLUUID mId;
LLSD mPayload;
LLSD mSubstitutions;
LLDate mTimestamp;
@ -374,7 +376,6 @@ private:
ENotificationPriority mPriority;
LLNotificationFormPtr mForm;
void* mResponderObj; // TODO - refactor/remove this field
bool mIsReusable;
LLNotificationResponderPtr mResponder;
// a reference to the template
@ -399,18 +400,10 @@ private:
void init(const std::string& template_name, const LLSD& form_elements);
LLNotification(const Params& p);
// this is just for making it easy to look things up in a set organized by UUID -- DON'T USE IT
// for anything real!
LLNotification(LLUUID uuid) : mId(uuid), mCancelled(false), mRespondedTo(false), mIgnored(false), mPriority(NOTIFICATION_PRIORITY_UNSPECIFIED), mTemporaryResponder(false) {}
void cancel();
public:
// constructor from a saved notification
LLNotification(const LLSD& sd);
LLNotification(const LLSDParamAdapter<Params>& p);
void setResponseFunctor(std::string const &responseFunctorName);
@ -555,8 +548,6 @@ public:
return mId;
}
bool isReusable() { return mIsReusable; }
// comparing two notifications normally means comparing them by UUID (so we can look them
// up quickly this way)
bool operator<(const LLNotification& rhs) const
@ -668,44 +659,18 @@ namespace LLNotificationFilters
namespace LLNotificationComparators
{
typedef enum e_direction { ORDER_DECREASING, ORDER_INCREASING } EDirection;
// generic order functor that takes method or member variable reference
template<typename T>
struct orderBy
struct orderByUUID
{
typedef boost::function<T (LLNotificationPtr)> field_t;
orderBy(field_t field, EDirection direction = ORDER_INCREASING) : mField(field), mDirection(direction) {}
bool operator()(LLNotificationPtr lhs, LLNotificationPtr rhs)
{
if (mDirection == ORDER_DECREASING)
{
return mField(lhs) > mField(rhs);
}
else
{
return mField(lhs) < mField(rhs);
}
return lhs->id() < rhs->id();
}
field_t mField;
EDirection mDirection;
};
struct orderByUUID : public orderBy<const LLUUID&>
{
orderByUUID(EDirection direction = ORDER_INCREASING) : orderBy<const LLUUID&>(&LLNotification::id, direction) {}
};
struct orderByDate : public orderBy<const LLDate&>
{
orderByDate(EDirection direction = ORDER_INCREASING) : orderBy<const LLDate&>(&LLNotification::getDate, direction) {}
};
};
typedef boost::function<bool (LLNotificationPtr)> LLNotificationFilter;
typedef boost::function<bool (LLNotificationPtr, LLNotificationPtr)> LLNotificationComparator;
typedef std::set<LLNotificationPtr, LLNotificationComparator> LLNotificationSet;
typedef std::set<LLNotificationPtr, LLNotificationComparators::orderByUUID> LLNotificationSet;
typedef std::multimap<std::string, LLNotificationPtr> LLNotificationMap;
// ========================================================
@ -731,8 +696,9 @@ class LLNotificationChannelBase :
{
LOG_CLASS(LLNotificationChannelBase);
public:
LLNotificationChannelBase(LLNotificationFilter filter, LLNotificationComparator comp) :
mFilter(filter), mItems(comp)
LLNotificationChannelBase(LLNotificationFilter filter)
: mFilter(filter),
mItems()
{}
virtual ~LLNotificationChannelBase() {}
// you can also connect to a Channel, so you can be notified of
@ -829,18 +795,11 @@ public:
{
Mandatory<std::string> name;
Optional<LLNotificationFilter> filter;
Optional<LLNotificationComparator> comparator;
Multiple<std::string> sources;
Params()
: comparator("", LLNotificationComparators::orderByUUID())
{}
};
LLNotificationChannel(const Params& p = Params());
LLNotificationChannel(const std::string& name, const std::string& parent,
LLNotificationFilter filter, LLNotificationComparator comparator=LLNotificationComparators::orderByUUID());
LLNotificationChannel(const std::string& name, const std::string& parent, LLNotificationFilter filter);
virtual ~LLNotificationChannel() {}
typedef LLNotificationSet::iterator Iterator;
@ -853,11 +812,8 @@ public:
Iterator begin();
Iterator end();
size_t size();
// Channels have a comparator to control sort order;
// the default sorts by arrival date
void setComparator(LLNotificationComparator comparator);
std::string summarize();
private:
@ -1047,5 +1003,55 @@ protected:
std::string mName;
};
// Stores only persistent notifications.
// Class users can use connectChanged() to process persistent notifications
// (see LLNotificationStorage for example).
class LLPersistentNotificationChannel : public LLNotificationChannel
{
LOG_CLASS(LLPersistentNotificationChannel);
public:
LLPersistentNotificationChannel()
: LLNotificationChannel("Persistent", "Visible", &notificationFilter)
{
}
typedef std::vector<LLNotificationPtr> history_list_t;
history_list_t::iterator beginHistory() { sortHistory(); return mHistory.begin(); }
history_list_t::iterator endHistory() { return mHistory.end(); }
private:
void sortHistory()
{
struct sortByTime
{
S32 operator ()(const LLNotificationPtr& a, const LLNotificationPtr& b)
{
return a->getDate() < b->getDate();
}
};
std::sort(mHistory.begin(), mHistory.end(), sortByTime());
}
// The channel gets all persistent notifications except those that have been canceled
static bool notificationFilter(LLNotificationPtr pNotification)
{
bool handle_notification = false;
handle_notification = pNotification->isPersistent()
&& !pNotification->isCancelled();
return handle_notification;
}
void onAdd(LLNotificationPtr p)
{
mHistory.push_back(p);
}
std::vector<LLNotificationPtr> mHistory;
};
#endif//LL_LLNOTIFICATIONS_H

8
indra/llui/llsdparam.cpp
View File

@ -283,7 +283,10 @@ void LLParamSDParserUtilities::readSDValues(read_sd_cb_t cb, const LLSD& sd, LLI
it != sd.endArray();
++it)
{
stack.back().second = true;
if (!stack.empty())
{
stack.back().second = true;
}
readSDValues(cb, *it, stack);
}
}
@ -336,7 +339,6 @@ namespace LLInitParam
void ParamValue<LLSD, NOT_BLOCK>::serializeBlock(Parser& p, Parser::name_stack_t& name_stack, const BaseBlock* diff_block) const
{
// read from LLSD value and serialize out to parser (which could be LLSD, XUI, etc)
Parser::name_stack_t stack;
LLParamSDParserUtilities::readSDValues(boost::bind(&serializeElement, boost::ref(p), _1, _2), mValue, stack);
LLParamSDParserUtilities::readSDValues(boost::bind(&serializeElement, boost::ref(p), _1, _2), mValue, name_stack);
}
}

4
indra/llxuixml/llinitparam.h
View File

@ -1024,7 +1024,9 @@ namespace LLInitParam
if (!parser.writeValue(typed_param.getValue(), name_stack))
{
std::string calculated_key = typed_param.calcValueName(typed_param.getValue());
if (!diff_param || !ParamCompare<std::string>::equals(static_cast<const self_t*>(diff_param)->getValueName(), calculated_key))
if (calculated_key.size()
&& (!diff_param
|| !ParamCompare<std::string>::equals(static_cast<const self_t*>(diff_param)->getValueName(), calculated_key)))
{
parser.writeValue(calculated_key, name_stack);
}

50
indra/newview/llnotificationalerthandler.cpp
View File

@ -82,39 +82,39 @@ bool LLAlertHandler::processNotification(const LLNotificationPtr& notification)
}
if (notification->canLogToIM() && notification->hasFormElements())
{
const std::string name = LLHandlerUtil::getSubstitutionName(notification);
{
const std::string name = LLHandlerUtil::getSubstitutionName(notification);
LLUUID from_id = notification->getPayload()["from_id"];
LLUUID from_id = notification->getPayload()["from_id"];
// firstly create session...
LLHandlerUtil::spawnIMSession(name, from_id);
// firstly create session...
LLHandlerUtil::spawnIMSession(name, from_id);
// ...then log message to have IM Well notified about new message
LLHandlerUtil::logToIMP2P(notification);
}
// ...then log message to have IM Well notified about new message
LLHandlerUtil::logToIMP2P(notification);
}
LLToastAlertPanel* alert_dialog = new LLToastAlertPanel(notification, mIsModal);
LLToast::Params p;
p.notif_id = notification->getID();
p.notification = notification;
p.panel = dynamic_cast<LLToastPanel*>(alert_dialog);
p.enable_hide_btn = false;
p.can_fade = false;
p.is_modal = mIsModal;
p.on_delete_toast = boost::bind(&LLAlertHandler::onDeleteToast, this, _1);
LLToastAlertPanel* alert_dialog = new LLToastAlertPanel(notification, mIsModal);
LLToast::Params p;
p.notif_id = notification->getID();
p.notification = notification;
p.panel = dynamic_cast<LLToastPanel*>(alert_dialog);
p.enable_hide_btn = false;
p.can_fade = false;
p.is_modal = mIsModal;
p.on_delete_toast = boost::bind(&LLAlertHandler::onDeleteToast, this, _1);
// Show alert in middle of progress view (during teleport) (EXT-1093)
LLProgressView* progress = gViewerWindow->getProgressView();
LLRect rc = progress && progress->getVisible() ? progress->getRect() : gViewerWindow->getWorldViewRectScaled();
mChannel.get()->updatePositionAndSize(rc);
// Show alert in middle of progress view (during teleport) (EXT-1093)
LLProgressView* progress = gViewerWindow->getProgressView();
LLRect rc = progress && progress->getVisible() ? progress->getRect() : gViewerWindow->getWorldViewRectScaled();
mChannel.get()->updatePositionAndSize(rc);
LLScreenChannel* channel = dynamic_cast<LLScreenChannel*>(mChannel.get());
if(channel)
channel->addToast(p);
LLScreenChannel* channel = dynamic_cast<LLScreenChannel*>(mChannel.get());
if(channel)
channel->addToast(p);
return false;
}
}
void LLAlertHandler::onChange( LLNotificationPtr notification )
{

2
indra/newview/llnotificationhandler.h
View File

@ -258,7 +258,7 @@ public:
: LLNotificationChannel("Outbox", "Visible", LLNotificationFilters::filterBy<std::string>(&LLNotification::getType, "outbox"))
{}
/*virtual*/ void onAdd(LLNotificationPtr p) { processNotification(p); }
/*virtual*/ void onChange(LLNotificationPtr p) { processNotification(p); }
/*virtual*/ void onChange(LLNotificationPtr p) { }
/*virtual*/ void onDelete(LLNotificationPtr p);
bool processNotification(const LLNotificationPtr& p);
};

18
indra/newview/llnotificationstorage.cpp
View File

@ -84,9 +84,11 @@ bool LLPersistentNotificationStorage::onPersistentChannelChanged(const LLSD& pay
return false;
}
static LLFastTimer::DeclareTimer FTM_SAVE_NOTIFICATIONS("Save Notifications");
void LLPersistentNotificationStorage::saveNotifications()
{
// TODO - think about save optimization.
LLFastTimer _(FTM_SAVE_NOTIFICATIONS);
llofstream notify_file(mFileName.c_str());
if (!notify_file.is_open())
@ -98,10 +100,15 @@ void LLPersistentNotificationStorage::saveNotifications()
LLSD output;
LLSD& data = output["data"];
LLNotificationChannelPtr history_channel = LLNotifications::instance().getChannel("Persistent");
LLNotificationSet::iterator it = history_channel->begin();
boost::intrusive_ptr<LLPersistentNotificationChannel> history_channel = boost::dynamic_pointer_cast<LLPersistentNotificationChannel>(LLNotifications::instance().getChannel("Persistent"));
if (!history_channel)
{
return;
}
for ( ; history_channel->end() != it; ++it)
for ( std::vector<LLNotificationPtr>::iterator it = history_channel->beginHistory(), end_it = history_channel->endHistory();
it != end_it;
++it)
{
LLNotificationPtr notification = *it;
@ -120,8 +127,11 @@ void LLPersistentNotificationStorage::saveNotifications()
formatter->format(output, notify_file, LLSDFormatter::OPTIONS_PRETTY);
}
static LLFastTimer::DeclareTimer FTM_LOAD_NOTIFICATIONS("Load Notifications");
void LLPersistentNotificationStorage::loadNotifications()
{
LLFastTimer _(FTM_LOAD_NOTIFICATIONS);
LLResponderRegistry::registerResponders();
LLNotifications::instance().getChannel("Persistent")->

17
indra/newview/llscreenchannel.cpp
View File

@ -499,21 +499,20 @@ void LLScreenChannel::killToastByNotificationID(LLUUID id)
void LLScreenChannel::removeToastByNotificationID(LLUUID id)
{
std::vector<ToastElem>::iterator it = find(mToastList.begin(), mToastList.end(), id);
if( it != mToastList.end())
std::vector<ToastElem>::iterator it = mToastList.begin();
while( it != mToastList.end())
{
// find next toast with matching id
it = find(it, mToastList.end(), id);
deleteToast(it->getToast());
mToastList.erase(it);
redrawToasts();
}
else
it = find(mStoredToastList.begin(), mStoredToastList.end(), id);
if (it != mStoredToastList.end())
{
it = find(mStoredToastList.begin(), mStoredToastList.end(), id);
if (it != mStoredToastList.end())
{
deleteToast(it->getToast());
mStoredToastList.erase(it);
}
deleteToast(it->getToast());
mStoredToastList.erase(it);
}
}

24
indra/newview/lltoastnotifypanel.cpp
View File

@ -60,19 +60,6 @@ LLToastNotifyPanel::LLToastNotifyPanel(const LLNotificationPtr& notification, co
LLInstanceTracker<LLToastNotifyPanel, LLUUID>(notification->getID())
{
init(rect, show_images);
//if(notification->isRespondedTo())
//{
// // User selected an option in toast, now disable required buttons in IM window
// disableRespondedOptions(notification);
//}
//
//if(notification->isReusable())
//{
// mButtonClickConnection = sButtonClickSignal.connect(
// boost::bind(&LLToastNotifyPanel::disableRespondedOptions, this, notification));
//}
}
void LLToastNotifyPanel::addDefaultButton()
{
@ -355,17 +342,6 @@ void LLToastNotifyPanel::onClickButton(void* data)
response[button_name] = true;
}
bool is_reusable = self->mNotification->isReusable();
// When we call respond(), LLOfferInfo will delete itself in inventory_offer_callback(),
// lets copy it while it's still valid.
LLOfferInfo* old_info = static_cast<LLOfferInfo*>(self->mNotification->getResponder());
LLOfferInfo* new_info = NULL;
if(is_reusable && old_info)
{
new_info = new LLOfferInfo(*old_info);
self->mNotification->setResponder(new_info);
}
// disable all buttons
self->mControlPanel->setEnabled(FALSE);