llinventoryactions.cpp

Go to the documentation of this file.
00001 
00032 #include "llviewerprecompiledheaders.h"
00033 
00034 #include <utility> // for std::pair<>
00035 
00036 #include "llinventoryview.h"
00037 #include "llpanelinventory.h"
00038 #include "llinventorybridge.h"
00039 
00040 #include "message.h"
00041 
00042 #include "llagent.h"
00043 #include "llcallingcard.h"
00044 #include "llcheckboxctrl.h"             // for radio buttons
00045 #include "llradiogroup.h"
00046 #include "llspinctrl.h"
00047 #include "lltextbox.h"
00048 #include "llui.h"
00049 
00050 #include "llviewercontrol.h"
00051 #include "llfirstuse.h"
00052 #include "llfloateravatarinfo.h"
00053 #include "llfloaterchat.h"
00054 #include "llfloatercustomize.h"
00055 #include "llfloaterproperties.h"
00056 #include "llfocusmgr.h"
00057 #include "llfolderview.h"
00058 #include "llgesturemgr.h"
00059 #include "lliconctrl.h"
00060 #include "llinventorymodel.h"
00061 #include "llinventoryclipboard.h"
00062 #include "lllineeditor.h"
00063 #include "llmenugl.h"
00064 #include "llpreviewanim.h"
00065 #include "llpreviewgesture.h"
00066 #include "llpreviewlandmark.h"
00067 #include "llpreviewnotecard.h"
00068 #include "llpreviewscript.h"
00069 #include "llpreviewsound.h"
00070 #include "llpreviewtexture.h"
00071 #include "llresmgr.h"
00072 #include "llscrollcontainer.h"
00073 #include "llimview.h"
00074 #include "lltooldraganddrop.h"
00075 #include "llviewerimagelist.h"
00076 #include "llviewerinventory.h"
00077 #include "llviewerobjectlist.h"
00078 #include "llviewerwindow.h"
00079 #include "llwearable.h"
00080 #include "llwearablelist.h"
00081 #include "viewer.h"
00082 #include "llviewermessage.h" 
00083 #include "llviewerregion.h"
00084 #include "lltabcontainer.h"
00085 #include "llvieweruictrlfactory.h"
00086 #include "llselectmgr.h"
00087 
00088 const char* NEW_LSL_NAME = "New Script"; // *TODO:Translate? (probably not)
00089 const char* NEW_NOTECARD_NAME = "New Note"; // *TODO:Translate? (probably not)
00090 const char* NEW_GESTURE_NAME = "New Gesture"; // *TODO:Translate? (probably not)
00091 
00092 typedef LLMemberListener<LLPanelInventory> object_inventory_listener_t;
00093 typedef LLMemberListener<LLInventoryView> inventory_listener_t;
00094 typedef LLMemberListener<LLInventoryPanel> inventory_panel_listener_t;
00095 
00096 bool doToSelected(LLFolderView* folder, LLString action)
00097 {
00098         LLInventoryModel* model = &gInventory;
00099         if ("rename" == action)
00100         {
00101                 folder->startRenamingSelectedItem();
00102                 return true;
00103         }
00104         if ("delete" == action)
00105         {
00106                 folder->removeSelectedItems();
00107                 return true;
00108         }
00109 
00110         if ("copy" == action)
00111         {       
00112                 LLInventoryClipboard::instance().reset();
00113         }
00114 
00115         std::set<LLUUID> selected_items;
00116         folder->getSelectionList(selected_items);
00117 
00118         LLMultiPreview* multi_previewp = NULL;
00119         LLMultiProperties* multi_propertiesp = NULL;
00120 
00121         if (("task_open" == action  || "open" == action) && selected_items.size() > 1)
00122         {
00123                 S32 left, top;
00124                 gFloaterView->getNewFloaterPosition(&left, &top);
00125 
00126                 multi_previewp = new LLMultiPreview(LLRect(left, top, left + 300, top - 100));
00127                 gFloaterView->addChild(multi_previewp);
00128 
00129                 LLFloater::setFloaterHost(multi_previewp);
00130         
00131         }
00132         else if (("task_properties" == action || "properties" == action) && selected_items.size() > 1)
00133         {
00134                 S32 left, top;
00135                 gFloaterView->getNewFloaterPosition(&left, &top);
00136 
00137                 multi_propertiesp = new LLMultiProperties(LLRect(left, top, left + 100, top - 100));
00138                 gFloaterView->addChild(multi_propertiesp);
00139 
00140                 LLFloater::setFloaterHost(multi_propertiesp);
00141         }
00142 
00143         std::set<LLUUID>::iterator set_iter;
00144 
00145         for (set_iter = selected_items.begin(); set_iter != selected_items.end(); ++set_iter)
00146         {
00147                 LLFolderViewItem* folder_item = folder->getItemByID(*set_iter);
00148                 if(!folder_item) continue;
00149                 LLInvFVBridge* bridge = (LLInvFVBridge*)folder_item->getListener();
00150                 if(!bridge) continue;
00151 
00152                 bridge->performAction(folder, model, action);
00153         }
00154 
00155         LLFloater::setFloaterHost(NULL);
00156         if (multi_previewp)
00157         {
00158                 multi_previewp->open();
00159         }
00160         else if (multi_propertiesp)
00161         {
00162                 multi_propertiesp->open();              /*Flawfinder: ignore*/
00163         }
00164 
00165         return true;
00166 }
00167 
00168 class LLDoToSelectedPanel : public object_inventory_listener_t
00169 {
00170         bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
00171         {
00172                 LLString action = userdata.asString();
00173                 LLPanelInventory *panel = mPtr;
00174                 LLFolderView* folder = panel->getRootFolder();
00175                 if(!folder) return true;
00176 
00177                 return doToSelected(folder, action);
00178         }
00179 };
00180 
00181 class LLDoToSelectedFloater : public inventory_listener_t
00182 {
00183         bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
00184         {
00185                 LLString action = userdata.asString();
00186                 LLInventoryPanel *panel = mPtr->getPanel();
00187                 LLFolderView* folder = panel->getRootFolder();
00188                 if(!folder) return true;
00189 
00190                 return doToSelected(folder, action);
00191         }
00192 };
00193 
00194 class LLDoToSelected : public inventory_panel_listener_t
00195 {
00196         bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
00197         {
00198                 LLString action = userdata.asString();
00199                 LLInventoryPanel *panel = mPtr;
00200                 LLFolderView* folder = panel->getRootFolder();
00201                 if(!folder) return true;
00202 
00203                 return doToSelected(folder, action);
00204         }
00205 };
00206 
00207 class LLNewWindow : public inventory_listener_t
00208 {
00209         bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
00210         {
00211                 LLRect rect(gSavedSettings.getRect("FloaterInventoryRect"));
00212                 S32 left = 0 , top = 0;
00213                 gFloaterView->getNewFloaterPosition(&left, &top);
00214                 rect.setLeftTopAndSize(left, top, rect.getWidth(), rect.getHeight());
00215                 LLInventoryView* iv = new LLInventoryView("Inventory",
00216                                                                                                 rect,
00217                                                                                                 mPtr->getActivePanel()->getModel());
00218                 iv->getActivePanel()->setFilterTypes(mPtr->getActivePanel()->getFilterTypes());
00219                 iv->getActivePanel()->setFilterSubString(mPtr->getActivePanel()->getFilterSubString());
00220                 iv->open();             /*Flawfinder: ignore*/
00221 
00222                 // force onscreen
00223                 gFloaterView->adjustToFitScreen(iv, FALSE);
00224                 return true;
00225         }
00226 };
00227 
00228 class LLShowFilters : public inventory_listener_t
00229 {
00230         bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
00231         {
00232                 mPtr->toggleFindOptions();
00233                 return true;
00234         }
00235 };
00236 
00237 class LLResetFilter : public inventory_listener_t
00238 {
00239         bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
00240         {
00241                 LLInventoryViewFinder *finder = mPtr->getFinder();
00242                 mPtr->getActivePanel()->getFilter()->resetDefault();
00243                 if (finder)
00244                 {
00245                         finder->updateElementsFromFilter();
00246                 }
00247 
00248                 mPtr->setFilterTextFromFilter();
00249                 return true;
00250         }
00251 };
00252 
00253 class LLCloseAllFolders : public inventory_panel_listener_t
00254 {
00255         bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
00256         {
00257                 mPtr->closeAllFolders();
00258                 return true;
00259         }
00260 };
00261 
00262 class LLCloseAllFoldersFloater : public inventory_listener_t
00263 {
00264         bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
00265         {
00266                 mPtr->getPanel()->closeAllFolders();
00267                 return true;
00268         }
00269 };
00270 
00271 class LLEmptyTrash : public inventory_panel_listener_t
00272 {
00273         bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
00274         {
00275                 LLInventoryModel* model = mPtr->getModel();
00276                 if(!model) return false;
00277                 gViewerWindow->alertXml("ConfirmEmptyTrash", callback_empty_trash, this);
00278                 return true;
00279         }
00280 
00281         static void callback_empty_trash(S32 option, void* userdata)
00282         {
00283                 LLEmptyTrash* empty_trash = (LLEmptyTrash*)userdata;
00284                 if (option == 0) // YES
00285                 {
00286                         LLInventoryModel* model = empty_trash->mPtr->getModel();
00287                         LLUUID trash_id = model->findCategoryUUIDForType(LLAssetType::AT_TRASH);
00288                         model->purgeDescendentsOf(trash_id);
00289                         model->notifyObservers();
00290                 }
00291         }
00292 };
00293 
00294 class LLEmptyLostAndFound : public inventory_panel_listener_t
00295 {
00296         bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
00297         {
00298                 LLInventoryModel* model = mPtr->getModel();
00299                 if(!model) return false;
00300                 gViewerWindow->alertXml("ConfirmEmptyLostAndFound", callback_empty_lost_and_found, this);
00301                 return true;
00302         }
00303 
00304         static void callback_empty_lost_and_found(S32 option, void* userdata)
00305         {
00306                 LLEmptyLostAndFound* empty_lost_and_found = (LLEmptyLostAndFound*)userdata;
00307                 if (option == 0) // YES
00308                 {
00309                         LLInventoryModel* model = empty_lost_and_found->mPtr->getModel();
00310                         LLUUID lost_and_found_id = model->findCategoryUUIDForType(LLAssetType::AT_LOST_AND_FOUND);
00311                         model->purgeDescendentsOf(lost_and_found_id);
00312                         model->notifyObservers();
00313                 }
00314         }
00315 };
00316 
00317 class LLEmptyTrashFloater : public inventory_listener_t
00318 {
00319         bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
00320         {
00321                 LLInventoryModel* model = mPtr->getPanel()->getModel();
00322                 if(!model) return false;
00323                 LLUUID trash_id = model->findCategoryUUIDForType(LLAssetType::AT_TRASH);
00324                 model->purgeDescendentsOf(trash_id);
00325                 model->notifyObservers();
00326                 return true;
00327         }
00328 };
00329 
00330 void do_create(LLInventoryModel *model, LLInventoryPanel *ptr, LLString type, LLFolderBridge *self = NULL)
00331 {
00332         if ("category" == type)
00333         {
00334                 LLUUID category;
00335                 if (self)
00336                 {
00337                         category = model->createNewCategory(self->getUUID(), LLAssetType::AT_NONE, NULL);
00338                 }
00339                 else
00340                 {
00341                         category = model->createNewCategory(gAgent.getInventoryRootID(),
00342                                                                         LLAssetType::AT_NONE, NULL);
00343                 }
00344                 model->notifyObservers();
00345                 ptr->setSelection(category, TRUE);
00346         }
00347         else if ("lsl" == type)
00348         {
00349                 LLUUID parent_id = self ? self->getUUID() : model->findCategoryUUIDForType(LLAssetType::AT_LSL_TEXT);
00350                 ptr->createNewItem(NEW_LSL_NAME,
00351                                                         parent_id,
00352                                                         LLAssetType::AT_LSL_TEXT,
00353                                                         LLInventoryType::IT_LSL,
00354                                                         PERM_MOVE | PERM_TRANSFER);
00355         }
00356         else if ("notecard" == type)
00357         {
00358                 LLUUID parent_id = self ? self->getUUID() : model->findCategoryUUIDForType(LLAssetType::AT_NOTECARD);
00359                 ptr->createNewItem(NEW_NOTECARD_NAME,
00360                                                         parent_id,
00361                                                         LLAssetType::AT_NOTECARD,
00362                                                         LLInventoryType::IT_NOTECARD,
00363                                                         PERM_ALL);
00364         }
00365         else if ("gesture" == type)
00366         {
00367                 LLUUID parent_id = self ? self->getUUID() : model->findCategoryUUIDForType(LLAssetType::AT_GESTURE);
00368                 ptr->createNewItem(NEW_GESTURE_NAME,
00369                                                         parent_id,
00370                                                         LLAssetType::AT_GESTURE,
00371                                                         LLInventoryType::IT_GESTURE,
00372                                                         PERM_ALL);
00373         }
00374         else if ("shirt" == type)
00375         {
00376                 LLUUID parent_id = self ? self->getUUID() : gInventory.findCategoryUUIDForType(LLAssetType::AT_CLOTHING);
00377                 LLFolderBridge::createWearable(parent_id, WT_SHIRT);
00378         }
00379         else if ("pants" == type)
00380         {
00381                 LLUUID parent_id = self ? self->getUUID() : gInventory.findCategoryUUIDForType(LLAssetType::AT_CLOTHING);
00382                 LLFolderBridge::createWearable(parent_id, WT_PANTS);
00383         }
00384         else if ("shoes" == type)
00385         {
00386                 LLUUID parent_id = self ? self->getUUID() : gInventory.findCategoryUUIDForType(LLAssetType::AT_CLOTHING);
00387                 LLFolderBridge::createWearable(parent_id, WT_SHOES);
00388         }
00389         else if ("socks" == type)
00390         {
00391                 LLUUID parent_id = self ? self->getUUID() : gInventory.findCategoryUUIDForType(LLAssetType::AT_CLOTHING);
00392                 LLFolderBridge::createWearable(parent_id, WT_SOCKS);
00393         }
00394         else if ("jacket" == type)
00395         {
00396                 LLUUID parent_id = self ? self->getUUID() : gInventory.findCategoryUUIDForType(LLAssetType::AT_CLOTHING);
00397                 LLFolderBridge::createWearable(parent_id, WT_JACKET);
00398         }
00399         else if ("skirt" == type)
00400         {
00401                 LLUUID parent_id = self ? self->getUUID() : gInventory.findCategoryUUIDForType(LLAssetType::AT_CLOTHING);
00402                 LLFolderBridge::createWearable(parent_id, WT_SKIRT);
00403         }
00404         else if ("gloves" == type)
00405         {
00406                 LLUUID parent_id = self ? self->getUUID() : gInventory.findCategoryUUIDForType(LLAssetType::AT_CLOTHING);
00407                 LLFolderBridge::createWearable(parent_id, WT_GLOVES);
00408         }
00409         else if ("undershirt" == type)
00410         {
00411                 LLUUID parent_id = self ? self->getUUID() : gInventory.findCategoryUUIDForType(LLAssetType::AT_CLOTHING);
00412                 LLFolderBridge::createWearable(parent_id, WT_UNDERSHIRT);
00413         }
00414         else if ("underpants" == type)
00415         {
00416                 LLUUID parent_id = self ? self->getUUID() : gInventory.findCategoryUUIDForType(LLAssetType::AT_CLOTHING);
00417                 LLFolderBridge::createWearable(parent_id, WT_UNDERPANTS);
00418         }
00419         else if ("shape" == type)
00420         {
00421                 LLUUID parent_id = self ? self->getUUID() : gInventory.findCategoryUUIDForType(LLAssetType::AT_BODYPART);
00422                 LLFolderBridge::createWearable(parent_id, WT_SHAPE);
00423         }
00424         else if ("skin" == type)
00425         {
00426                 LLUUID parent_id = self ? self->getUUID() : gInventory.findCategoryUUIDForType(LLAssetType::AT_BODYPART);
00427                 LLFolderBridge::createWearable(parent_id, WT_SKIN);
00428         }
00429         else if ("hair" == type)
00430         {
00431                 LLUUID parent_id = self ? self->getUUID() : gInventory.findCategoryUUIDForType(LLAssetType::AT_BODYPART);
00432                 LLFolderBridge::createWearable(parent_id, WT_HAIR);
00433         }
00434         else if ("eyes" == type)
00435         {
00436                 LLUUID parent_id = self ? self->getUUID() : gInventory.findCategoryUUIDForType(LLAssetType::AT_BODYPART);
00437                 LLFolderBridge::createWearable(parent_id, WT_EYES);
00438         }
00439         
00440         ptr->getRootFolder()->setNeedsAutoRename(TRUE); 
00441 }
00442 
00443 class LLDoCreate : public inventory_panel_listener_t
00444 {
00445         bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
00446         {
00447                 LLInventoryModel* model = mPtr->getModel();
00448                 if(!model) return false;
00449                 LLString type = userdata.asString();
00450                 do_create(model, mPtr, type, LLFolderBridge::sSelf);
00451                 return true;
00452         }
00453 };
00454 
00455 class LLDoCreateFloater : public inventory_listener_t
00456 {
00457         bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
00458         {
00459                 LLInventoryModel* model = mPtr->getPanel()->getModel();
00460                 if(!model) return false;
00461                 LLString type = userdata.asString();
00462                 do_create(model, mPtr->getPanel(), type);
00463                 return true;
00464         }
00465 };
00466 
00467 class LLSetSortBy : public inventory_listener_t
00468 {
00469         bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
00470         {
00471                 LLString sort_field = userdata.asString();
00472                 if (sort_field == "name")
00473                 {
00474                         U32 order = mPtr->getActivePanel()->getSortOrder();
00475                         mPtr->getActivePanel()->setSortOrder( order & ~LLInventoryFilter::SO_DATE );
00476                         
00477                         mPtr->getControl("Inventory.SortByName")->setValue( TRUE );
00478                         mPtr->getControl("Inventory.SortByDate")->setValue( FALSE );
00479                 }
00480                 else if (sort_field == "date")
00481                 {
00482                         U32 order = mPtr->getActivePanel()->getSortOrder();
00483                         mPtr->getActivePanel()->setSortOrder( order | LLInventoryFilter::SO_DATE );
00484 
00485                         mPtr->getControl("Inventory.SortByName")->setValue( FALSE );
00486                         mPtr->getControl("Inventory.SortByDate")->setValue( TRUE );
00487                 }
00488                 else if (sort_field == "foldersalwaysbyname")
00489                 {
00490                         U32 order = mPtr->getActivePanel()->getSortOrder();
00491                         if ( order & LLInventoryFilter::SO_FOLDERS_BY_NAME )
00492                         {
00493                                 order &= ~LLInventoryFilter::SO_FOLDERS_BY_NAME;
00494 
00495                                 mPtr->getControl("Inventory.FoldersAlwaysByName")->setValue( FALSE );
00496                         }
00497                         else
00498                         {
00499                                 order |= LLInventoryFilter::SO_FOLDERS_BY_NAME;
00500 
00501                                 mPtr->getControl("Inventory.FoldersAlwaysByName")->setValue( TRUE );
00502                         }
00503                         mPtr->getActivePanel()->setSortOrder( order );
00504                 }
00505                 else if (sort_field == "systemfolderstotop")
00506                 {
00507                         U32 order = mPtr->getActivePanel()->getSortOrder();
00508                         if ( order & LLInventoryFilter::SO_SYSTEM_FOLDERS_TO_TOP )
00509                         {
00510                                 order &= ~LLInventoryFilter::SO_SYSTEM_FOLDERS_TO_TOP;
00511 
00512                                 mPtr->getControl("Inventory.SystemFoldersToTop")->setValue( FALSE );
00513                         }
00514                         else
00515                         {
00516                                 order |= LLInventoryFilter::SO_SYSTEM_FOLDERS_TO_TOP;
00517 
00518                                 mPtr->getControl("Inventory.SystemFoldersToTop")->setValue( TRUE );
00519                         }
00520                         mPtr->getActivePanel()->setSortOrder( order );
00521                 }
00522 
00523                 return true;
00524         }
00525 };
00526 
00527 class LLBeginIMSession : public inventory_panel_listener_t
00528 {
00529         bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
00530         {
00531                 LLInventoryPanel *panel = mPtr;
00532                 LLInventoryModel* model = panel->getModel();
00533                 if(!model) return true;
00534                 std::set<LLUUID> selected_items;
00535                 panel->getRootFolder()->getSelectionList(selected_items);
00536 
00537                 LLString name;
00538                 static int session_num = 1;
00539 
00540                 LLDynamicArray<LLUUID> members;
00541                 EInstantMessage type = IM_SESSION_CONFERENCE_START;
00542 
00543                 std::set<LLUUID>::const_iterator iter;
00544                 for (iter = selected_items.begin(); iter != selected_items.end(); iter++)
00545                 {
00546 
00547                         LLUUID item = *iter;
00548                         LLFolderViewItem* folder_item = panel->getRootFolder()->getItemByID(item);
00549                         
00550                         if(folder_item) 
00551                         {
00552                                 LLFolderViewEventListener* fve_listener = folder_item->getListener();
00553                                 if (fve_listener && (fve_listener->getInventoryType() == LLInventoryType::IT_CATEGORY))
00554                                 {
00555 
00556                                         LLFolderBridge* bridge = (LLFolderBridge*)folder_item->getListener();
00557                                         if(!bridge) return true;
00558                                         LLViewerInventoryCategory* cat = bridge->getCategory();
00559                                         if(!cat) return true;
00560                                         name = cat->getName();
00561                                         LLUniqueBuddyCollector is_buddy;
00562                                         LLInventoryModel::cat_array_t cat_array;
00563                                         LLInventoryModel::item_array_t item_array;
00564                                         model->collectDescendentsIf(bridge->getUUID(),
00565                                                                                                 cat_array,
00566                                                                                                 item_array,
00567                                                                                                 LLInventoryModel::EXCLUDE_TRASH,
00568                                                                                                 is_buddy);
00569                                         S32 count = item_array.count();
00570                                         if(count > 0)
00571                                         {
00572                                                 // create the session
00573                                                 gIMMgr->setFloaterOpen(TRUE);
00574                                                 S32 i;
00575                                                 
00576                                                 LLAvatarTracker& at = LLAvatarTracker::instance();
00577                                                 LLUUID id;
00578                                                 for(i = 0; i < count; ++i)
00579                                                 {
00580                                                         id = item_array.get(i)->getCreatorUUID();
00581                                                         if(at.isBuddyOnline(id))
00582                                                         {
00583                                                                 members.put(id);
00584                                                         }
00585                                                 }
00586                                         }
00587                                 }
00588                                 else
00589                                 {
00590                                         LLFolderViewItem* folder_item = panel->getRootFolder()->getItemByID(item);
00591                                         if(!folder_item) return true;
00592                                         LLInvFVBridge* listenerp = (LLInvFVBridge*)folder_item->getListener();
00593 
00594                                         if (listenerp->getInventoryType() == LLInventoryType::IT_CALLINGCARD)
00595                                         {
00596                                                 LLInventoryItem* inv_item = gInventory.getItem(listenerp->getUUID());
00597 
00598                                                 if (inv_item)
00599                                                 {
00600                                                         LLAvatarTracker& at = LLAvatarTracker::instance();
00601                                                         LLUUID id = inv_item->getCreatorUUID();
00602 
00603                                                         if(at.isBuddyOnline(id))
00604                                                         {
00605                                                                 members.put(id);
00606                                                         }
00607                                                 }
00608                                         } //if IT_CALLINGCARD
00609                                 } //if !IT_CATEGORY
00610                         }
00611                 } //for selected_items  
00612 
00613                 // the session_id is randomly generated UUID which will be replaced later
00614                 // with a server side generated number
00615 
00616                 if (name.empty())
00617                 {
00618                         char buffer [50];
00619                         sprintf(buffer, "Session %d", session_num++);
00620                         name = buffer;
00621                 }
00622 
00623 
00624                 gIMMgr->addSession(name,
00625                                                         type,
00626                                                         members[0],
00627                                                         members);
00628                 
00629                 return true;
00630         }
00631 };
00632 
00633 void rez_attachment(LLViewerInventoryItem* item, LLViewerJointAttachment* attachment);
00634 
00635 class LLAttachObject : public inventory_panel_listener_t
00636 {
00637         bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
00638         {
00639                 LLInventoryPanel *panel = mPtr;
00640                 LLFolderView* folder = panel->getRootFolder();
00641                 if(!folder) return true;
00642 
00643                 std::set<LLUUID> selected_items;
00644                 folder->getSelectionList(selected_items);
00645                 LLUUID id = *selected_items.begin();
00646 
00647                 LLString joint_name = userdata.asString();
00648                 LLVOAvatar *avatarp = gAgent.getAvatarObject();
00649                 LLViewerJointAttachment* attachmentp = NULL;
00650                 for (LLViewerJointAttachment* attachment = avatarp->mAttachmentPoints.getFirstData(); 
00651                         attachment;
00652                         attachment = gAgent.getAvatarObject()->mAttachmentPoints.getNextData())
00653                 {
00654                         if (attachment->getName() == joint_name)
00655                         {
00656                                 attachmentp = attachment;
00657                                 break;
00658                         }
00659                 }
00660                 if (attachmentp == NULL)
00661                 {
00662                         return true;
00663                 }
00664                 LLViewerInventoryItem* item = (LLViewerInventoryItem*)gInventory.getItem(id);
00665 
00666                 if(item && gInventory.isObjectDescendentOf(id, gAgent.getInventoryRootID()))
00667                 {
00668                         rez_attachment(item, attachmentp);
00669                 }
00670                 else if(item && item->isComplete())
00671                 {
00672                         // must be in library. copy it to our inventory and put it on.
00673                         LLPointer<LLInventoryCallback> cb = new RezAttachmentCallback(attachmentp);
00674                         copy_inventory_item(
00675                                 gAgent.getID(),
00676                                 item->getPermissions().getOwner(),
00677                                 item->getUUID(),
00678                                 LLUUID::null,
00679                                 std::string(),
00680                                 cb);
00681                 }
00682                 gFocusMgr.setKeyboardFocus(NULL, NULL);
00683 
00684                 return true;
00685         }
00686 };
00687 
00688 /*
00689 class LL : public listener_t
00690 {
00691         bool handleEvent(LLPointer<LLEvent> event, const LLSD& userdata)
00692         {
00693                 return true;
00694         }
00695 };
00696 */
00697 
00698 void init_object_inventory_panel_actions(LLPanelInventory *panel)
00699 {
00700         (new LLDoToSelectedPanel())->registerListener(panel, "Inventory.DoToSelected");
00701 }
00702 
00703 void init_inventory_actions(LLInventoryView *floater)
00704 {
00705         (new LLDoToSelectedFloater())->registerListener(floater, "Inventory.DoToSelected");
00706         (new LLCloseAllFoldersFloater())->registerListener(floater, "Inventory.CloseAllFolders");
00707         (new LLEmptyTrashFloater())->registerListener(floater, "Inventory.EmptyTrash");
00708         (new LLDoCreateFloater())->registerListener(floater, "Inventory.DoCreate");
00709 
00710         (new LLNewWindow())->registerListener(floater, "Inventory.NewWindow");
00711         (new LLShowFilters())->registerListener(floater, "Inventory.ShowFilters");
00712         (new LLResetFilter())->registerListener(floater, "Inventory.ResetFilter");
00713         (new LLSetSortBy())->registerListener(floater, "Inventory.SetSortBy");
00714 }
00715 
00716 void init_inventory_panel_actions(LLInventoryPanel *panel)
00717 {
00718         (new LLDoToSelected())->registerListener(panel, "Inventory.DoToSelected");
00719         (new LLAttachObject())->registerListener(panel, "Inventory.AttachObject");
00720         (new LLCloseAllFolders())->registerListener(panel, "Inventory.CloseAllFolders");
00721         (new LLEmptyTrash())->registerListener(panel, "Inventory.EmptyTrash");
00722         (new LLEmptyLostAndFound())->registerListener(panel, "Inventory.EmptyLostAndFound");
00723         (new LLDoCreate())->registerListener(panel, "Inventory.DoCreate");
00724         (new LLBeginIMSession())->registerListener(panel, "Inventory.BeginIMSession");
00725 }

Generated on Thu Jul 1 06:08:45 2010 for Second Life Viewer by  doxygen 1.4.7