llpanelavatar.cpp

Go to the documentation of this file.
00001 
00032 #include "llviewerprecompiledheaders.h"
00033 
00034 #include "llpanelavatar.h"
00035 
00036 #include "llclassifiedflags.h"
00037 #include "llfontgl.h"
00038 #include "llcachename.h"
00039 
00040 #include "llavatarconstants.h"
00041 #include "lluiconstants.h"
00042 #include "lltextbox.h"
00043 #include "llviewertexteditor.h"
00044 #include "lltexturectrl.h"
00045 #include "llagent.h"
00046 #include "llviewerwindow.h"
00047 #include "llbutton.h"
00048 #include "llcallingcard.h"
00049 #include "llcheckboxctrl.h"
00050 #include "llfloater.h"
00051 
00052 #include "llfloaterfriends.h"
00053 #include "llfloatergroupinfo.h"
00054 #include "llfloaterworldmap.h"
00055 #include "llfloatermute.h"
00056 #include "llfloateravatarinfo.h"
00057 #include "lliconctrl.h"
00058 #include "llinventoryview.h"
00059 #include "lllineeditor.h"
00060 #include "llnameeditor.h"
00061 #include "llmutelist.h"
00062 #include "llpanelclassified.h"
00063 #include "llpanelpick.h"
00064 #include "llscrolllistctrl.h"
00065 #include "llstatusbar.h"
00066 #include "lltabcontainer.h"
00067 #include "lltabcontainervertical.h"
00068 #include "llimview.h"
00069 #include "lltooldraganddrop.h"
00070 #include "lluiconstants.h"
00071 #include "llvoavatar.h"
00072 #include "llviewercontrol.h"
00073 #include "llviewermenu.h"               // *FIX: for is_agent_friend()
00074 #include "llviewergenericmessage.h"     // send_generic_message
00075 #include "llviewerobjectlist.h"
00076 #include "llviewerregion.h"
00077 #include "llweb.h"
00078 #include "llinventorymodel.h"
00079 #include "roles_constants.h"
00080 
00081 #define kArraySize( _kArray ) ( sizeof( (_kArray) ) / sizeof( _kArray[0] ) )
00082 
00083 #include "lluictrlfactory.h"
00084 
00085 // Statics
00086 std::list<LLPanelAvatar*> LLPanelAvatar::sAllPanels;
00087 BOOL LLPanelAvatar::sAllowFirstLife = FALSE;
00088 
00089 extern void handle_lure(const LLUUID& invitee);
00090 extern void handle_pay_by_id(const LLUUID& payee);
00091 
00092 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
00093 // Class LLDropTarget
00094 //
00095 // This handy class is a simple way to drop something on another
00096 // view. It handles drop events, always setting itself to the size of
00097 // its parent.
00098 //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
00099 
00100 class LLDropTarget : public LLView
00101 {
00102 public:
00103         LLDropTarget(const std::string& name, const LLRect& rect, const LLUUID& agent_id);
00104         ~LLDropTarget();
00105 
00106         void doDrop(EDragAndDropType cargo_type, void* cargo_data);
00107 
00108         //
00109         // LLView functionality
00110         virtual BOOL handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
00111                                                                    EDragAndDropType cargo_type,
00112                                                                    void* cargo_data,
00113                                                                    EAcceptance* accept,
00114                                                                    LLString& tooltip_msg);
00115         void setAgentID(const LLUUID &agent_id)         { mAgentID = agent_id; }
00116 protected:
00117         LLUUID mAgentID;
00118 };
00119 
00120 
00121 LLDropTarget::LLDropTarget(const std::string& name, const LLRect& rect,
00122                                                    const LLUUID& agent_id) :
00123         LLView(name, rect, NOT_MOUSE_OPAQUE, FOLLOWS_ALL),
00124         mAgentID(agent_id)
00125 {
00126 }
00127 
00128 LLDropTarget::~LLDropTarget()
00129 {
00130 }
00131 
00132 void LLDropTarget::doDrop(EDragAndDropType cargo_type, void* cargo_data)
00133 {
00134         llinfos << "LLDropTarget::doDrop()" << llendl;
00135 }
00136 
00137 BOOL LLDropTarget::handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
00138                                                                          EDragAndDropType cargo_type,
00139                                                                          void* cargo_data,
00140                                                                          EAcceptance* accept,
00141                                                                          LLString& tooltip_msg)
00142 {
00143         BOOL handled = FALSE;
00144         if(getParent())
00145         {
00146                 // check if inside
00147                 //LLRect parent_rect = mParentView->getRect();
00148                 //getRect().set(0, parent_rect.getHeight(), parent_rect.getWidth(), 0);
00149                 handled = TRUE;
00150 
00151                 // check the type
00152                 switch(cargo_type)
00153                 {
00154                 case DAD_TEXTURE:
00155                 case DAD_SOUND:
00156                 case DAD_LANDMARK:
00157                 case DAD_SCRIPT:
00158                 case DAD_OBJECT:
00159                 case DAD_NOTECARD:
00160                 case DAD_CLOTHING:
00161                 case DAD_BODYPART:
00162                 case DAD_ANIMATION:
00163                 case DAD_GESTURE:
00164                 {
00165                         LLViewerInventoryItem* inv_item = (LLViewerInventoryItem*)cargo_data;
00166                         if(gInventory.getItem(inv_item->getUUID())
00167                                 && LLToolDragAndDrop::isInventoryGiveAcceptable(inv_item))
00168                         {
00169                                 // *TODO: get multiple object transfers working
00170                                 *accept = ACCEPT_YES_COPY_SINGLE;
00171                                 if(drop)
00172                                 {
00173                                         LLToolDragAndDrop::giveInventory(mAgentID, inv_item);
00174                                 }
00175                         }
00176                         else
00177                         {
00178                                 // It's not in the user's inventory (it's probably
00179                                 // in an object's contents), so disallow dragging
00180                                 // it here.  You can't give something you don't
00181                                 // yet have.
00182                                 *accept = ACCEPT_NO;
00183                         }
00184                         break;
00185                 }
00186                 case DAD_CATEGORY:
00187                 {
00188                         LLViewerInventoryCategory* inv_cat = (LLViewerInventoryCategory*)cargo_data;
00189                         if( gInventory.getCategory( inv_cat->getUUID() ) )
00190                         {
00191                                 // *TODO: get multiple object transfers working
00192                                 *accept = ACCEPT_YES_COPY_SINGLE;
00193                                 if(drop)
00194                                 {
00195                                         LLToolDragAndDrop::giveInventoryCategory(mAgentID,
00196                                                                                                                                 inv_cat);
00197                                 }
00198                         }
00199                         else
00200                         {
00201                                 // It's not in the user's inventory (it's probably
00202                                 // in an object's contents), so disallow dragging
00203                                 // it here.  You can't give something you don't
00204                                 // yet have.
00205                                 *accept = ACCEPT_NO;
00206                         }
00207                         break;
00208                 }
00209                 case DAD_CALLINGCARD:
00210                 default:
00211                         *accept = ACCEPT_NO;
00212                         break;
00213                 }
00214         }
00215         return handled;
00216 }
00217 
00218 
00219 //-----------------------------------------------------------------------------
00220 // LLPanelAvatarTab()
00221 //-----------------------------------------------------------------------------
00222 LLPanelAvatarTab::LLPanelAvatarTab(const std::string& name, const LLRect &rect, 
00223                                                                    LLPanelAvatar* panel_avatar)
00224 :       LLPanel(name, rect),
00225         mPanelAvatar(panel_avatar),
00226         mDataRequested(false)
00227 { }
00228 
00229 // virtual
00230 void LLPanelAvatarTab::draw()
00231 {
00232         refresh();
00233 
00234         LLPanel::draw();
00235 }
00236 
00237 void LLPanelAvatarTab::sendAvatarProfileRequestIfNeeded(const char* method)
00238 {
00239         if (!mDataRequested)
00240         {
00241                 std::vector<std::string> strings;
00242                 strings.push_back( mPanelAvatar->getAvatarID().asString() );
00243                 send_generic_message(method, strings);
00244                 mDataRequested = true;
00245         }
00246 }
00247 
00248 //-----------------------------------------------------------------------------
00249 // LLPanelAvatarSecondLife()
00250 //-----------------------------------------------------------------------------
00251 LLPanelAvatarSecondLife::LLPanelAvatarSecondLife(const std::string& name, 
00252                                                                                                  const LLRect &rect, 
00253                                                                                                  LLPanelAvatar* panel_avatar ) 
00254 :       LLPanelAvatarTab(name, rect, panel_avatar),
00255         mPartnerID()
00256 {
00257 }
00258 
00259 void LLPanelAvatarSecondLife::refresh()
00260 {
00261         updatePartnerName();
00262 }
00263 
00264 void LLPanelAvatarSecondLife::updatePartnerName()
00265 {
00266         if (mPartnerID.notNull())
00267         {
00268                 std::string first, last;
00269                 BOOL found = gCacheName->getName(mPartnerID, first, last);
00270                 if (found)
00271                 {
00272                         childSetTextArg("partner_edit", "[FIRST]", first);
00273                         childSetTextArg("partner_edit", "[LAST]", last);
00274                 }
00275                 childSetEnabled("partner_info", TRUE);
00276         }
00277 }
00278 
00279 //-----------------------------------------------------------------------------
00280 // clearControls()
00281 // Empty the data out of the controls, since we have to wait for new
00282 // data off the network.
00283 //-----------------------------------------------------------------------------
00284 void LLPanelAvatarSecondLife::clearControls()
00285 {
00286         LLTextureCtrl*  image_ctrl = getChild<LLTextureCtrl>("img");
00287         if(image_ctrl)
00288         {
00289                 image_ctrl->setImageAssetID(LLUUID::null);
00290         }
00291         childSetValue("about", "");
00292         childSetValue("born", "");
00293         childSetValue("acct", "");
00294 
00295         childSetTextArg("partner_edit", "[FIRST]", LLString::null);
00296         childSetTextArg("partner_edit", "[LAST]", LLString::null);
00297 
00298         mPartnerID = LLUUID::null;
00299         
00300         LLScrollListCtrl*       group_list = getChild<LLScrollListCtrl>("groups"); 
00301         if(group_list)
00302         {
00303                 group_list->deleteAllItems();
00304         }
00305         LLScrollListCtrl*       ratings_list = getChild<LLScrollListCtrl>("ratings"); 
00306         if(ratings_list)
00307         {
00308                 ratings_list->deleteAllItems();
00309         }
00310 
00311 }
00312 
00313 
00314 //-----------------------------------------------------------------------------
00315 // enableControls()
00316 //-----------------------------------------------------------------------------
00317 void LLPanelAvatarSecondLife::enableControls(BOOL self)
00318 {
00319         childSetEnabled("img", self);
00320         childSetEnabled("about", self);
00321         childSetVisible("allow_publish", self);
00322         childSetEnabled("allow_publish", self);
00323         childSetVisible("?", self);
00324         childSetEnabled("?", self);
00325 }
00326 
00327 
00328 // static
00329 void LLPanelAvatarSecondLife::onClickImage(void *)
00330 { }
00331 
00332 // static
00333 void LLPanelAvatarSecondLife::onDoubleClickGroup(void* data)
00334 {
00335         LLPanelAvatarSecondLife* self = (LLPanelAvatarSecondLife*)data;
00336 
00337         
00338         LLScrollListCtrl*       group_list =  self->getChild<LLScrollListCtrl>("groups"); 
00339         if(group_list)
00340         {
00341                 LLScrollListItem* item = group_list->getFirstSelected();
00342                 
00343                 if(item && item->getUUID().notNull())
00344                 {
00345                         llinfos << "Show group info " << item->getUUID() << llendl;
00346 
00347                         LLFloaterGroupInfo::showFromUUID(item->getUUID());
00348                 }
00349         }
00350 }
00351 
00352 // static
00353 void LLPanelAvatarSecondLife::onClickPublishHelp(void *)
00354 {
00355         gViewerWindow->alertXml("ClickPublishHelpAvatar");
00356 }
00357 
00358 // static
00359 void LLPanelAvatarSecondLife::onClickPartnerHelp(void *)
00360 {
00361     gViewerWindow->alertXml("ClickPartnerHelpAvatar", onClickPartnerHelpLoadURL, (void*) NULL);
00362 }
00363 
00364 // static 
00365 void LLPanelAvatarSecondLife::onClickPartnerHelpLoadURL(S32 option, void* userdata)
00366 {
00367   if (option == 0)
00368     LLWeb::loadURL("http://secondlife.com/partner");
00369 }
00370 
00371 // static
00372 void LLPanelAvatarSecondLife::onClickPartnerInfo(void *data)
00373 {
00374         LLPanelAvatarSecondLife* self = (LLPanelAvatarSecondLife*) data;
00375         if (self->mPartnerID.notNull())
00376         {
00377                 LLFloaterAvatarInfo::showFromProfile(self->mPartnerID,
00378                                                                                          self->getScreenRect());
00379         }
00380 }
00381 
00382 //-----------------------------------------------------------------------------
00383 // LLPanelAvatarFirstLife()
00384 //-----------------------------------------------------------------------------
00385 LLPanelAvatarFirstLife::LLPanelAvatarFirstLife(const std::string& name, 
00386                                                                                            const LLRect &rect, 
00387                                                                                            LLPanelAvatar* panel_avatar ) 
00388 :       LLPanelAvatarTab(name, rect, panel_avatar)
00389 {
00390 }
00391 
00392 
00393 void LLPanelAvatarFirstLife::enableControls(BOOL self)
00394 {
00395         childSetEnabled("img", self);
00396         childSetEnabled("about", self);
00397 }
00398 
00399 //-----------------------------------------------------------------------------
00400 // postBuild
00401 //-----------------------------------------------------------------------------
00402 
00403 BOOL LLPanelAvatarSecondLife::postBuild(void)
00404 {
00405         childSetEnabled("born", FALSE);
00406         childSetEnabled("partner_edit", FALSE);
00407         childSetAction("partner_help",onClickPartnerHelp,this);
00408         childSetAction("partner_info", onClickPartnerInfo, this);
00409         childSetEnabled("partner_info", mPartnerID.notNull());
00410         
00411         childSetAction("?",onClickPublishHelp,this);
00412         BOOL own_avatar = (getPanelAvatar()->getAvatarID() == gAgent.getID() );
00413         enableControls(own_avatar);
00414 
00415         childSetVisible("About:",LLPanelAvatar::sAllowFirstLife);
00416         childSetVisible("(500 chars)",LLPanelAvatar::sAllowFirstLife);
00417         childSetVisible("about",LLPanelAvatar::sAllowFirstLife);
00418         
00419         childSetVisible("allow_publish",LLPanelAvatar::sAllowFirstLife);
00420         childSetVisible("?",LLPanelAvatar::sAllowFirstLife);
00421 
00422         childSetVisible("online_yes",FALSE);
00423 
00424         // These are cruft but may still exist in some xml files
00425         // TODO: remove the following 2 lines once translators grab these changes
00426         childSetVisible("online_unknown",FALSE);
00427         childSetVisible("online_no",FALSE);
00428 
00429         childSetAction("Find on Map", LLPanelAvatar::onClickTrack, getPanelAvatar());
00430         childSetAction("Instant Message...", LLPanelAvatar::onClickIM, getPanelAvatar());
00431         
00432         childSetAction("Add Friend...", LLPanelAvatar::onClickAddFriend, getPanelAvatar());
00433         childSetAction("Pay...", LLPanelAvatar::onClickPay, getPanelAvatar());
00434         childSetAction("Mute", LLPanelAvatar::onClickMute, getPanelAvatar() );  
00435 
00436         childSetAction("Offer Teleport...", LLPanelAvatar::onClickOfferTeleport, 
00437                 getPanelAvatar() );
00438 
00439         childSetDoubleClickCallback("groups", onDoubleClickGroup, this );
00440 
00441         return TRUE;
00442 }
00443 
00444 BOOL LLPanelAvatarFirstLife::postBuild(void)
00445 {
00446         BOOL own_avatar = (getPanelAvatar()->getAvatarID() == gAgent.getID() );
00447         enableControls(own_avatar);
00448         return TRUE;
00449 }
00450 
00451 BOOL LLPanelAvatarNotes::postBuild(void)
00452 {
00453         childSetCommitCallback("notes edit",onCommitNotes,this);
00454         
00455         LLTextEditor*   te = getChild<LLTextEditor>("notes edit");
00456         if(te) te->setCommitOnFocusLost(TRUE);
00457         return TRUE;
00458 }
00459 
00460 BOOL LLPanelAvatarWeb::postBuild(void)
00461 {
00462         childSetAction("load",onClickLoad,this);
00463         childSetAction("open",onClickOpen,this);
00464         childSetAction("home",onClickLoad,this);
00465         childSetAction("web_profile_help",onClickWebProfileHelp,this);
00466 
00467         childSetCommitCallback("url_edit",onCommitURL,this);
00468 
00469         childSetControlName("auto_load","AutoLoadWebProfiles");
00470 
00471         mWebBrowser = getChild<LLWebBrowserCtrl>("profile_html");
00472 
00473         // links open in internally 
00474         mWebBrowser->setOpenInExternalBrowser( false );
00475 
00476         // observe browser events
00477         mWebBrowser->addObserver( this );
00478 
00479         return TRUE;
00480 }
00481 
00482 BOOL LLPanelAvatarClassified::postBuild(void)
00483 {
00484         childSetAction("New...",onClickNew,NULL);
00485         childSetAction("Delete...",onClickDelete,NULL);
00486         return TRUE;
00487 }
00488 
00489 BOOL LLPanelAvatarPicks::postBuild(void)
00490 {
00491         childSetAction("New...",onClickNew,NULL);
00492         childSetAction("Delete...",onClickDelete,NULL);
00493         return TRUE;
00494 }
00495 
00496 BOOL LLPanelAvatarAdvanced::postBuild()
00497 {
00498         for(size_t ii = 0; ii < kArraySize(mWantToCheck); ++ii)
00499                 mWantToCheck[ii] = NULL;
00500         for(size_t ii = 0; ii < kArraySize(mSkillsCheck); ++ii)
00501                 mSkillsCheck[ii] = NULL;
00502         mWantToCount = (8>kArraySize(mWantToCheck))?kArraySize(mWantToCheck):8;
00503         for(S32 tt=0; tt < mWantToCount; ++tt)
00504         {       
00505                 LLString ctlname = llformat("chk%d", tt);
00506                 mWantToCheck[tt] = getChild<LLCheckBoxCtrl>(ctlname);
00507         }       
00508         mSkillsCount = (6>kArraySize(mSkillsCheck))?kArraySize(mSkillsCheck):6;
00509 
00510         for(S32 tt=0; tt < mSkillsCount; ++tt)
00511         {
00512                 //Find the Skills checkboxes and save off thier controls
00513                 LLString ctlname = llformat("schk%d",tt);
00514                 mSkillsCheck[tt] = getChild<LLCheckBoxCtrl>(ctlname);
00515         }
00516 
00517         mWantToEdit = getChild<LLLineEditor>("want_to_edit");
00518         mSkillsEdit = getChild<LLLineEditor>("skills_edit");
00519         childSetVisible("skills_edit",LLPanelAvatar::sAllowFirstLife);
00520         childSetVisible("want_to_edit",LLPanelAvatar::sAllowFirstLife);
00521 
00522         return TRUE;
00523 }
00524 
00525 //-----------------------------------------------------------------------------
00526 // LLPanelAvatarWeb
00527 //-----------------------------------------------------------------------------
00528 LLPanelAvatarWeb::LLPanelAvatarWeb(const std::string& name, const LLRect& rect, 
00529                                                                    LLPanelAvatar* panel_avatar)
00530 :       LLPanelAvatarTab(name, rect, panel_avatar),
00531         mWebBrowser(NULL)
00532 {
00533 }
00534 
00535 LLPanelAvatarWeb::~LLPanelAvatarWeb()
00536 {
00537         // stop observing browser events
00538         if  ( mWebBrowser )
00539         {
00540                 mWebBrowser->remObserver( this );
00541         };
00542 }
00543 
00544 void LLPanelAvatarWeb::enableControls(BOOL self)
00545 {       
00546         childSetEnabled("url_edit",self);
00547         childSetVisible("status_text",!self && !mURL.empty());
00548         childSetText("status_text", LLString::null);
00549 }
00550 
00551 void LLPanelAvatarWeb::setWebURL(std::string url)
00552 {
00553         bool changed_url = (mURL != url);
00554 
00555         mURL = url;
00556         bool have_url = !mURL.empty();
00557         
00558         childSetText("url_edit",mURL);
00559 
00560         childSetEnabled("load",have_url);
00561         childSetEnabled("open",have_url);
00562 
00563         childSetVisible("home",false);
00564         childSetVisible("load",true);
00565 
00566         if (have_url
00567                 && gSavedSettings.getBOOL("AutoLoadWebProfiles"))
00568         {
00569                 if (changed_url)
00570                 {
00571                         load();
00572                 }
00573         }
00574         else
00575         {
00576                 childSetVisible("profile_html",false);
00577         }
00578 
00579         BOOL own_avatar = (getPanelAvatar()->getAvatarID() == gAgent.getID() );
00580         childSetVisible("status_text",!own_avatar && !mURL.empty());
00581         
00582 }
00583 
00584 // static
00585 void LLPanelAvatarWeb::onCommitURL(LLUICtrl* ctrl, void* data)
00586 {
00587         LLPanelAvatarWeb* self = (LLPanelAvatarWeb*)data;
00588 
00589         if (!self) return;
00590         
00591         self->load( self->childGetText("url_edit") );
00592 }
00593 
00594 // static
00595 void LLPanelAvatarWeb::onClickWebProfileHelp(void *)
00596 {
00597         gViewerWindow->alertXml("ClickWebProfileHelpAvatar");
00598 }
00599 
00600 void LLPanelAvatarWeb::load(std::string url)
00601 {
00602         bool have_url = (!url.empty());
00603 
00604         if (have_url)
00605         {
00606                 llinfos << "Loading " << url << llendl;
00607                 mWebBrowser->navigateTo( url );
00608         }
00609 
00610         // If we have_url then we loaded so use the home button
00611         // Or if the url in address bar is not the home url show the home button.
00612         bool use_home = (have_url
00613                                          || url != mURL);
00614                                          
00615         childSetVisible("profile_html",have_url);
00616         childSetVisible("load",!use_home);      
00617         childSetVisible("home",use_home);
00618 
00619         childSetEnabled("load",!use_home);
00620         childSetEnabled("home",use_home);
00621         childSetEnabled("open",have_url);
00622         
00623 }
00624 
00625 void LLPanelAvatarWeb::load()
00626 {
00627         load(mURL);
00628 }
00629 
00630 // static
00631 void LLPanelAvatarWeb::onClickLoad(void* data)
00632 {
00633         LLPanelAvatarWeb* self = (LLPanelAvatarWeb*)data;
00634 
00635         if (!self) return;
00636         
00637         self->load();
00638 }
00639 
00640 // static
00641 void LLPanelAvatarWeb::onClickOpen(void* data)
00642 {
00643         LLPanelAvatarWeb* self = (LLPanelAvatarWeb*)data;
00644 
00645         if (!self) return;
00646 
00647         std::string url = self->childGetText("url_edit");
00648         if (!url.empty())
00649         {
00650                 LLWeb::loadURLExternal(url);
00651         }
00652 }
00653 
00654 void LLPanelAvatarWeb::onStatusTextChange( const EventType& eventIn )
00655 {
00656         childSetText("status_text", eventIn.getStringValue() );
00657 }
00658 
00659 void LLPanelAvatarWeb::onLocationChange( const EventType& eventIn )
00660 {
00661         childSetText("url_edit", eventIn.getStringValue() );
00662 }
00663 
00664 
00665 //-----------------------------------------------------------------------------
00666 // LLPanelAvatarAdvanced
00667 //-----------------------------------------------------------------------------
00668 LLPanelAvatarAdvanced::LLPanelAvatarAdvanced(const std::string& name, 
00669                                                                                          const LLRect& rect, 
00670                                                                                          LLPanelAvatar* panel_avatar)
00671 :       LLPanelAvatarTab(name, rect, panel_avatar),
00672         mWantToCount(0),
00673         mSkillsCount(0),
00674         mWantToEdit( NULL ),
00675         mSkillsEdit( NULL )
00676 {
00677 }
00678 
00679 void LLPanelAvatarAdvanced::enableControls(BOOL self)
00680 {
00681         S32 t;
00682         for(t=0;t<mWantToCount;t++)
00683         {
00684                 if(mWantToCheck[t])mWantToCheck[t]->setEnabled(self);
00685         }
00686         for(t=0;t<mSkillsCount;t++)
00687         {
00688                 if(mSkillsCheck[t])mSkillsCheck[t]->setEnabled(self);
00689         }
00690 
00691         if (mWantToEdit) mWantToEdit->setEnabled(self);
00692         if (mSkillsEdit) mSkillsEdit->setEnabled(self);
00693         childSetEnabled("languages_edit",self);
00694 }
00695 
00696 void LLPanelAvatarAdvanced::setWantSkills(U32 want_to_mask, const std::string& want_to_text,
00697                                                                                   U32 skills_mask, const std::string& skills_text,
00698                                                                                   const std::string& languages_text)
00699 {
00700         for(int id =0;id<mWantToCount;id++)
00701         {
00702                 mWantToCheck[id]->set( want_to_mask & 1<<id );
00703         }
00704         for(int id =0;id<mSkillsCount;id++)
00705         {
00706                 mSkillsCheck[id]->set( skills_mask & 1<<id );
00707         }
00708         if (mWantToEdit && mSkillsEdit)
00709         {
00710                 mWantToEdit->setText( want_to_text );
00711                 mSkillsEdit->setText( skills_text );
00712         }
00713 
00714         childSetText("languages_edit",languages_text);
00715 }
00716 
00717 void LLPanelAvatarAdvanced::getWantSkills(U32* want_to_mask, std::string& want_to_text,
00718                                                                                   U32* skills_mask, std::string& skills_text,
00719                                                                                   std::string& languages_text)
00720 {
00721         if (want_to_mask)
00722         {
00723                 *want_to_mask = 0;
00724                 for(int t=0;t<mWantToCount;t++)
00725                 {
00726                         if(mWantToCheck[t]->get())
00727                                 *want_to_mask |= 1<<t;
00728                 }
00729         }
00730         if (skills_mask)
00731         {
00732                 *skills_mask = 0;
00733                 for(int t=0;t<mSkillsCount;t++)
00734                 {
00735                         if(mSkillsCheck[t]->get())
00736                                 *skills_mask |= 1<<t;
00737                 }
00738         }
00739         if (mWantToEdit)
00740         {
00741                 want_to_text = mWantToEdit->getText();
00742         }
00743 
00744         if (mSkillsEdit)
00745         {
00746                 skills_text = mSkillsEdit->getText();
00747         }
00748 
00749         languages_text = childGetText("languages_edit");
00750 }       
00751 
00752 //-----------------------------------------------------------------------------
00753 // LLPanelAvatarNotes()
00754 //-----------------------------------------------------------------------------
00755 LLPanelAvatarNotes::LLPanelAvatarNotes(const std::string& name, const LLRect& rect, LLPanelAvatar* panel_avatar)
00756 :       LLPanelAvatarTab(name, rect, panel_avatar)
00757 {
00758 }
00759 
00760 void LLPanelAvatarNotes::refresh()
00761 {
00762         sendAvatarProfileRequestIfNeeded("avatarnotesrequest");
00763 }
00764 
00765 void LLPanelAvatarNotes::clearControls()
00766 {
00767         childSetText("notes edit", getString("Loading"));
00768         childSetEnabled("notes edit", false);
00769 }
00770 
00771 // static
00772 void LLPanelAvatarNotes::onCommitNotes(LLUICtrl*, void* userdata)
00773 {
00774         LLPanelAvatarNotes* self = (LLPanelAvatarNotes*)userdata;
00775 
00776         self->getPanelAvatar()->sendAvatarNotesUpdate();
00777 }
00778 
00779 
00780 //-----------------------------------------------------------------------------
00781 // LLPanelAvatarClassified()
00782 //-----------------------------------------------------------------------------
00783 LLPanelAvatarClassified::LLPanelAvatarClassified(const LLString& name, const LLRect& rect,
00784                                                                            LLPanelAvatar* panel_avatar)
00785 :       LLPanelAvatarTab(name, rect, panel_avatar)
00786 {
00787 }
00788 
00789 
00790 void LLPanelAvatarClassified::refresh()
00791 {
00792         BOOL self = (gAgent.getID() == getPanelAvatar()->getAvatarID());
00793         
00794         LLTabContainer* tabs = getChild<LLTabContainer>("classified tab");
00795         
00796         S32 tab_count = tabs ? tabs->getTabCount() : 0;
00797 
00798         bool allow_new = tab_count < MAX_CLASSIFIEDS;
00799         bool allow_delete = (tab_count > 0);
00800         bool show_help = (tab_count == 0);
00801 
00802         // *HACK: Don't allow making new classifieds from inside the directory.
00803         // The logic for save/don't save when closing is too hairy, and the 
00804         // directory is conceptually read-only. JC
00805         bool in_directory = false;
00806         LLView* view = this;
00807         while (view)
00808         {
00809                 if (view->getName() == "directory")
00810                 {
00811                         in_directory = true;
00812                         break;
00813                 }
00814                 view = view->getParent();
00815         }
00816         childSetEnabled("New...", self && !in_directory && allow_new);
00817         childSetVisible("New...", !in_directory);
00818         childSetEnabled("Delete...", self && !in_directory && allow_delete);
00819         childSetVisible("Delete...", !in_directory);
00820         childSetVisible("classified tab",!show_help);
00821 
00822         sendAvatarProfileRequestIfNeeded("avatarclassifiedsrequest");
00823 }
00824 
00825 
00826 BOOL LLPanelAvatarClassified::canClose()
00827 {
00828         LLTabContainer* tabs = getChild<LLTabContainer>("classified tab");
00829         for (S32 i = 0; i < tabs->getTabCount(); i++)
00830         {
00831                 LLPanelClassified* panel = (LLPanelClassified*)tabs->getPanelByIndex(i);
00832                 if (!panel->canClose())
00833                 {
00834                         return FALSE;
00835                 }
00836         }
00837         return TRUE;
00838 }
00839 
00840 BOOL LLPanelAvatarClassified::titleIsValid()
00841 {
00842         LLTabContainer* tabs = getChild<LLTabContainer>("classified tab");
00843         if ( tabs )
00844         {
00845                 LLPanelClassified* panel = (LLPanelClassified*)tabs->getCurrentPanel();
00846                 if ( panel )
00847                 {
00848                         if ( ! panel->titleIsValid() )
00849                         {
00850                                 return FALSE;
00851                         };
00852                 };
00853         };
00854 
00855         return TRUE;
00856 }
00857 
00858 void LLPanelAvatarClassified::apply()
00859 {
00860         LLTabContainer* tabs = getChild<LLTabContainer>("classified tab");
00861         for (S32 i = 0; i < tabs->getTabCount(); i++)
00862         {
00863                 LLPanelClassified* panel = (LLPanelClassified*)tabs->getPanelByIndex(i);
00864                 panel->apply();
00865         }
00866 }
00867 
00868 
00869 void LLPanelAvatarClassified::deleteClassifiedPanels()
00870 {
00871         LLTabContainer* tabs = getChild<LLTabContainer>("classified tab");
00872         if (tabs)
00873         {
00874                 tabs->deleteAllTabs();
00875         }
00876 
00877         childSetVisible("New...", false);
00878         childSetVisible("Delete...", false);
00879         childSetVisible("loading_text", true);
00880 }
00881 
00882 
00883 void LLPanelAvatarClassified::processAvatarClassifiedReply(LLMessageSystem* msg, void**)
00884 {
00885         S32 block = 0;
00886         S32 block_count = 0;
00887         LLUUID classified_id;
00888         char classified_name[DB_PICK_NAME_SIZE];                /*Flawfinder: ignore*/
00889         LLPanelClassified* panel_classified = NULL;
00890 
00891         LLTabContainer* tabs = getChild<LLTabContainer>("classified tab");
00892 
00893         // Don't remove old panels.  We need to be able to process multiple
00894         // packets for people who have lots of classifieds. JC
00895 
00896         block_count = msg->getNumberOfBlocksFast(_PREHASH_Data);
00897         for (block = 0; block < block_count; block++)
00898         {
00899                 msg->getUUIDFast(_PREHASH_Data, _PREHASH_ClassifiedID, classified_id, block);
00900                 msg->getStringFast(_PREHASH_Data, _PREHASH_Name, DB_PICK_NAME_SIZE, classified_name, block);
00901 
00902                 panel_classified = new LLPanelClassified(false, false);
00903 
00904                 panel_classified->setClassifiedID(classified_id);
00905 
00906                 // This will request data from the server when the pick is first drawn.
00907                 panel_classified->markForServerRequest();
00908 
00909                 // The button should automatically truncate long names for us
00910                 if(tabs)
00911                 {
00912                         tabs->addTabPanel(panel_classified, classified_name);
00913                 }
00914         }
00915 
00916         // Make sure somebody is highlighted.  This works even if there
00917         // are no tabs in the container.
00918         if(tabs)
00919         {
00920                 tabs->selectFirstTab();
00921         }
00922 
00923         childSetVisible("New...", true);
00924         childSetVisible("Delete...", true);
00925         childSetVisible("loading_text", false);
00926 }
00927 
00928 
00929 // Create a new classified panel.  It will automatically handle generating
00930 // its own id when it's time to save.
00931 // static
00932 void LLPanelAvatarClassified::onClickNew(void* data)
00933 {
00934         LLPanelAvatarClassified* self = (LLPanelAvatarClassified*)data;
00935 
00936         gViewerWindow->alertXml("AddClassified",callbackNew,self);
00937                 
00938 }
00939 
00940 // static
00941 void LLPanelAvatarClassified::callbackNew(S32 option, void* data)
00942 {
00943         LLPanelAvatarClassified* self = (LLPanelAvatarClassified*)data;
00944 
00945         if (0 == option)
00946         {
00947                 LLPanelClassified* panel_classified = new LLPanelClassified(false, false);
00948                 panel_classified->initNewClassified();
00949                 LLTabContainer* tabs = self->getChild<LLTabContainer>("classified tab");
00950                 if(tabs)
00951                 {
00952                         tabs->addTabPanel(panel_classified, panel_classified->getClassifiedName());
00953                         tabs->selectLastTab();
00954                 }
00955         }
00956 }
00957 
00958 
00959 // static
00960 void LLPanelAvatarClassified::onClickDelete(void* data)
00961 {
00962         LLPanelAvatarClassified* self = (LLPanelAvatarClassified*)data;
00963 
00964         LLTabContainer* tabs = self->getChild<LLTabContainer>("classified tab");
00965         LLPanelClassified* panel_classified = NULL;
00966         if(tabs)
00967         {
00968                 panel_classified = (LLPanelClassified*)tabs->getCurrentPanel();
00969         }
00970         if (!panel_classified) return;
00971 
00972         LLStringBase<char>::format_map_t args;
00973         args["[NAME]"] = panel_classified->getClassifiedName();
00974         gViewerWindow->alertXml("DeleteClassified", args, callbackDelete, self);
00975                 
00976 }
00977 
00978 
00979 // static
00980 void LLPanelAvatarClassified::callbackDelete(S32 option, void* data)
00981 {
00982         LLPanelAvatarClassified* self = (LLPanelAvatarClassified*)data;
00983         LLTabContainer* tabs = self->getChild<LLTabContainer>("classified tab");
00984         LLPanelClassified* panel_classified=NULL;
00985         if(tabs)
00986         {
00987                 panel_classified = (LLPanelClassified*)tabs->getCurrentPanel();
00988         }
00989         
00990         LLMessageSystem* msg = gMessageSystem;
00991 
00992         if (!panel_classified) return;
00993 
00994         if (0 == option)
00995         {
00996                 msg->newMessageFast(_PREHASH_ClassifiedDelete);
00997                 msg->nextBlockFast(_PREHASH_AgentData);
00998                 msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
00999                 msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
01000                 msg->nextBlockFast(_PREHASH_Data);
01001                 msg->addUUIDFast(_PREHASH_ClassifiedID, panel_classified->getClassifiedID());
01002                 gAgent.sendReliableMessage();
01003 
01004                 if(tabs)
01005                 {
01006                         tabs->removeTabPanel(panel_classified);
01007                 }
01008                 delete panel_classified;
01009                 panel_classified = NULL;
01010         }
01011 }
01012 
01013 
01014 //-----------------------------------------------------------------------------
01015 // LLPanelAvatarPicks()
01016 //-----------------------------------------------------------------------------
01017 LLPanelAvatarPicks::LLPanelAvatarPicks(const std::string& name, 
01018                                                                            const LLRect& rect,
01019                                                                            LLPanelAvatar* panel_avatar)
01020 :       LLPanelAvatarTab(name, rect, panel_avatar)
01021 {
01022 }
01023 
01024 
01025 void LLPanelAvatarPicks::refresh()
01026 {
01027         BOOL self = (gAgent.getID() == getPanelAvatar()->getAvatarID());
01028         LLTabContainer* tabs = getChild<LLTabContainer>("picks tab");
01029         S32 tab_count = tabs ? tabs->getTabCount() : 0;
01030         childSetEnabled("New...",    self && tab_count < MAX_AVATAR_PICKS);
01031         childSetEnabled("Delete...", self && tab_count > 0);
01032         childSetVisible("New...",    self && getPanelAvatar()->isEditable());
01033         childSetVisible("Delete...", self && getPanelAvatar()->isEditable());
01034 
01035         sendAvatarProfileRequestIfNeeded("avatarpicksrequest");
01036 }
01037 
01038 
01039 void LLPanelAvatarPicks::deletePickPanels()
01040 {
01041         LLTabContainer* tabs = getChild<LLTabContainer>("picks tab");
01042         if(tabs)
01043         {
01044                 tabs->deleteAllTabs();
01045         }
01046 
01047         childSetVisible("New...", false);
01048         childSetVisible("Delete...", false);
01049         childSetVisible("loading_text", true);
01050 }
01051 
01052 void LLPanelAvatarPicks::processAvatarPicksReply(LLMessageSystem* msg, void**)
01053 {
01054         S32 block = 0;
01055         S32 block_count = 0;
01056         LLUUID pick_id;
01057         char pick_name[DB_PICK_NAME_SIZE];              /*Flawfinder: ignore*/
01058         LLPanelPick* panel_pick = NULL;
01059 
01060         LLTabContainer* tabs =  getChild<LLTabContainer>("picks tab");
01061 
01062         // Clear out all the old panels.  We'll replace them with the correct
01063         // number of new panels.
01064         deletePickPanels();
01065 
01066         // The database needs to know for which user to look up picks.
01067         LLUUID avatar_id = getPanelAvatar()->getAvatarID();
01068         
01069         block_count = msg->getNumberOfBlocks("Data");
01070         for (block = 0; block < block_count; block++)
01071         {
01072                 msg->getUUID("Data", "PickID", pick_id, block);
01073                 msg->getString("Data", "PickName", DB_PICK_NAME_SIZE, pick_name, block);
01074 
01075                 panel_pick = new LLPanelPick(FALSE);
01076 
01077                 panel_pick->setPickID(pick_id, avatar_id);
01078 
01079                 // This will request data from the server when the pick is first
01080                 // drawn.
01081                 panel_pick->markForServerRequest();
01082 
01083                 // The button should automatically truncate long names for us
01084                 if(tabs)
01085                 {
01086                         tabs->addTabPanel(panel_pick, pick_name);
01087                 }
01088         }
01089 
01090         // Make sure somebody is highlighted.  This works even if there
01091         // are no tabs in the container.
01092         if(tabs)
01093         {
01094                 tabs->selectFirstTab();
01095         }
01096 
01097         childSetVisible("New...", true);
01098         childSetVisible("Delete...", true);
01099         childSetVisible("loading_text", false);
01100 }
01101 
01102 
01103 // Create a new pick panel.  It will automatically handle generating
01104 // its own id when it's time to save.
01105 // static
01106 void LLPanelAvatarPicks::onClickNew(void* data)
01107 {
01108         LLPanelAvatarPicks* self = (LLPanelAvatarPicks*)data;
01109         LLPanelPick* panel_pick = new LLPanelPick(FALSE);
01110         LLTabContainer* tabs =  self->getChild<LLTabContainer>("picks tab");
01111 
01112         panel_pick->initNewPick();
01113         if(tabs)
01114         {
01115                 tabs->addTabPanel(panel_pick, panel_pick->getPickName());
01116                 tabs->selectLastTab();
01117         }
01118 }
01119 
01120 
01121 // static
01122 void LLPanelAvatarPicks::onClickDelete(void* data)
01123 {
01124         LLPanelAvatarPicks* self = (LLPanelAvatarPicks*)data;
01125         LLTabContainer* tabs =  self->getChild<LLTabContainer>("picks tab");
01126         LLPanelPick* panel_pick = tabs?(LLPanelPick*)tabs->getCurrentPanel():NULL;
01127 
01128         if (!panel_pick) return;
01129 
01130         LLString::format_map_t args;
01131         args["[PICK]"] = panel_pick->getPickName();
01132 
01133         gViewerWindow->alertXml("DeleteAvatarPick", args,
01134                 callbackDelete,
01135                 self);
01136 }
01137 
01138 
01139 // static
01140 void LLPanelAvatarPicks::callbackDelete(S32 option, void* data)
01141 {
01142         LLPanelAvatarPicks* self = (LLPanelAvatarPicks*)data;
01143         LLTabContainer* tabs = self->getChild<LLTabContainer>("picks tab");
01144         LLPanelPick* panel_pick = tabs?(LLPanelPick*)tabs->getCurrentPanel():NULL;
01145         LLMessageSystem* msg = gMessageSystem;
01146 
01147         if (!panel_pick) return;
01148 
01149         if (0 == option)
01150         {
01151                 // If the viewer has a hacked god-mode, then this call will
01152                 // fail.
01153                 if(gAgent.isGodlike())
01154                 {
01155                         msg->newMessage("PickGodDelete");                       
01156                         msg->nextBlock("AgentData");
01157                         msg->addUUID("AgentID", gAgent.getID());
01158                         msg->addUUID("SessionID", gAgent.getSessionID());
01159                         msg->nextBlock("Data");
01160                         msg->addUUID("PickID", panel_pick->getPickID());
01161                         // *HACK: We need to send the pick's creator id to accomplish
01162                         // the delete, and we don't use the query id for anything. JC
01163                         msg->addUUID( "QueryID", panel_pick->getPickCreatorID() );
01164                 }
01165                 else
01166                 {
01167                         msg->newMessage("PickDelete");
01168                         msg->nextBlock("AgentData");
01169                         msg->addUUID("AgentID", gAgent.getID());
01170                         msg->addUUID("SessionID", gAgent.getSessionID());
01171                         msg->nextBlock("Data");
01172                         msg->addUUID("PickID", panel_pick->getPickID());
01173                 }
01174                 gAgent.sendReliableMessage();
01175 
01176                 if(tabs)
01177                 {
01178                         tabs->removeTabPanel(panel_pick);
01179                 }
01180                 delete panel_pick;
01181                 panel_pick = NULL;
01182         }
01183 }
01184 
01185 
01186 //-----------------------------------------------------------------------------
01187 // LLPanelAvatar
01188 //-----------------------------------------------------------------------------
01189 LLPanelAvatar::LLPanelAvatar(
01190         const std::string& name,
01191         const LLRect &rect,
01192         BOOL allow_edit)
01193         :
01194         LLPanel(name, rect, FALSE),
01195         mPanelSecondLife(NULL),
01196         mPanelAdvanced(NULL),
01197         mPanelClassified(NULL),
01198         mPanelPicks(NULL),
01199         mPanelNotes(NULL),
01200         mPanelFirstLife(NULL),
01201         mPanelWeb(NULL),
01202         mDropTarget(NULL),
01203         mAvatarID( LLUUID::null ),      // mAvatarID is set with 'setAvatar' or 'setAvatarID'
01204         mHaveProperties(FALSE),
01205         mHaveStatistics(FALSE),
01206         mHaveNotes(false),
01207         mLastNotes(),
01208         mAllowEdit(allow_edit)
01209 {
01210 
01211         sAllPanels.push_back(this);
01212 
01213         LLCallbackMap::map_t factory_map;
01214 
01215         factory_map["2nd Life"] = LLCallbackMap(createPanelAvatarSecondLife, this);
01216         factory_map["WebProfile"] = LLCallbackMap(createPanelAvatarWeb, this);
01217         factory_map["Interests"] = LLCallbackMap(createPanelAvatarInterests, this);
01218         factory_map["Picks"] = LLCallbackMap(createPanelAvatarPicks, this);
01219         factory_map["Classified"] = LLCallbackMap(createPanelAvatarClassified, this);
01220         factory_map["1st Life"] = LLCallbackMap(createPanelAvatarFirstLife, this);
01221         factory_map["My Notes"] = LLCallbackMap(createPanelAvatarNotes, this);
01222         
01223         LLUICtrlFactory::getInstance()->buildPanel(this, "panel_avatar.xml", &factory_map);
01224 
01225         selectTab(0);
01226         
01227 
01228 }
01229 
01230 BOOL LLPanelAvatar::postBuild(void)
01231 {
01232         mTab = getChild<LLTabContainer>("tab");
01233         childSetAction("Kick",onClickKick,this);
01234         childSetAction("Freeze",onClickFreeze, this);
01235         childSetAction("Unfreeze", onClickUnfreeze, this);
01236         childSetAction("csr_btn", onClickCSR, this);
01237         childSetAction("OK", onClickOK, this);
01238         childSetAction("Cancel", onClickCancel, this);
01239 
01240         if(mTab && !sAllowFirstLife)
01241         {
01242                 LLPanel* panel = mTab->getPanelByName("1st Life");
01243                 if (panel) mTab->removeTabPanel(panel);
01244 
01245                 panel = mTab->getPanelByName("WebProfile");
01246                 if (panel) mTab->removeTabPanel(panel);
01247         }
01248         childSetVisible("Kick",FALSE);
01249         childSetEnabled("Kick",FALSE);
01250         childSetVisible("Freeze",FALSE);
01251         childSetEnabled("Freeze",FALSE);
01252         childSetVisible("Unfreeze",FALSE);
01253         childSetEnabled("Unfreeze",FALSE);
01254         childSetVisible("csr_btn", FALSE);
01255         childSetEnabled("csr_btn", FALSE);
01256 
01257         return TRUE;
01258 }
01259 
01260 
01261 LLPanelAvatar::~LLPanelAvatar()
01262 {
01263         sAllPanels.remove(this);
01264 }
01265 
01266 
01267 BOOL LLPanelAvatar::canClose()
01268 {
01269         return mPanelClassified && mPanelClassified->canClose();
01270 }
01271 
01272 void LLPanelAvatar::setAvatar(LLViewerObject *avatarp)
01273 {
01274         // find the avatar and grab the name
01275         LLNameValue *firstname = avatarp->getNVPair("FirstName");
01276         LLNameValue *lastname = avatarp->getNVPair("LastName");
01277 
01278         LLString name;
01279         if (firstname && lastname)
01280         {
01281                 name.assign( firstname->getString() );
01282                 name.append(" ");
01283                 name.append( lastname->getString() );
01284         }
01285         else
01286         {
01287                 name.assign("");
01288         }
01289 
01290         // If we have an avatar pointer, they must be online.
01291         setAvatarID(avatarp->getID(), name, ONLINE_STATUS_YES);
01292 }
01293 
01294 void LLPanelAvatar::setOnlineStatus(EOnlineStatus online_status)
01295 {
01296         // Online status NO could be because they are hidden
01297         // If they are a friend, we may know the truth!
01298         if ((ONLINE_STATUS_YES != online_status)
01299                 && mIsFriend
01300                 && (LLAvatarTracker::instance().isBuddyOnline( mAvatarID )))
01301         {
01302                 online_status = ONLINE_STATUS_YES;
01303         }
01304 
01305         mPanelSecondLife->childSetVisible("online_yes", (online_status == ONLINE_STATUS_YES));
01306 
01307         // Since setOnlineStatus gets called after setAvatarID
01308         // need to make sure that "Offer Teleport" doesn't get set
01309         // to TRUE again for yourself
01310         if (mAvatarID != gAgent.getID())
01311         {
01312                 childSetVisible("Offer Teleport...",TRUE);
01313         }
01314 
01315         BOOL in_prelude = gAgent.inPrelude();
01316         if(gAgent.isGodlike())
01317         {
01318                 childSetEnabled("Offer Teleport...", TRUE);
01319                 childSetToolTip("Offer Teleport...", childGetValue("TeleportGod").asString());
01320         }
01321         else if (in_prelude)
01322         {
01323                 childSetEnabled("Offer Teleport...",FALSE);
01324                 childSetToolTip("Offer Teleport...",childGetValue("TeleportPrelude").asString());
01325         }
01326         else
01327         {
01328                 childSetEnabled("Offer Teleport...", (online_status == ONLINE_STATUS_YES));
01329                 childSetToolTip("Offer Teleport...", childGetValue("TeleportNormal").asString());
01330         }
01331 }
01332 
01333 void LLPanelAvatar::setAvatarID(const LLUUID &avatar_id, const LLString &name,
01334                                                                 EOnlineStatus online_status)
01335 {
01336         if (avatar_id.isNull()) return;
01337 
01338         BOOL avatar_changed = FALSE;
01339         if (avatar_id != mAvatarID)
01340         {
01341                 avatar_changed = TRUE;
01342         }
01343         mAvatarID = avatar_id;
01344 
01345         // Determine if we have their calling card.
01346         mIsFriend = is_agent_friend(mAvatarID); 
01347 
01348         // setOnlineStatus uses mIsFriend
01349         setOnlineStatus(online_status);
01350         
01351         BOOL own_avatar = (mAvatarID == gAgent.getID() );
01352         BOOL avatar_is_friend = LLAvatarTracker::instance().getBuddyInfo(mAvatarID) != NULL;
01353 
01354         mPanelSecondLife->enableControls(own_avatar && mAllowEdit);
01355         mPanelWeb->enableControls(own_avatar && mAllowEdit);
01356         mPanelAdvanced->enableControls(own_avatar && mAllowEdit);
01357         // Teens don't have this.
01358         if (mPanelFirstLife) mPanelFirstLife->enableControls(own_avatar && mAllowEdit);
01359 
01360         LLView *target_view = getChild<LLView>("drop_target_rect");
01361         if(target_view)
01362         {
01363                 if (mDropTarget)
01364                 {
01365                         delete mDropTarget;
01366                 }
01367                 mDropTarget = new LLDropTarget("drop target", target_view->getRect(), mAvatarID);
01368                 addChild(mDropTarget);
01369                 mDropTarget->setAgentID(mAvatarID);
01370         }
01371 
01372         LLNameEditor* name_edit = getChild<LLNameEditor>("name");
01373         if(name_edit)
01374         {
01375                 if (name.empty())
01376                 {
01377                         name_edit->setNameID(avatar_id, FALSE);
01378                 }
01379                 else
01380                 {
01381                         name_edit->setText(name);
01382                 }
01383         }
01384 //      if (avatar_changed)
01385         {
01386                 // While we're waiting for data off the network, clear out the
01387                 // old data.
01388                 mPanelSecondLife->clearControls();
01389 
01390                 mPanelPicks->deletePickPanels();
01391                 mPanelPicks->setDataRequested(false);
01392 
01393                 mPanelClassified->deleteClassifiedPanels();
01394                 mPanelClassified->setDataRequested(false);
01395 
01396                 mPanelNotes->clearControls();
01397                 mPanelNotes->setDataRequested(false);
01398                 mHaveNotes = false;
01399                 mLastNotes.clear();
01400 
01401                 // Request just the first two pages of data.  The picks,
01402                 // classifieds, and notes will be requested when that panel
01403                 // is made visible. JC
01404                 sendAvatarPropertiesRequest();
01405 
01406                 if (own_avatar)
01407                 {
01408                         if (mAllowEdit)
01409                         {
01410                                 // OK button disabled until properties data arrives
01411                                 childSetVisible("OK", true);
01412                                 childSetEnabled("OK", false);
01413                                 childSetVisible("Cancel",TRUE);
01414                                 childSetEnabled("Cancel",TRUE);
01415                         }
01416                         else
01417                         {
01418                                 childSetVisible("OK",FALSE);
01419                                 childSetEnabled("OK",FALSE);
01420                                 childSetVisible("Cancel",FALSE);
01421                                 childSetEnabled("Cancel",FALSE);
01422                         }
01423                         childSetVisible("Instant Message...",FALSE);
01424                         childSetEnabled("Instant Message...",FALSE);
01425                         childSetVisible("Mute",FALSE);
01426                         childSetEnabled("Mute",FALSE);
01427                         childSetVisible("Offer Teleport...",FALSE);
01428                         childSetEnabled("Offer Teleport...",FALSE);
01429                         childSetVisible("drop target",FALSE);
01430                         childSetEnabled("drop target",FALSE);
01431                         childSetVisible("Find on Map",FALSE);
01432                         childSetEnabled("Find on Map",FALSE);
01433                         childSetVisible("Add Friend...",FALSE);
01434                         childSetEnabled("Add Friend...",FALSE);
01435                         childSetVisible("Pay...",FALSE);
01436                         childSetEnabled("Pay...",FALSE);
01437                 }
01438                 else
01439                 {
01440                         childSetVisible("OK",FALSE);
01441                         childSetEnabled("OK",FALSE);
01442 
01443                         childSetVisible("Cancel",FALSE);
01444                         childSetEnabled("Cancel",FALSE);
01445 
01446                         childSetVisible("Instant Message...",TRUE);
01447                         childSetEnabled("Instant Message...",FALSE);
01448                         childSetVisible("Mute",TRUE);
01449                         childSetEnabled("Mute",FALSE);
01450 
01451                         childSetVisible("drop target",TRUE);
01452                         childSetEnabled("drop target",FALSE);
01453 
01454                         childSetVisible("Find on Map",TRUE);
01455                         // Note: we don't always know online status, so always allow gods to try to track
01456                         BOOL enable_track = gAgent.isGodlike() || is_agent_mappable(mAvatarID);
01457                         childSetEnabled("Find on Map",enable_track);
01458                         if (!mIsFriend)
01459                         {
01460                                 childSetToolTip("Find on Map",childGetValue("ShowOnMapNonFriend").asString());
01461                         }
01462                         else if (ONLINE_STATUS_YES != online_status)
01463                         {
01464                                 childSetToolTip("Find on Map",childGetValue("ShowOnMapFriendOffline").asString());
01465                         }
01466                         else
01467                         {
01468                                 childSetToolTip("Find on Map",childGetValue("ShowOnMapFriendOnline").asString());
01469                         }
01470                         childSetVisible("Add Friend...", true);
01471                         childSetEnabled("Add Friend...", !avatar_is_friend);
01472                         childSetVisible("Pay...",TRUE);
01473                         childSetEnabled("Pay...",FALSE);
01474                 }
01475         }
01476         
01477         BOOL is_god = FALSE;
01478         if (gAgent.isGodlike()) is_god = TRUE;
01479         
01480         childSetVisible("Kick", is_god);
01481         childSetEnabled("Kick", is_god);
01482         childSetVisible("Freeze", is_god);
01483         childSetEnabled("Freeze", is_god);
01484         childSetVisible("Unfreeze", is_god);
01485         childSetEnabled("Unfreeze", is_god);
01486         childSetVisible("csr_btn", is_god);
01487         childSetEnabled("csr_btn", is_god);
01488 }
01489 
01490 
01491 void LLPanelAvatar::resetGroupList()
01492 {
01493         // only get these updates asynchronously via the group floater, which works on the agent only
01494         if (mAvatarID != gAgent.getID())
01495         {
01496                 return;
01497         }
01498                 
01499         if (mPanelSecondLife)
01500         {
01501                 LLScrollListCtrl* group_list = mPanelSecondLife->getChild<LLScrollListCtrl>("groups");
01502                 if (group_list)
01503                 {
01504                         group_list->deleteAllItems();
01505                         
01506                         S32 count = gAgent.mGroups.count();
01507                         LLUUID id;
01508                         
01509                         for(S32 i = 0; i < count; ++i)
01510                         {
01511                                 LLGroupData group_data = gAgent.mGroups.get(i);
01512                                 id = group_data.mID;
01513                                 std::string group_string;
01514                                 /* Show group title?  DUMMY_POWER for Don Grep
01515                                    if(group_data.mOfficer)
01516                                    {
01517                                    group_string = "Officer of ";
01518                                    }
01519                                    else
01520                                    {
01521                                    group_string = "Member of ";
01522                                    }
01523                                 */
01524 
01525                                 group_string += group_data.mName;
01526 
01527                                 LLSD row;
01528 
01529                                 row["id"] = id ;
01530                                 row["columns"][0]["value"] = group_string;
01531                                 row["columns"][0]["font"] = "SANSSERIF_SMALL";
01532                                 row["columns"][0]["width"] = 0;
01533                                 group_list->addElement(row);
01534                         }
01535                         group_list->sortByColumn(0, TRUE);
01536                 }
01537         }
01538 }
01539 
01540 // static
01541 //-----------------------------------------------------------------------------
01542 // onClickIM()
01543 //-----------------------------------------------------------------------------
01544 void LLPanelAvatar::onClickIM(void* userdata)
01545 {
01546         LLPanelAvatar* self = (LLPanelAvatar*) userdata;
01547         gIMMgr->setFloaterOpen(TRUE);
01548 
01549         std::string name;
01550         LLNameEditor* nameedit = self->mPanelSecondLife->getChild<LLNameEditor>("name");
01551         if (nameedit) name = nameedit->getText();
01552         gIMMgr->addSession(name, IM_NOTHING_SPECIAL, self->mAvatarID);
01553 }
01554 
01555 
01556 // static
01557 //-----------------------------------------------------------------------------
01558 // onClickTrack()
01559 //-----------------------------------------------------------------------------
01560 void LLPanelAvatar::onClickTrack(void* userdata)
01561 {
01562         LLPanelAvatar* self = (LLPanelAvatar*) userdata;
01563         
01564         if( gFloaterWorldMap )
01565         {
01566                 std::string name;
01567                 LLNameEditor* nameedit = self->mPanelSecondLife->getChild<LLNameEditor>("name");
01568                 if (nameedit) name = nameedit->getText();
01569                 gFloaterWorldMap->trackAvatar(self->mAvatarID, name);
01570                 LLFloaterWorldMap::show(NULL, TRUE);
01571         }
01572 }
01573 
01574 
01575 // static
01576 void LLPanelAvatar::onClickAddFriend(void* userdata)
01577 {
01578         LLPanelAvatar* self = (LLPanelAvatar*) userdata;
01579         LLNameEditor* name_edit = self->mPanelSecondLife->getChild<LLNameEditor>("name");       
01580         if (name_edit)
01581         {
01582                 LLPanelFriends::requestFriendshipDialog(self->getAvatarID(),
01583                                                                                                   name_edit->getText());
01584         }
01585 }
01586 
01587 //-----------------------------------------------------------------------------
01588 // onClickMute()
01589 //-----------------------------------------------------------------------------
01590 void LLPanelAvatar::onClickMute(void *userdata)
01591 {
01592         LLPanelAvatar* self = (LLPanelAvatar*) userdata;
01593         
01594         LLUUID agent_id = self->getAvatarID();
01595         LLNameEditor* name_edit = self->mPanelSecondLife->getChild<LLNameEditor>("name");
01596         
01597         if (name_edit)
01598         {
01599                 std::string agent_name = name_edit->getText();
01600                 LLFloaterMute::showInstance();
01601                 
01602                 if (LLMuteList::getInstance()->isMuted(agent_id))
01603                 {
01604                         LLFloaterMute::getInstance()->selectMute(agent_id);
01605                 }
01606                 else
01607                 {
01608                         LLMute mute(agent_id, agent_name, LLMute::AGENT);
01609                         LLMuteList::getInstance()->add(mute);
01610                 }
01611         }
01612 }
01613 
01614 
01615 // static
01616 void LLPanelAvatar::onClickOfferTeleport(void *userdata)
01617 {
01618         LLPanelAvatar* self = (LLPanelAvatar*) userdata;
01619 
01620         handle_lure(self->mAvatarID);
01621 }
01622 
01623 
01624 // static
01625 void LLPanelAvatar::onClickPay(void *userdata)
01626 {
01627         LLPanelAvatar* self = (LLPanelAvatar*) userdata;
01628         handle_pay_by_id(self->mAvatarID);
01629 }
01630 
01631 
01632 // static
01633 void LLPanelAvatar::onClickOK(void *userdata)
01634 {
01635         LLPanelAvatar *self = (LLPanelAvatar *)userdata;
01636 
01637         // JC: Only save the data if we actually got the original
01638         // properties.  Otherwise we might save blanks into
01639         // the database.
01640         if (self
01641                 && self->mHaveProperties)
01642         {
01643                 self->sendAvatarPropertiesUpdate();
01644 
01645                 LLTabContainer* tabs = self->getChild<LLTabContainer>("tab");
01646                 if ( tabs->getCurrentPanel() != self->mPanelClassified )
01647                 {
01648                         self->mPanelClassified->apply();
01649 
01650                         LLFloaterAvatarInfo *infop = LLFloaterAvatarInfo::getInstance(self->mAvatarID);
01651                         if (infop)
01652                         {
01653                                 infop->close();
01654                         }
01655                 }
01656                 else
01657                 {
01658                         if ( self->mPanelClassified->titleIsValid() )
01659                         {
01660                                 self->mPanelClassified->apply();
01661 
01662                                 LLFloaterAvatarInfo *infop = LLFloaterAvatarInfo::getInstance(self->mAvatarID);
01663                                 if (infop)
01664                                 {
01665                                         infop->close();
01666                                 }
01667                         }
01668                 }
01669         }
01670 }
01671 
01672 // static
01673 void LLPanelAvatar::onClickCancel(void *userdata)
01674 {
01675         LLPanelAvatar *self = (LLPanelAvatar *)userdata;
01676 
01677         if (self)
01678         {
01679                 LLFloaterAvatarInfo *infop;
01680                 if ((infop = LLFloaterAvatarInfo::getInstance(self->mAvatarID)))
01681                 {
01682                         infop->close();
01683                 }
01684                 else
01685                 {
01686                         // We're in the Search directory and are cancelling an edit
01687                         // to our own profile, so reset.
01688                         self->sendAvatarPropertiesRequest();
01689                 }
01690         }
01691 }
01692 
01693 
01694 void LLPanelAvatar::sendAvatarPropertiesRequest()
01695 {
01696         lldebugs << "LLPanelAvatar::sendAvatarPropertiesRequest()" << llendl; 
01697         LLMessageSystem *msg = gMessageSystem;
01698 
01699         msg->newMessageFast(_PREHASH_AvatarPropertiesRequest);
01700         msg->nextBlockFast( _PREHASH_AgentData);
01701         msg->addUUIDFast(   _PREHASH_AgentID, gAgent.getID() );
01702         msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
01703         msg->addUUIDFast(   _PREHASH_AvatarID, mAvatarID);
01704         gAgent.sendReliableMessage();
01705 }
01706 
01707 void LLPanelAvatar::sendAvatarNotesUpdate()
01708 {
01709         std::string notes = mPanelNotes->childGetValue("notes edit").asString();
01710 
01711         if (!mHaveNotes
01712                 && (notes.empty() || notes == getString("Loading")))
01713         {
01714                 // no notes from server and no user updates
01715                 return;
01716         }
01717         if (notes == mLastNotes)
01718         {
01719                 // Avatar notes unchanged
01720                 return;
01721         }
01722 
01723         LLMessageSystem *msg = gMessageSystem;
01724 
01725         msg->newMessage("AvatarNotesUpdate");
01726         msg->nextBlock("AgentData");
01727         msg->addUUID("AgentID", gAgent.getID());
01728         msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
01729         msg->nextBlock("Data");
01730         msg->addUUID("TargetID", mAvatarID);
01731         msg->addString("Notes", notes);
01732 
01733         gAgent.sendReliableMessage();
01734 }
01735 
01736 
01737 // static
01738 void LLPanelAvatar::processAvatarPropertiesReply(LLMessageSystem *msg, void**)
01739 {
01740         LLUUID  agent_id;       // your id
01741         LLUUID  avatar_id;      // target of this panel
01742         LLUUID  image_id;
01743         LLUUID  fl_image_id;
01744         LLUUID  partner_id;
01745         char    about_text[DB_USER_ABOUT_BUF_SIZE];             /*Flawfinder: ignore*/
01746         char    fl_about_text[DB_USER_FL_ABOUT_BUF_SIZE];               /*Flawfinder: ignore*/
01747         char    born_on[DB_BORN_BUF_SIZE];              /*Flawfinder: ignore*/
01748         S32             charter_member_size = 0;
01749         BOOL    allow_publish = FALSE;
01750         //BOOL  mature = FALSE;
01751         BOOL    identified = FALSE;
01752         BOOL    transacted = FALSE;
01753         BOOL    age_verified = FALSE;
01754         BOOL    online = FALSE;
01755         char    profile_url[DB_USER_PROFILE_URL_BUF_SIZE];              /*Flawfinder: ignore*/
01756 
01757         U32             flags = 0x0;
01758 
01759         //llinfos << "properties packet size " << msg->getReceiveSize() << llendl;
01760 
01761         msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_AgentID, agent_id);
01762         msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_AvatarID, avatar_id );
01763 
01764         for (panel_list_t::iterator iter = sAllPanels.begin(); iter != sAllPanels.end(); ++iter)
01765         {
01766                 LLPanelAvatar* self = *iter;
01767                 if (self->mAvatarID != avatar_id)
01768                 {
01769                         continue;
01770                 }
01771                 self->childSetEnabled("Instant Message...",TRUE);
01772                 self->childSetEnabled("Pay...",TRUE);
01773                 self->childSetEnabled("Mute",TRUE);
01774 
01775                 self->childSetEnabled("drop target",TRUE);
01776 
01777                 self->mHaveProperties = TRUE;
01778                 self->enableOKIfReady();
01779 
01780                 msg->getUUIDFast(  _PREHASH_PropertiesData,     _PREHASH_ImageID,               image_id );
01781                 msg->getUUIDFast(  _PREHASH_PropertiesData,     _PREHASH_FLImageID,     fl_image_id );
01782                 msg->getUUIDFast(_PREHASH_PropertiesData, _PREHASH_PartnerID, partner_id);
01783                 msg->getStringFast(_PREHASH_PropertiesData, _PREHASH_AboutText, DB_USER_ABOUT_BUF_SIZE,         about_text );
01784                 msg->getStringFast(_PREHASH_PropertiesData, _PREHASH_FLAboutText,       DB_USER_FL_ABOUT_BUF_SIZE,              fl_about_text );
01785                 msg->getStringFast(_PREHASH_PropertiesData, _PREHASH_BornOn, DB_BORN_BUF_SIZE, born_on);
01786                 msg->getString("PropertiesData","ProfileURL", DB_USER_PROFILE_URL_BUF_SIZE, profile_url);
01787                 msg->getU32Fast(_PREHASH_PropertiesData, _PREHASH_Flags, flags);
01788                 
01789                 identified = (flags & AVATAR_IDENTIFIED);
01790                 transacted = (flags & AVATAR_TRANSACTED);
01791                 age_verified = (flags & AVATAR_AGEVERIFIED); // Not currently getting set in dataserver/lldataavatar.cpp for privacy considerations
01792                 allow_publish = (flags & AVATAR_ALLOW_PUBLISH);
01793                 online = (flags & AVATAR_ONLINE);
01794                 
01795                 U8 caption_index = 0;
01796                 LLString caption_text;
01797                 charter_member_size = msg->getSize("PropertiesData", "CharterMember");
01798                 if(1 == charter_member_size)
01799                 {
01800                         msg->getBinaryData("PropertiesData", "CharterMember", &caption_index, 1);
01801                 }
01802                 else if(1 < charter_member_size)
01803                 {
01804                         char caption[MAX_STRING];               /*Flawfinder: ignore*/
01805                         msg->getString("PropertiesData", "CharterMember", MAX_STRING, caption);
01806                         caption_text = caption;
01807                 }
01808                 
01809 
01810                 if(caption_text.empty())
01811                 {
01812                         LLString::format_map_t args;
01813                         caption_text = self->mPanelSecondLife->getString("CaptionTextAcctInfo");
01814                         
01815                         const char* ACCT_TYPE[] = {
01816                                 "AcctTypeResident",
01817                                 "AcctTypeTrial",
01818                                 "AcctTypeCharterMember",
01819                                 "AcctTypeEmployee"
01820                         };
01821                         caption_index = llclamp(caption_index, (U8)0, (U8)(sizeof(ACCT_TYPE)/sizeof(ACCT_TYPE[0])-1));
01822                         args["[ACCTTYPE]"] = self->mPanelSecondLife->getString(ACCT_TYPE[caption_index]);
01823 
01824                         LLString payment_text = " ";
01825                         const S32 DEFAULT_CAPTION_LINDEN_INDEX = 3;
01826                         if(caption_index != DEFAULT_CAPTION_LINDEN_INDEX)
01827                         {                       
01828                                 if(transacted)
01829                                 {
01830                                         payment_text = "PaymentInfoUsed";
01831                                 }
01832                                 else if (identified)
01833                                 {
01834                                         payment_text = "PaymentInfoOnFile";
01835                                 }
01836                                 else
01837                                 {
01838                                         payment_text = "NoPaymentInfoOnFile";
01839                                 }
01840                                 args["[PAYMENTINFO]"] = self->mPanelSecondLife->getString(payment_text);
01841                                 LLString age_text = age_verified ? "AgeVerified" : "NotAgeVerified";
01842                                 // Do not display age verification status at this time
01843                                 //args["[AGEVERIFICATION]"] = self->mPanelSecondLife->getString(age_text);
01844                                 args["[AGEVERIFICATION]"] = " ";
01845                         }
01846                         else
01847                         {
01848                                 args["[PAYMENTINFO]"] = " ";
01849                                 args["[AGEVERIFICATION]"] = " ";
01850                         }
01851                         LLString::format(caption_text, args);
01852                 }
01853                 
01854                 self->mPanelSecondLife->childSetValue("acct", caption_text);
01855                 self->mPanelSecondLife->childSetValue("born", born_on);
01856 
01857                 EOnlineStatus online_status = (online) ? ONLINE_STATUS_YES : ONLINE_STATUS_NO;
01858 
01859                 self->setOnlineStatus(online_status);
01860 
01861                 self->mPanelWeb->setWebURL(std::string(profile_url));
01862 
01863                 LLTextureCtrl*  image_ctrl = self->mPanelSecondLife->getChild<LLTextureCtrl>("img");
01864                 if(image_ctrl)
01865                 {
01866                         image_ctrl->setImageAssetID(image_id);
01867                 }
01868                 self->childSetValue("about", about_text);
01869 
01870                 self->mPanelSecondLife->setPartnerID(partner_id);
01871                 self->mPanelSecondLife->updatePartnerName();
01872 
01873                 if (self->mPanelFirstLife)
01874                 {
01875                         // Teens don't get these
01876                         self->mPanelFirstLife->childSetValue("about", fl_about_text);
01877                         LLTextureCtrl*  image_ctrl = self->mPanelFirstLife->getChild<LLTextureCtrl>("img");
01878                         if(image_ctrl)
01879                         {
01880                                 image_ctrl->setImageAssetID(fl_image_id);
01881                         }
01882 
01883                         self->mPanelSecondLife->childSetValue("allow_publish", allow_publish);
01884 
01885                 }
01886         }
01887 }
01888 
01889 // static
01890 void LLPanelAvatar::processAvatarInterestsReply(LLMessageSystem *msg, void**)
01891 {
01892         LLUUID  agent_id;       // your id
01893         LLUUID  avatar_id;      // target of this panel
01894 
01895         U32             want_to_mask;
01896         char    want_to_text[DB_USER_WANT_TO_BUF_SIZE];         /*Flawfinder: ignore*/
01897         U32             skills_mask;
01898         char    skills_text[DB_USER_SKILLS_BUF_SIZE];           /*Flawfinder: ignore*/
01899         char    languages_text[DB_USER_SKILLS_BUF_SIZE];                /*Flawfinder: ignore*/
01900 
01901         //llinfos << "properties packet size " << msg->getReceiveSize() << llendl;
01902 
01903         msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_AgentID, agent_id);
01904         msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_AvatarID, avatar_id );
01905 
01906         for (panel_list_t::iterator iter = sAllPanels.begin(); iter != sAllPanels.end(); ++iter)
01907         {
01908                 LLPanelAvatar* self = *iter;
01909                 if (self->mAvatarID != avatar_id)
01910                 {
01911                         continue;
01912                 }
01913 
01914                 msg->getU32Fast(   _PREHASH_PropertiesData,     _PREHASH_WantToMask,    want_to_mask );
01915                 msg->getStringFast(_PREHASH_PropertiesData, _PREHASH_WantToText,        DB_USER_WANT_TO_BUF_SIZE,       want_to_text );
01916                 msg->getU32Fast(   _PREHASH_PropertiesData,     _PREHASH_SkillsMask,    skills_mask );
01917                 msg->getStringFast(_PREHASH_PropertiesData, _PREHASH_SkillsText,        DB_USER_SKILLS_BUF_SIZE,        skills_text );
01918                 msg->getString(_PREHASH_PropertiesData, "LanguagesText",        DB_USER_SKILLS_BUF_SIZE,        languages_text );
01919 
01920                 self->mPanelAdvanced->setWantSkills(want_to_mask, want_to_text, skills_mask, skills_text, languages_text);
01921         }
01922 }
01923 
01924 // Separate function because the groups list can be very long, almost
01925 // filling a packet. JC
01926 // static
01927 void LLPanelAvatar::processAvatarGroupsReply(LLMessageSystem *msg, void**)
01928 {
01929         LLUUID  agent_id;       // your id
01930         LLUUID  avatar_id;      // target of this panel
01931         U64             group_powers;
01932         char    group_title[DB_GROUP_TITLE_BUF_SIZE];           /*Flawfinder: ignore*/
01933         LLUUID  group_id;
01934         char    group_name[DB_GROUP_NAME_BUF_SIZE];             /*Flawfinder: ignore*/
01935         LLUUID  group_insignia_id;
01936 
01937         llinfos << "groups packet size " << msg->getReceiveSize() << llendl;
01938 
01939         msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_AgentID, agent_id);
01940         msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_AvatarID, avatar_id );
01941 
01942         for (panel_list_t::iterator iter = sAllPanels.begin(); iter != sAllPanels.end(); ++iter)
01943         {
01944                 LLPanelAvatar* self = *iter;
01945                 if (self->mAvatarID != avatar_id)
01946                 {
01947                         continue;
01948                 }
01949                 
01950                 LLScrollListCtrl*       group_list = self->mPanelSecondLife->getChild<LLScrollListCtrl>("groups"); 
01951 //              if(group_list)
01952 //              {
01953 //                      group_list->deleteAllItems();
01954 //              }
01955                 
01956                 S32 group_count = msg->getNumberOfBlocksFast(_PREHASH_GroupData);
01957                 if (0 == group_count)
01958                 {
01959                         if(group_list) group_list->addCommentText("None");
01960                 }
01961                 else
01962                 {
01963                         for(S32 i = 0; i < group_count; ++i)
01964                         {
01965                                 msg->getU64(    _PREHASH_GroupData, "GroupPowers",      group_powers, i );
01966                                 msg->getStringFast(_PREHASH_GroupData, _PREHASH_GroupTitle,     DB_GROUP_TITLE_BUF_SIZE,        group_title, i );
01967                                 msg->getUUIDFast(  _PREHASH_GroupData, _PREHASH_GroupID,                group_id, i);
01968                                 msg->getStringFast(_PREHASH_GroupData, _PREHASH_GroupName,      DB_GROUP_NAME_BUF_SIZE,         group_name, i );
01969                                 msg->getUUIDFast(  _PREHASH_GroupData, _PREHASH_GroupInsigniaID, group_insignia_id, i );
01970 
01971                                 LLString group_string;
01972                                 if (group_id.notNull())
01973                                 {
01974                                         group_string.assign(group_name);
01975                                 }
01976                                 else
01977                                 {
01978                                         group_string.assign("");
01979                                 }
01980 
01981                                 // Is this really necessary?  Remove existing entry if it exists.
01982                                 // TODO: clear the whole list when a request for data is made
01983                                 if (group_list)
01984                                 {
01985                                         S32 index = group_list->getItemIndex(group_id);
01986                                         if ( index >= 0 )
01987                                         {
01988                                                 group_list->deleteSingleItem(index);
01989                                         }
01990                                 }
01991 
01992                                 LLSD row;
01993                                 row["id"] = group_id;
01994                                 row["columns"][0]["value"] = group_string;
01995                                 row["columns"][0]["font"] = "SANSSERIF_SMALL";
01996                                 if (group_list)
01997                                 {
01998                                         group_list->addElement(row);
01999                                 }
02000                         }
02001                 }
02002                 if(group_list) group_list->sortByColumn(0, TRUE);
02003         }
02004 }
02005 
02006 // Don't enable the OK button until you actually have the data.
02007 // Otherwise you will write blanks back into the database.
02008 void LLPanelAvatar::enableOKIfReady()
02009 {
02010         if(mHaveProperties && childIsVisible("OK"))
02011         {
02012                 childSetEnabled("OK", TRUE);
02013         }
02014         else
02015         {
02016                 childSetEnabled("OK", FALSE);
02017         }
02018 }
02019 
02020 void LLPanelAvatar::sendAvatarPropertiesUpdate()
02021 {
02022         llinfos << "Sending avatarinfo update" << llendl;
02023         BOOL allow_publish = FALSE;
02024         BOOL mature = FALSE;
02025         if (LLPanelAvatar::sAllowFirstLife)
02026         {
02027                 allow_publish = childGetValue("allow_publish");
02028                 //A profile should never be mature.
02029                 mature = FALSE;
02030         }
02031         U32 want_to_mask = 0x0;
02032         U32 skills_mask = 0x0;
02033         std::string want_to_text;
02034         std::string skills_text;
02035         std::string languages_text;
02036         mPanelAdvanced->getWantSkills(&want_to_mask, want_to_text, &skills_mask, skills_text, languages_text);
02037 
02038         LLUUID first_life_image_id;
02039         LLString first_life_about_text;
02040         if (mPanelFirstLife)
02041         {
02042                 first_life_about_text = mPanelFirstLife->childGetValue("about").asString();
02043                 LLTextureCtrl*  image_ctrl = mPanelFirstLife->getChild<LLTextureCtrl>("img");
02044                 if(image_ctrl)
02045                 {
02046                         first_life_image_id = image_ctrl->getImageAssetID();
02047                 }
02048         }
02049 
02050         LLString about_text = mPanelSecondLife->childGetValue("about").asString();
02051 
02052         LLMessageSystem *msg = gMessageSystem;
02053 
02054         msg->newMessageFast(_PREHASH_AvatarPropertiesUpdate);
02055         msg->nextBlockFast(_PREHASH_AgentData);
02056         msg->addUUIDFast(       _PREHASH_AgentID,               gAgent.getID() );
02057         msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID() );
02058         msg->nextBlockFast(_PREHASH_PropertiesData);
02059         
02060         LLTextureCtrl*  image_ctrl = mPanelSecondLife->getChild<LLTextureCtrl>("img");
02061         if(image_ctrl)
02062         {
02063                 msg->addUUIDFast(       _PREHASH_ImageID,       image_ctrl->getImageAssetID());
02064         }
02065         else
02066         {
02067                 msg->addUUIDFast(       _PREHASH_ImageID,       LLUUID::null);
02068         }
02069 //      msg->addUUIDFast(       _PREHASH_ImageID,               mPanelSecondLife->mimage_ctrl->getImageAssetID()        );
02070         msg->addUUIDFast(       _PREHASH_FLImageID,             first_life_image_id);
02071         msg->addStringFast(     _PREHASH_AboutText,             about_text);
02072         msg->addStringFast(     _PREHASH_FLAboutText,   first_life_about_text);
02073 
02074         msg->addBOOL("AllowPublish", allow_publish);
02075         msg->addBOOL("MaturePublish", mature);
02076         msg->addString("ProfileURL", mPanelWeb->childGetText("url_edit"));
02077         gAgent.sendReliableMessage();
02078 
02079         msg->newMessage("AvatarInterestsUpdate");
02080         msg->nextBlockFast(_PREHASH_AgentData);
02081         msg->addUUIDFast(       _PREHASH_AgentID,               gAgent.getID() );
02082         msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID() );
02083         msg->nextBlockFast(_PREHASH_PropertiesData);
02084         msg->addU32Fast(        _PREHASH_WantToMask,    want_to_mask);
02085         msg->addStringFast(     _PREHASH_WantToText,    want_to_text);
02086         msg->addU32Fast(        _PREHASH_SkillsMask,    skills_mask);
02087         msg->addStringFast(     _PREHASH_SkillsText,    skills_text);
02088         msg->addString( "LanguagesText",                        languages_text);
02089         gAgent.sendReliableMessage();
02090 }
02091 
02092 void LLPanelAvatar::selectTab(S32 tabnum)
02093 {
02094         if(mTab)
02095         {
02096                 mTab->selectTab(tabnum);
02097         }
02098 }
02099 
02100 void LLPanelAvatar::selectTabByName(std::string tab_name)
02101 {
02102         if (mTab)
02103         {
02104                 if (tab_name.empty())
02105                 {
02106                         mTab->selectFirstTab();
02107                 }
02108                 else
02109                 {
02110                         mTab->selectTabByName(tab_name);
02111                 }
02112         }
02113 }
02114 
02115 
02116 void LLPanelAvatar::processAvatarNotesReply(LLMessageSystem *msg, void**)
02117 {
02118         // extract the agent id
02119         LLUUID agent_id;
02120         msg->getUUID("AgentData", "AgentID", agent_id);
02121 
02122         LLUUID target_id;
02123         msg->getUUID("Data", "TargetID", target_id);
02124 
02125         // look up all panels which have this avatar
02126         for (panel_list_t::iterator iter = sAllPanels.begin(); iter != sAllPanels.end(); ++iter)
02127         {
02128                 LLPanelAvatar* self = *iter;
02129                 if (self->mAvatarID != target_id)
02130                 {
02131                         continue;
02132                 }
02133 
02134                 char text[DB_USER_NOTE_SIZE];           /*Flawfinder: ignore*/
02135                 msg->getString("Data", "Notes", DB_USER_NOTE_SIZE, text);
02136                 self->childSetValue("notes edit", text);
02137                 self->childSetEnabled("notes edit", true);
02138                 self->mHaveNotes = true;
02139                 self->mLastNotes = text;
02140         }
02141 }
02142 
02143 
02144 void LLPanelAvatar::processAvatarClassifiedReply(LLMessageSystem *msg, void** userdata)
02145 {
02146         LLUUID agent_id;
02147         LLUUID target_id;
02148 
02149         msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_AgentID, agent_id);
02150         msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_TargetID, target_id);
02151 
02152         // look up all panels which have this avatar target
02153         for (panel_list_t::iterator iter = sAllPanels.begin(); iter != sAllPanels.end(); ++iter)
02154         {
02155                 LLPanelAvatar* self = *iter;
02156                 if (self->mAvatarID != target_id)
02157                 {
02158                         continue;
02159                 }
02160 
02161                 self->mPanelClassified->processAvatarClassifiedReply(msg, userdata);
02162         }
02163 }
02164 
02165 void LLPanelAvatar::processAvatarPicksReply(LLMessageSystem *msg, void** userdata)
02166 {
02167         LLUUID agent_id;
02168         LLUUID target_id;
02169 
02170         msg->getUUID("AgentData", "AgentID", agent_id);
02171         msg->getUUID("AgentData", "TargetID", target_id);
02172 
02173         // look up all panels which have this avatar target
02174         for (panel_list_t::iterator iter = sAllPanels.begin(); iter != sAllPanels.end(); ++iter)
02175         {
02176                 LLPanelAvatar* self = *iter;
02177                 if (self->mAvatarID != target_id)
02178                 {
02179                         continue;
02180                 }
02181 
02182                 self->mPanelPicks->processAvatarPicksReply(msg, userdata);
02183         }
02184 }
02185 
02186 // static
02187 void LLPanelAvatar::onClickKick(void* userdata)
02188 {
02189         LLPanelAvatar* self = (LLPanelAvatar*) userdata;
02190 
02191         S32 left, top;
02192         gFloaterView->getNewFloaterPosition(&left, &top);
02193         LLRect rect(left, top, left+400, top-300);
02194 
02195         gViewerWindow->alertXmlEditText("KickUser", LLString::format_map_t(),
02196                                                                         NULL, NULL,
02197                                                                         LLPanelAvatar::finishKick, self);
02198 }
02199 
02200 // static
02201 void LLPanelAvatar::finishKick(S32 option, const LLString& text, void* userdata)
02202 {
02203         LLPanelAvatar* self = (LLPanelAvatar*) userdata;
02204 
02205         if (option == 0)
02206         {
02207                 LLMessageSystem* msg = gMessageSystem;
02208 
02209                 msg->newMessageFast(_PREHASH_GodKickUser);
02210                 msg->nextBlockFast(_PREHASH_UserInfo);
02211                 msg->addUUIDFast(_PREHASH_GodID,                gAgent.getID() );
02212                 msg->addUUIDFast(_PREHASH_GodSessionID, gAgent.getSessionID());
02213                 msg->addUUIDFast(_PREHASH_AgentID,   self->mAvatarID );
02214                 msg->addU32("KickFlags", KICK_FLAGS_DEFAULT );
02215                 msg->addStringFast(_PREHASH_Reason,    text );
02216                 gAgent.sendReliableMessage();
02217         }
02218 }
02219 
02220 // static
02221 void LLPanelAvatar::onClickFreeze(void* userdata)
02222 {
02223         gViewerWindow->alertXmlEditText("FreezeUser", LLString::format_map_t(),
02224                                                                         NULL, NULL,
02225                                                                         LLPanelAvatar::finishFreeze, userdata);
02226 }
02227 
02228 // static
02229 void LLPanelAvatar::finishFreeze(S32 option, const LLString& text, void* userdata)
02230 {
02231         LLPanelAvatar* self = (LLPanelAvatar*) userdata;
02232 
02233         if (option == 0)
02234         {
02235                 LLMessageSystem* msg = gMessageSystem;
02236 
02237                 msg->newMessageFast(_PREHASH_GodKickUser);
02238                 msg->nextBlockFast(_PREHASH_UserInfo);
02239                 msg->addUUIDFast(_PREHASH_GodID,                gAgent.getID() );
02240                 msg->addUUIDFast(_PREHASH_GodSessionID, gAgent.getSessionID());
02241                 msg->addUUIDFast(_PREHASH_AgentID,   self->mAvatarID );
02242                 msg->addU32("KickFlags", KICK_FLAGS_FREEZE );
02243                 msg->addStringFast(_PREHASH_Reason,    text );
02244                 gAgent.sendReliableMessage();
02245         }
02246 }
02247 
02248 // static
02249 void LLPanelAvatar::onClickUnfreeze(void* userdata)
02250 {
02251         gViewerWindow->alertXmlEditText("UnFreezeUser", LLString::format_map_t(),
02252                                                                         NULL, NULL,
02253                                                                         LLPanelAvatar::finishUnfreeze, userdata);
02254 }
02255 
02256 // static
02257 void LLPanelAvatar::finishUnfreeze(S32 option, const LLString& text, void* userdata)
02258 {
02259         LLPanelAvatar* self = (LLPanelAvatar*) userdata;
02260 
02261         if (option == 0)
02262         {
02263                 LLMessageSystem* msg = gMessageSystem;
02264 
02265                 msg->newMessageFast(_PREHASH_GodKickUser);
02266                 msg->nextBlockFast(_PREHASH_UserInfo);
02267                 msg->addUUIDFast(_PREHASH_GodID,                gAgent.getID() );
02268                 msg->addUUIDFast(_PREHASH_GodSessionID, gAgent.getSessionID());
02269                 msg->addUUIDFast(_PREHASH_AgentID,   self->mAvatarID );
02270                 msg->addU32("KickFlags", KICK_FLAGS_UNFREEZE );
02271                 msg->addStringFast(_PREHASH_Reason,    text );
02272                 gAgent.sendReliableMessage();
02273         }
02274 }
02275 
02276 // static
02277 void LLPanelAvatar::onClickCSR(void* userdata)
02278 {
02279         LLPanelAvatar* self = (LLPanelAvatar*)userdata;
02280         if (!self) return;
02281         
02282         LLNameEditor* name_edit = self->getChild<LLNameEditor>("name");
02283         if (!name_edit) return;
02284 
02285         LLString name = name_edit->getText();
02286         if (name.empty()) return;
02287         
02288         LLString url = "http://csr.lindenlab.com/agent/";
02289         
02290         // slow and stupid, but it's late
02291         S32 len = name.length();
02292         for (S32 i = 0; i < len; i++)
02293         {
02294                 if (name[i] == ' ')
02295                 {
02296                         url += "%20";
02297                 }
02298                 else
02299                 {
02300                         url += name[i];
02301                 }
02302         }
02303         
02304         LLWeb::loadURL(url);
02305 }
02306 
02307 
02308 void*   LLPanelAvatar::createPanelAvatarSecondLife(void* data)
02309 {
02310         LLPanelAvatar* self = (LLPanelAvatar*)data;
02311         self->mPanelSecondLife = new LLPanelAvatarSecondLife("2nd Life",LLRect(),self);
02312         return self->mPanelSecondLife;
02313 }
02314 
02315 void*   LLPanelAvatar::createPanelAvatarWeb(void*       data)
02316 {
02317         LLPanelAvatar* self = (LLPanelAvatar*)data;
02318         self->mPanelWeb = new LLPanelAvatarWeb("Web",LLRect(),self);
02319         return self->mPanelWeb;
02320 }
02321 
02322 void*   LLPanelAvatar::createPanelAvatarInterests(void* data)
02323 {
02324         LLPanelAvatar* self = (LLPanelAvatar*)data;
02325         self->mPanelAdvanced = new LLPanelAvatarAdvanced("Interests",LLRect(),self);
02326         return self->mPanelAdvanced;
02327 }
02328 
02329 
02330 void*   LLPanelAvatar::createPanelAvatarPicks(void*     data)
02331 {
02332         LLPanelAvatar* self = (LLPanelAvatar*)data;
02333         self->mPanelPicks = new LLPanelAvatarPicks("Picks",LLRect(),self);
02334         return self->mPanelPicks;
02335 }
02336 
02337 void*   LLPanelAvatar::createPanelAvatarClassified(void* data)
02338 {
02339         LLPanelAvatar* self = (LLPanelAvatar*)data;
02340         self->mPanelClassified = new LLPanelAvatarClassified("Classified",LLRect(),self);
02341         return self->mPanelClassified;
02342 }
02343 
02344 void*   LLPanelAvatar::createPanelAvatarFirstLife(void* data)
02345 {
02346         LLPanelAvatar* self = (LLPanelAvatar*)data;
02347         self->mPanelFirstLife = new LLPanelAvatarFirstLife("1st Life", LLRect(), self);
02348         return self->mPanelFirstLife;
02349 }
02350 
02351 void*   LLPanelAvatar::createPanelAvatarNotes(void*     data)
02352 {
02353         LLPanelAvatar* self = (LLPanelAvatar*)data;
02354         self->mPanelNotes = new LLPanelAvatarNotes("My Notes",LLRect(),self);
02355         return self->mPanelNotes;
02356 }
Generated on Fri May 16 08:33:49 2008 for SecondLife by  doxygen 1.5.5