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

Merge the work lost in 49c9461937df back into the tree

master
Bryan O'Sullivan 2009-11-04 15:14:54 -08:00
parent 0e63920569 b806edf4ac
commit fa3b57bd9f
126 changed files with 4475 additions and 2615 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
indra/llcommon/CMakeLists.txt
View File

@ -50,6 +50,7 @@ set(llcommon_SOURCE_FILES
llfile.cpp
llfindlocale.cpp
llfixedbuffer.cpp
llfoldertype.cpp
llformat.cpp
llframetimer.cpp
llheartbeat.cpp
@ -150,6 +151,7 @@ set(llcommon_HEADER_FILES
llfile.h
llfindlocale.h
llfixedbuffer.h
llfoldertype.h
llformat.h
llframetimer.h
llhash.h

150
indra/llcommon/llassettype.cpp
View File

@ -43,30 +43,21 @@
struct AssetEntry : public LLDictionaryEntry
{
AssetEntry(const char *desc_name,
const char *type_name, // 8 character limit!
const char *human_name, // for decoding to human readable form; put any and as many printable characters you want in each one
const char *category_name, // used by llinventorymodel when creating new categories
EDragAndDropType dad_type,
bool can_link, // can you create a link to this type?
bool is_protected) // can the viewer change categories of this type?
const char *type_name, // 8 character limit!
const char *human_name, // for decoding to human readable form; put any and as many printable characters you want in each one
bool can_link) // can you create a link to this type?
:
LLDictionaryEntry(desc_name),
mTypeName(type_name),
mHumanName(human_name),
mCategoryName(category_name),
mDadType(dad_type),
mCanLink(can_link),
mIsProtected(is_protected)
mCanLink(can_link)
{
llassert(strlen(mTypeName) <= 8);
}
const char *mTypeName;
const char *mHumanName;
const char *mCategoryName;
EDragAndDropType mDadType;
bool mCanLink;
bool mIsProtected;
};
class LLAssetDictionary : public LLSingleton<LLAssetDictionary>,
@ -78,48 +69,32 @@ public:
LLAssetDictionary::LLAssetDictionary()
{
// DESCRIPTION TYPE NAME HUMAN NAME CATEGORY NAME DRAG&DROP CAN LINK? PROTECTED?
// |--------------------|-----------|-------------------|-------------------|---------------|-----------|-----------|
addEntry(LLAssetType::AT_TEXTURE, new AssetEntry("TEXTURE", "texture", "texture", "Textures", DAD_TEXTURE, TRUE, TRUE));
addEntry(LLAssetType::AT_SOUND, new AssetEntry("SOUND", "sound", "sound", "Sounds", DAD_SOUND, TRUE, TRUE));
addEntry(LLAssetType::AT_CALLINGCARD, new AssetEntry("CALLINGCARD", "callcard", "calling card", "Calling Cards", DAD_CALLINGCARD, TRUE, TRUE));
addEntry(LLAssetType::AT_LANDMARK, new AssetEntry("LANDMARK", "landmark", "landmark", "Landmarks", DAD_LANDMARK, TRUE, TRUE));
addEntry(LLAssetType::AT_SCRIPT, new AssetEntry("SCRIPT", "script", "legacy script", "Scripts", DAD_NONE, TRUE, TRUE));
addEntry(LLAssetType::AT_CLOTHING, new AssetEntry("CLOTHING", "clothing", "clothing", "Clothing", DAD_CLOTHING, TRUE, TRUE));
addEntry(LLAssetType::AT_OBJECT, new AssetEntry("OBJECT", "object", "object", "Objects", DAD_OBJECT, TRUE, TRUE));
addEntry(LLAssetType::AT_NOTECARD, new AssetEntry("NOTECARD", "notecard", "note card", "Notecards", DAD_NOTECARD, TRUE, TRUE));
addEntry(LLAssetType::AT_CATEGORY, new AssetEntry("CATEGORY", "category", "folder", "New Folder", DAD_CATEGORY, TRUE, TRUE));
addEntry(LLAssetType::AT_ROOT_CATEGORY, new AssetEntry("ROOT_CATEGORY", "root", "root", "Inventory", DAD_ROOT_CATEGORY, TRUE, TRUE));
addEntry(LLAssetType::AT_LSL_TEXT, new AssetEntry("LSL_TEXT", "lsltext", "lsl2 script", "Scripts", DAD_SCRIPT, TRUE, TRUE));
addEntry(LLAssetType::AT_LSL_BYTECODE, new AssetEntry("LSL_BYTECODE", "lslbyte", "lsl bytecode", "Scripts", DAD_NONE, TRUE, TRUE));
addEntry(LLAssetType::AT_TEXTURE_TGA, new AssetEntry("TEXTURE_TGA", "txtr_tga", "tga texture", "Uncompressed Images", DAD_NONE, TRUE, TRUE));
addEntry(LLAssetType::AT_BODYPART, new AssetEntry("BODYPART", "bodypart", "body part", "Body Parts", DAD_BODYPART, TRUE, TRUE));
addEntry(LLAssetType::AT_TRASH, new AssetEntry("TRASH", "trash", "trash", "Trash", DAD_NONE, FALSE, TRUE));
addEntry(LLAssetType::AT_SNAPSHOT_CATEGORY, new AssetEntry("SNAPSHOT_CATEGORY", "snapshot", "snapshot", "Photo Album", DAD_NONE, FALSE, TRUE));
addEntry(LLAssetType::AT_LOST_AND_FOUND, new AssetEntry("LOST_AND_FOUND", "lstndfnd", "lost and found", "Lost And Found", DAD_NONE, FALSE, TRUE));
addEntry(LLAssetType::AT_SOUND_WAV, new AssetEntry("SOUND_WAV", "snd_wav", "sound", "Uncompressed SoundS", DAD_NONE, TRUE, TRUE));
addEntry(LLAssetType::AT_IMAGE_TGA, new AssetEntry("IMAGE_TGA", "img_tga", "targa image", "Uncompressed Images", DAD_NONE, TRUE, TRUE));
addEntry(LLAssetType::AT_IMAGE_JPEG, new AssetEntry("IMAGE_JPEG", "jpeg", "jpeg image", "Uncompressed Images", DAD_NONE, TRUE, TRUE));
addEntry(LLAssetType::AT_ANIMATION, new AssetEntry("ANIMATION", "animatn", "animation", "Animations", DAD_ANIMATION, TRUE, TRUE));
addEntry(LLAssetType::AT_GESTURE, new AssetEntry("GESTURE", "gesture", "gesture", "Gestures", DAD_GESTURE, TRUE, TRUE));
addEntry(LLAssetType::AT_SIMSTATE, new AssetEntry("SIMSTATE", "simstate", "simstate", "New Folder", DAD_NONE, FALSE, TRUE));
addEntry(LLAssetType::AT_FAVORITE, new AssetEntry("FAVORITE", "favorite", "favorite", "favorite", DAD_NONE, FALSE, TRUE));
// DESCRIPTION TYPE NAME HUMAN NAME CAN LINK?
// |--------------------|-----------|-------------------|-----------|
addEntry(LLAssetType::AT_TEXTURE, new AssetEntry("TEXTURE", "texture", "texture", FALSE));
addEntry(LLAssetType::AT_SOUND, new AssetEntry("SOUND", "sound", "sound", FALSE));
addEntry(LLAssetType::AT_CALLINGCARD, new AssetEntry("CALLINGCARD", "callcard", "calling card", FALSE));
addEntry(LLAssetType::AT_LANDMARK, new AssetEntry("LANDMARK", "landmark", "landmark", FALSE));
addEntry(LLAssetType::AT_SCRIPT, new AssetEntry("SCRIPT", "script", "legacy script", FALSE));
addEntry(LLAssetType::AT_CLOTHING, new AssetEntry("CLOTHING", "clothing", "clothing", TRUE));
addEntry(LLAssetType::AT_OBJECT, new AssetEntry("OBJECT", "object", "object", TRUE));
addEntry(LLAssetType::AT_NOTECARD, new AssetEntry("NOTECARD", "notecard", "note card", FALSE));
addEntry(LLAssetType::AT_CATEGORY, new AssetEntry("CATEGORY", "category", "folder", TRUE));
addEntry(LLAssetType::AT_LSL_TEXT, new AssetEntry("LSL_TEXT", "lsltext", "lsl2 script", FALSE));
addEntry(LLAssetType::AT_LSL_BYTECODE, new AssetEntry("LSL_BYTECODE", "lslbyte", "lsl bytecode", FALSE));
addEntry(LLAssetType::AT_TEXTURE_TGA, new AssetEntry("TEXTURE_TGA", "txtr_tga", "tga texture", FALSE));
addEntry(LLAssetType::AT_BODYPART, new AssetEntry("BODYPART", "bodypart", "body part", TRUE));
addEntry(LLAssetType::AT_SOUND_WAV, new AssetEntry("SOUND_WAV", "snd_wav", "sound", FALSE));
addEntry(LLAssetType::AT_IMAGE_TGA, new AssetEntry("IMAGE_TGA", "img_tga", "targa image", FALSE));
addEntry(LLAssetType::AT_IMAGE_JPEG, new AssetEntry("IMAGE_JPEG", "jpeg", "jpeg image", FALSE));
addEntry(LLAssetType::AT_ANIMATION, new AssetEntry("ANIMATION", "animatn", "animation", FALSE));
addEntry(LLAssetType::AT_GESTURE, new AssetEntry("GESTURE", "gesture", "gesture", TRUE));
addEntry(LLAssetType::AT_SIMSTATE, new AssetEntry("SIMSTATE", "simstate", "simstate", FALSE));
addEntry(LLAssetType::AT_LINK, new AssetEntry("LINK", "link", "symbolic link", "Link", DAD_LINK, FALSE, TRUE));
addEntry(LLAssetType::AT_LINK_FOLDER, new AssetEntry("FOLDER_LINK", "link_f", "symbolic folder link", "New Folder", DAD_LINK, FALSE, TRUE));
addEntry(LLAssetType::AT_LINK, new AssetEntry("LINK", "link", "symbolic link", FALSE));
addEntry(LLAssetType::AT_LINK_FOLDER, new AssetEntry("FOLDER_LINK", "link_f", "symbolic folder link", FALSE));
for (S32 ensemble_num = S32(LLAssetType::AT_FOLDER_ENSEMBLE_START);
ensemble_num <= S32(LLAssetType::AT_FOLDER_ENSEMBLE_END);
ensemble_num++)
{
addEntry(LLAssetType::EType(ensemble_num), new AssetEntry("ENSEMBLE", "ensemble", "ensemble", "New Folder", DAD_CATEGORY, FALSE, FALSE));
}
addEntry(LLAssetType::AT_CURRENT_OUTFIT, new AssetEntry("CURRENT", "current", "current outfit", "Current Look", DAD_CATEGORY, FALSE, TRUE));
addEntry(LLAssetType::AT_OUTFIT, new AssetEntry("OUTFIT", "outfit", "outfit", "New Look", DAD_CATEGORY, FALSE, FALSE));
addEntry(LLAssetType::AT_MY_OUTFITS, new AssetEntry("MY_OUTFITS", "my_otfts", "my outfits", "My Looks", DAD_CATEGORY, FALSE, TRUE));
addEntry(LLAssetType::AT_NONE, new AssetEntry("NONE", "-1", NULL, "New Folder", DAD_NONE, FALSE, FALSE));
addEntry(LLAssetType::AT_NONE, new AssetEntry("NONE", "-1", NULL, FALSE));
};
// static
@ -140,8 +115,7 @@ const std::string &LLAssetType::getDesc(LLAssetType::EType asset_type)
}
else
{
static const std::string error_string = "BAD TYPE";
return error_string;
return badLookup();
}
}
@ -156,7 +130,7 @@ const char *LLAssetType::lookup(LLAssetType::EType asset_type)
}
else
{
return "-1";
return badLookup().c_str();
}
}
@ -166,6 +140,7 @@ LLAssetType::EType LLAssetType::lookup(const char* name)
return lookup(ll_safe_string(name));
}
// static
LLAssetType::EType LLAssetType::lookup(const std::string& type_name)
{
const LLAssetDictionary *dict = LLAssetDictionary::getInstance();
@ -193,7 +168,7 @@ const char *LLAssetType::lookupHumanReadable(LLAssetType::EType asset_type)
}
else
{
return NULL;
return badLookup().c_str();
}
}
@ -203,6 +178,7 @@ LLAssetType::EType LLAssetType::lookupHumanReadable(const char* name)
return lookupHumanReadable(ll_safe_string(name));
}
// static
LLAssetType::EType LLAssetType::lookupHumanReadable(const std::string& readable_name)
{
const LLAssetDictionary *dict = LLAssetDictionary::getInstance();
@ -219,32 +195,6 @@ LLAssetType::EType LLAssetType::lookupHumanReadable(const std::string& readable_
return AT_NONE;
}
// static
const char *LLAssetType::lookupCategoryName(LLAssetType::EType asset_type)
{
const LLAssetDictionary *dict = LLAssetDictionary::getInstance();
const AssetEntry *entry = dict->lookup(asset_type);
if (entry)
{
return entry->mCategoryName;
}
else
{
return "New Folder";
}
}
// static
EDragAndDropType LLAssetType::lookupDragAndDropType(EType asset_type)
{
const LLAssetDictionary *dict = LLAssetDictionary::getInstance();
const AssetEntry *entry = dict->lookup(asset_type);
if (entry)
return entry->mDadType;
else
return DAD_NONE;
}
// static
bool LLAssetType::lookupCanLink(EType asset_type)
{
@ -269,37 +219,9 @@ bool LLAssetType::lookupIsLinkType(EType asset_type)
}
// static
// Only ensembles and plain folders aren't protected. "Protected" means
// you can't change certain properties such as their type.
bool LLAssetType::lookupIsProtectedCategoryType(EType asset_type)
const std::string &LLAssetType::badLookup()
{
const LLAssetDictionary *dict = LLAssetDictionary::getInstance();
const AssetEntry *entry = dict->lookup(asset_type);
if (entry)
{
return entry->mIsProtected;
}
return true;
}
static const std::string sBadLookup = "llassettype_bad_lookup";
return sBadLookup;
// static
bool LLAssetType::lookupIsEnsembleCategoryType(EType asset_type)
{
return (asset_type >= AT_FOLDER_ENSEMBLE_START &&
asset_type <= AT_FOLDER_ENSEMBLE_END);
}
// static. Generate a good default description
void LLAssetType::generateDescriptionFor(LLAssetType::EType asset_type,
std::string& description)
{
const S32 BUF_SIZE = 30;
char time_str[BUF_SIZE]; /* Flawfinder: ignore */
time_t now;
time(&now);
memset(time_str, '\0', BUF_SIZE);
strftime(time_str, BUF_SIZE - 1, "%Y-%m-%d %H:%M:%S ", localtime(&now));
description.assign(time_str);
description.append(LLAssetType::lookupHumanReadable(asset_type));
}

60
indra/llcommon/llassettype.h
View File

@ -94,18 +94,6 @@ public:
AT_BODYPART = 13,
// A collection of textures and parameters that can be worn by an avatar.
AT_TRASH = 14,
// Only to be used as a marker for a category preferred type.
// Using this, we can throw things in the trash before completely deleting.
AT_SNAPSHOT_CATEGORY = 15,
// A marker for a folder meant for snapshots.
// No actual assets will be snapshots, though if there were, you
// could interpret them as textures.
AT_LOST_AND_FOUND = 16,
// Used to stuff lost&found items into.
AT_SOUND_WAV = 17,
// Uncompressed sound.
@ -126,38 +114,22 @@ public:
AT_SIMSTATE = 22,
// Simstate file.
AT_FAVORITE = 23,
// favorite items
AT_LINK = 24,
// Inventory symbolic link
AT_LINK_FOLDER = 25,
// Inventory folder link
AT_FOLDER_ENSEMBLE_START = 26,
AT_FOLDER_ENSEMBLE_END = 45,
// This range is reserved for special clothing folder types.
AT_CURRENT_OUTFIT = 46,
// Current outfit
AT_OUTFIT = 47,
// Predefined outfit ("look")
AT_MY_OUTFITS = 48,
// Folder that holds your outfits.
AT_COUNT = 49,
AT_COUNT = 26,
// +*********************************************************+
// | TO ADD AN ELEMENT TO THIS ENUM: |
// +*********************************************************+
// | 1. INSERT BEFORE AT_COUNT |
// | 2. INCREMENT AT_COUNT BY 1 |
// | 3. ADD TO LLAssetDictionary in LLAssetType.cpp |
// | 3. ADD TO DEFAULT_ASSET_FOR_INV in LLInventoryType.cpp |
// | 3. ADD TO LLAssetType.cpp |
// | 4. ADD TO LLViewerAssetType.cpp |
// | 5. ADD TO DEFAULT_ASSET_FOR_INV in LLInventoryType.cpp |
// +*********************************************************+
AT_NONE = -1
@ -173,33 +145,17 @@ public:
static EType lookupHumanReadable(const std::string& readable_name);
static const char* lookupHumanReadable(EType asset_type);
// Generate a good default description. You may want to add a verb
// or agent name after this depending on your application.
static void generateDescriptionFor(LLAssetType::EType asset_type,
std::string& description);
static EType getType(const std::string& desc_name);
static const std::string& getDesc(EType asset_type);
static EDragAndDropType lookupDragAndDropType(EType asset_type);
static bool lookupCanLink(EType asset_type);
static bool lookupIsLinkType(EType asset_type);
static const char* lookupCategoryName(EType asset_type);
static bool lookupIsProtectedCategoryType(EType asset_type);
static bool lookupIsEnsembleCategoryType(EType asset_type);
static const std::string& badLookup(); // error string when a lookup fails
/* TODO: Change return types from "const char *" to "const std::string &".
This is fairly straightforward, but requires changing some calls to use .c_str().
e.g.:
- fprintf(fp, "\t\ttype\t%s\n", LLAssetType::lookup(mType));
+ fprintf(fp, "\t\ttype\t%s\n", LLAssetType::lookup(mType).c_str());
*/
private:
// don't instantiate or derive one of these objects
LLAssetType( void ) {}
~LLAssetType( void ) {}
protected:
LLAssetType() {}
~LLAssetType() {}
};
#endif // LL_LLASSETTYPE_H

165
indra/llcommon/llfoldertype.cpp Normal file
View File

@ -0,0 +1,165 @@
/**
* @file llfoldertype.cpp
* @brief Implementatino of LLFolderType functionality.
*
* $LicenseInfo:firstyear=2001&license=viewergpl$
*
* Copyright (c) 2001-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#include "linden_common.h"
#include "llfoldertype.h"
#include "lldictionary.h"
#include "llmemory.h"
#include "llsingleton.h"
///----------------------------------------------------------------------------
/// Class LLFolderType
///----------------------------------------------------------------------------
struct FolderEntry : public LLDictionaryEntry
{
FolderEntry(const std::string &type_name, // 8 character limit!
bool is_protected) // can the viewer change categories of this type?
:
LLDictionaryEntry(type_name),
mIsProtected(is_protected)
{
llassert(type_name.length() <= 8);
}
const bool mIsProtected;
};
class LLFolderDictionary : public LLSingleton<LLFolderDictionary>,
public LLDictionary<LLFolderType::EType, FolderEntry>
{
public:
LLFolderDictionary();
};
LLFolderDictionary::LLFolderDictionary()
{
// TYPE NAME PROTECTED
// |-----------|---------|
addEntry(LLFolderType::FT_TEXTURE, new FolderEntry("texture", TRUE));
addEntry(LLFolderType::FT_SOUND, new FolderEntry("sound", TRUE));
addEntry(LLFolderType::FT_CALLINGCARD, new FolderEntry("callcard", TRUE));
addEntry(LLFolderType::FT_LANDMARK, new FolderEntry("landmark", TRUE));
addEntry(LLFolderType::FT_CLOTHING, new FolderEntry("clothing", TRUE));
addEntry(LLFolderType::FT_OBJECT, new FolderEntry("object", TRUE));
addEntry(LLFolderType::FT_NOTECARD, new FolderEntry("notecard", TRUE));
addEntry(LLFolderType::FT_CATEGORY, new FolderEntry("category", TRUE));
addEntry(LLFolderType::FT_ROOT_CATEGORY, new FolderEntry("root", TRUE));
addEntry(LLFolderType::FT_LSL_TEXT, new FolderEntry("lsltext", TRUE));
addEntry(LLFolderType::FT_BODYPART, new FolderEntry("bodypart", TRUE));
addEntry(LLFolderType::FT_TRASH, new FolderEntry("trash", TRUE));
addEntry(LLFolderType::FT_SNAPSHOT_CATEGORY, new FolderEntry("snapshot", TRUE));
addEntry(LLFolderType::FT_LOST_AND_FOUND, new FolderEntry("lstndfnd", TRUE));
addEntry(LLFolderType::FT_ANIMATION, new FolderEntry("animatn", TRUE));
addEntry(LLFolderType::FT_GESTURE, new FolderEntry("gesture", TRUE));
addEntry(LLFolderType::FT_FAVORITE, new FolderEntry("favorite", TRUE));
for (S32 ensemble_num = S32(LLFolderType::FT_ENSEMBLE_START); ensemble_num <= S32(LLFolderType::FT_ENSEMBLE_END); ensemble_num++)
{
addEntry(LLFolderType::EType(ensemble_num), new FolderEntry("ensemble", FALSE));
}
addEntry(LLFolderType::FT_CURRENT_OUTFIT, new FolderEntry("current", TRUE));
addEntry(LLFolderType::FT_OUTFIT, new FolderEntry("outfit", FALSE));
addEntry(LLFolderType::FT_MY_OUTFITS, new FolderEntry("my_otfts", TRUE));
addEntry(LLFolderType::FT_INBOX, new FolderEntry("inbox", TRUE));
addEntry(LLFolderType::FT_NONE, new FolderEntry("-1", FALSE));
};
// static
LLFolderType::EType LLFolderType::lookup(const std::string& name)
{
return LLFolderDictionary::getInstance()->lookup(name);
}
// static
const std::string &LLFolderType::lookup(LLFolderType::EType folder_type)
{
const FolderEntry *entry = LLFolderDictionary::getInstance()->lookup(folder_type);
if (entry)
{
return entry->mName;
}
else
{
return badLookup();
}
}
// static
// Only ensembles and plain folders aren't protected. "Protected" means
// you can't change certain properties such as their type.
bool LLFolderType::lookupIsProtectedType(EType folder_type)
{
const LLFolderDictionary *dict = LLFolderDictionary::getInstance();
const FolderEntry *entry = dict->lookup(folder_type);
if (entry)
{
return entry->mIsProtected;
}
return true;
}
// static
bool LLFolderType::lookupIsEnsembleType(EType folder_type)
{
return (folder_type >= FT_ENSEMBLE_START &&
folder_type <= FT_ENSEMBLE_END);
}
// static
LLAssetType::EType LLFolderType::folderTypeToAssetType(LLFolderType::EType folder_type)
{
if (LLAssetType::lookup(LLAssetType::EType(folder_type)) == LLAssetType::badLookup())
{
llwarns << "Converting to unknown asset type " << folder_type << llendl;
}
return (LLAssetType::EType)folder_type;
}
// static
LLFolderType::EType LLFolderType::assetTypeToFolderType(LLAssetType::EType asset_type)
{
if (LLFolderType::lookup(LLFolderType::EType(asset_type)) == LLFolderType::badLookup())
{
llwarns << "Converting to unknown folder type " << asset_type << llendl;
}
return (LLFolderType::EType)asset_type;
}
// static
const std::string &LLFolderType::badLookup()
{
static const std::string sBadLookup = "llfoldertype_bad_lookup";
return sBadLookup;
}

123
indra/llcommon/llfoldertype.h Normal file
View File

@ -0,0 +1,123 @@
/**
* @file llfoldertype.h
* @brief Declaration of LLFolderType.
*
* $LicenseInfo:firstyear=2001&license=viewergpl$
*
* Copyright (c) 2001-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#ifndef LL_LLFOLDERTYPE_H
#define LL_LLFOLDERTYPE_H
#include <string>
#include "llassettype.h"
// This class handles folder types (similar to assettype, except for folders)
// and operations on those.
class LL_COMMON_API LLFolderType
{
public:
// ! BACKWARDS COMPATIBILITY ! Folder type enums must match asset type enums.
enum EType
{
FT_TEXTURE = 0,
FT_SOUND = 1,
FT_CALLINGCARD = 2,
FT_LANDMARK = 3,
// FT_SCRIPT = 4,
FT_CLOTHING = 5,
FT_OBJECT = 6,
FT_NOTECARD = 7,
FT_CATEGORY = 8,
FT_ROOT_CATEGORY = 9,
FT_LSL_TEXT = 10,
// FT_LSL_BYTECODE = 11,
// FT_TEXTURE_TGA = 12,
FT_BODYPART = 13,
FT_TRASH = 14,
FT_SNAPSHOT_CATEGORY = 15,
FT_LOST_AND_FOUND = 16,
// FT_SOUND_WAV = 17,
// FT_IMAGE_TGA = 18,
// FT_IMAGE_JPEG = 19,
FT_ANIMATION = 20,
FT_GESTURE = 21,
// FT_SIMSTATE = 22,
FT_FAVORITE = 23,
FT_ENSEMBLE_START = 26,
FT_ENSEMBLE_END = 45,
// This range is reserved for special clothing folder types.
FT_CURRENT_OUTFIT = 46,
FT_OUTFIT = 47,
FT_MY_OUTFITS = 48,
FT_INBOX = 49,
FT_COUNT = 50,
FT_NONE = -1
};
static EType lookup(const std::string& type_name);
static const std::string& lookup(EType folder_type);
static bool lookupIsProtectedType(EType folder_type);
static bool lookupIsEnsembleType(EType folder_type);
static LLAssetType::EType folderTypeToAssetType(LLFolderType::EType folder_type);
static LLFolderType::EType assetTypeToFolderType(LLAssetType::EType asset_type);
static const std::string& badLookup(); // error string when a lookup fails
protected:
LLFolderType() {}
~LLFolderType() {}
};
#endif // LL_LLFOLDERTYPE_H

62
indra/llinventory/llinventory.cpp
View File

@ -1324,7 +1324,7 @@ BOOL item_date_sort( LLInventoryItem* a, LLInventoryItem* b )
LLInventoryCategory::LLInventoryCategory(
const LLUUID& uuid,
const LLUUID& parent_uuid,
LLAssetType::EType preferred_type,
LLFolderType::EType preferred_type,
const std::string& name) :
LLInventoryObject(uuid, parent_uuid, LLAssetType::AT_CATEGORY, name),
mPreferredType(preferred_type)
@ -1332,7 +1332,7 @@ LLInventoryCategory::LLInventoryCategory(
}
LLInventoryCategory::LLInventoryCategory() :
mPreferredType(LLAssetType::AT_NONE)
mPreferredType(LLFolderType::FT_NONE)
{
mType = LLAssetType::AT_CATEGORY;
}
@ -1354,12 +1354,12 @@ void LLInventoryCategory::copyCategory(const LLInventoryCategory* other)
mPreferredType = other->mPreferredType;
}
LLAssetType::EType LLInventoryCategory::getPreferredType() const
LLFolderType::EType LLInventoryCategory::getPreferredType() const
{
return mPreferredType;
}
void LLInventoryCategory::setPreferredType(LLAssetType::EType type)
void LLInventoryCategory::setPreferredType(LLFolderType::EType type)
{
mPreferredType = type;
}
@ -1405,13 +1405,13 @@ bool LLInventoryCategory::fromLLSD(const LLSD& sd)
if (sd.has(w))
{
S8 type = (U8)sd[w].asInteger();
mPreferredType = static_cast<LLAssetType::EType>(type);
mPreferredType = static_cast<LLFolderType::EType>(type);
}
w = INV_ASSET_TYPE_LABEL_WS;
if (sd.has(w))
{
S8 type = (U8)sd[w].asInteger();
mPreferredType = static_cast<LLAssetType::EType>(type);
mPreferredType = static_cast<LLFolderType::EType>(type);
}
w = INV_NAME_LABEL;
@ -1433,7 +1433,7 @@ void LLInventoryCategory::unpackMessage(LLMessageSystem* msg,
msg->getUUIDFast(block, _PREHASH_ParentID, mParentUUID, block_num);
S8 type;
msg->getS8Fast(block, _PREHASH_Type, type, block_num);
mPreferredType = static_cast<LLAssetType::EType>(type);
mPreferredType = static_cast<LLFolderType::EType>(type);
msg->getStringFast(block, _PREHASH_Name, mName, block_num);
LLStringUtil::replaceNonstandardASCII(mName, ' ');
}
@ -1482,7 +1482,7 @@ BOOL LLInventoryCategory::importFile(LLFILE* fp)
}
else if(0 == strcmp("pref_type", keyword))
{
mPreferredType = LLAssetType::lookup(valuestr);
mPreferredType = LLFolderType::lookup(valuestr);
}
else if(0 == strcmp("name", keyword))
{
@ -1514,7 +1514,7 @@ BOOL LLInventoryCategory::exportFile(LLFILE* fp, BOOL) const
mParentUUID.toString(uuid_str);
fprintf(fp, "\t\tparent_id\t%s\n", uuid_str.c_str());
fprintf(fp, "\t\ttype\t%s\n", LLAssetType::lookup(mType));
fprintf(fp, "\t\tpref_type\t%s\n", LLAssetType::lookup(mPreferredType));
fprintf(fp, "\t\tpref_type\t%s\n", LLFolderType::lookup(mPreferredType).c_str());
fprintf(fp, "\t\tname\t%s|\n", mName.c_str());
fprintf(fp,"\t}\n");
return TRUE;
@ -1561,7 +1561,7 @@ BOOL LLInventoryCategory::importLegacyStream(std::istream& input_stream)
}
else if(0 == strcmp("pref_type", keyword))
{
mPreferredType = LLAssetType::lookup(valuestr);
mPreferredType = LLFolderType::lookup(valuestr);
}
else if(0 == strcmp("name", keyword))
{
@ -1593,7 +1593,7 @@ BOOL LLInventoryCategory::exportLegacyStream(std::ostream& output_stream, BOOL)
mParentUUID.toString(uuid_str);
output_stream << "\t\tparent_id\t" << uuid_str << "\n";
output_stream << "\t\ttype\t" << LLAssetType::lookup(mType) << "\n";
output_stream << "\t\tpref_type\t" << LLAssetType::lookup(mPreferredType) << "\n";
output_stream << "\t\tpref_type\t" << LLFolderType::lookup(mPreferredType) << "\n";
output_stream << "\t\tname\t" << mName.c_str() << "|\n";
output_stream << "\t}\n";
return TRUE;
@ -1629,38 +1629,6 @@ LLSD ll_create_sd_from_inventory_item(LLPointer<LLInventoryItem> item)
return rv;
}
/* deprecated, use LLInventoryItem::fromLLSD() instead
LLPointer<LLInventoryItem> ll_create_item_from_sd(const LLSD& sd_item)
{
LLPointer<LLInventoryItem> rv = new LLInventoryItem;
rv->setUUID(sd_item[INV_ITEM_ID_LABEL].asUUID());
rv->setParent(sd_item[INV_PARENT_ID_LABEL].asUUID());
rv->rename(sd_item[INV_NAME_LABEL].asString());
rv->setType(
LLAssetType::lookup(sd_item[INV_ASSET_TYPE_LABEL].asString()));
if (sd_item.has("shadow_id"))
{
LLUUID asset_id = sd_item["shadow_id"];
LLXORCipher cipher(MAGIC_ID.mData, UUID_BYTES);
cipher.decrypt(asset_id.mData, UUID_BYTES);
rv->setAssetUUID(asset_id);
}
if (sd_item.has(INV_ASSET_ID_LABEL))
{
rv->setAssetUUID(sd_item[INV_ASSET_ID_LABEL].asUUID());
}
rv->setDescription(sd_item[INV_DESC_LABEL].asString());
rv->setSaleInfo(ll_sale_info_from_sd(sd_item[INV_SALE_INFO_LABEL]));
rv->setPermissions(ll_permissions_from_sd(sd_item[INV_PERMISSIONS_LABEL]));
rv->setInventoryType(
LLInventoryType::lookup(
sd_item[INV_INVENTORY_TYPE_LABEL].asString()));
rv->setFlags((U32)(sd_item[INV_FLAGS_LABEL].asInteger()));
rv->setCreationDate(sd_item[INV_CREATION_DATE_LABEL].asInteger());
return rv;
}
*/
LLSD ll_create_sd_from_inventory_category(LLPointer<LLInventoryCategory> cat)
{
LLSD rv;
@ -1675,10 +1643,10 @@ LLSD ll_create_sd_from_inventory_category(LLPointer<LLInventoryCategory> cat)
rv[INV_PARENT_ID_LABEL] = cat->getParentUUID();
rv[INV_NAME_LABEL] = cat->getName();
rv[INV_ASSET_TYPE_LABEL] = LLAssetType::lookup(cat->getType());
if(LLAssetType::lookupIsProtectedCategoryType(cat->getPreferredType()))
if(LLFolderType::lookupIsProtectedType(cat->getPreferredType()))
{
rv[INV_PREFERRED_TYPE_LABEL] =
LLAssetType::lookup(cat->getPreferredType());
LLFolderType::lookup(cat->getPreferredType()).c_str();
}
return rv;
}
@ -1692,7 +1660,7 @@ LLPointer<LLInventoryCategory> ll_create_category_from_sd(const LLSD& sd_cat)
rv->setType(
LLAssetType::lookup(sd_cat[INV_ASSET_TYPE_LABEL].asString()));
rv->setPreferredType(
LLAssetType::lookup(
sd_cat[INV_PREFERRED_TYPE_LABEL].asString()));
LLFolderType::lookup(
sd_cat[INV_PREFERRED_TYPE_LABEL].asString()));
return rv;
}

13
indra/llinventory/llinventory.h
View File

@ -37,6 +37,7 @@
#include "llassetstorage.h"
#include "lldarray.h"
#include "llfoldertype.h"
#include "llinventorytype.h"
#include "llmemtype.h"
#include "llpermissions.h"
@ -321,15 +322,15 @@ protected:
public:
MEM_TYPE_NEW(LLMemType::MTYPE_INVENTORY);
LLInventoryCategory(const LLUUID& uuid, const LLUUID& parent_uuid,
LLAssetType::EType preferred_type,
LLFolderType::EType preferred_type,
const std::string& name);
LLInventoryCategory();
LLInventoryCategory(const LLInventoryCategory* other);
void copyCategory(const LLInventoryCategory* other); // LLRefCount requires custom copy
// accessors and mutators
LLAssetType::EType getPreferredType() const;
void setPreferredType(LLAssetType::EType type);
LLFolderType::EType getPreferredType() const;
void setPreferredType(LLFolderType::EType type);
// For messaging system support
virtual void packMessage(LLMessageSystem* msg) const;
virtual void unpackMessage(LLMessageSystem* msg, const char* block, S32 block_num = 0);
@ -345,10 +346,8 @@ public:
virtual BOOL exportLegacyStream(std::ostream& output_stream, BOOL include_asset_key = TRUE) const;
protected:
// The type of asset that this category was "meant" to hold
// (although it may in fact hold any type).
LLAssetType::EType mPreferredType;
// May be the type that this category was "meant" to hold (although it may hold any type).
LLFolderType::EType mPreferredType;
};

34
indra/llinventory/llinventorytype.cpp
View File

@ -79,24 +79,16 @@ LLInventoryDictionary::LLInventoryDictionary()
addEntry(LLInventoryType::IT_SOUND, new InventoryEntry("sound", "sound", 1, LLAssetType::AT_SOUND));
addEntry(LLInventoryType::IT_CALLINGCARD, new InventoryEntry("callcard", "calling card", 1, LLAssetType::AT_CALLINGCARD));
addEntry(LLInventoryType::IT_LANDMARK, new InventoryEntry("landmark", "landmark", 1, LLAssetType::AT_LANDMARK));
//addEntry(LLInventoryType::IT_SCRIPT, new InventoryEntry(NULL,NULL));
//addEntry(LLInventoryType::IT_CLOTHING, new InventoryEntry(NULL,NULL));
addEntry(LLInventoryType::IT_OBJECT, new InventoryEntry("object", "object", 1, LLAssetType::AT_OBJECT));
addEntry(LLInventoryType::IT_NOTECARD, new InventoryEntry("notecard", "note card", 1, LLAssetType::AT_NOTECARD));
addEntry(LLInventoryType::IT_CATEGORY, new InventoryEntry("category", "folder" ));
addEntry(LLInventoryType::IT_ROOT_CATEGORY, new InventoryEntry("root", "root" ));
addEntry(LLInventoryType::IT_LSL, new InventoryEntry("script", "script", 2, LLAssetType::AT_LSL_TEXT, LLAssetType::AT_LSL_BYTECODE));
//addEntry(LLInventoryType::IT_LSL_BYTECODE, new InventoryEntry(NULL,NULL));
//addEntry(LLInventoryType::IT_TEXTURE_TGA, new InventoryEntry(NULL,NULL));
//addEntry(LLInventoryType::IT_BODYPART, new InventoryEntry(NULL,NULL));
//addEntry(LLInventoryType::IT_TRASH, new InventoryEntry(NULL,NULL));
addEntry(LLInventoryType::IT_SNAPSHOT, new InventoryEntry("snapshot", "snapshot", 1, LLAssetType::AT_TEXTURE));
//addEntry(LLInventoryType::IT_LOST_AND_FOUND, new InventoryEntry(NULL,NULL, ));
addEntry(LLInventoryType::IT_ATTACHMENT, new InventoryEntry("attach", "attachment", 1, LLAssetType::AT_OBJECT));
addEntry(LLInventoryType::IT_WEARABLE, new InventoryEntry("wearable", "wearable", 2, LLAssetType::AT_CLOTHING, LLAssetType::AT_BODYPART));
addEntry(LLInventoryType::IT_ANIMATION, new InventoryEntry("animation", "animation", 1, LLAssetType::AT_ANIMATION));
addEntry(LLInventoryType::IT_GESTURE, new InventoryEntry("gesture", "gesture", 1, LLAssetType::AT_GESTURE));
addEntry(LLInventoryType::IT_FAVORITE, new InventoryEntry("favorite", "favorite", 1, LLAssetType::AT_FAVORITE));
}
@ -128,35 +120,9 @@ DEFAULT_ASSET_FOR_INV_TYPE[LLAssetType::AT_COUNT] =
LLInventoryType::IT_ANIMATION, // AT_ANIMATION
LLInventoryType::IT_GESTURE, // AT_GESTURE
LLInventoryType::IT_NONE, // AT_SIMSTATE
LLInventoryType::IT_FAVORITE, // AT_FAVORITE
LLInventoryType::IT_NONE, // AT_LINK
LLInventoryType::IT_NONE, // AT_LINK_FOLDER
LLInventoryType::IT_CATEGORY, // AT_ENSEMBLE
LLInventoryType::IT_CATEGORY, // AT_ENSEMBLE
LLInventoryType::IT_CATEGORY, // AT_ENSEMBLE
LLInventoryType::IT_CATEGORY, // AT_ENSEMBLE
LLInventoryType::IT_CATEGORY, // AT_ENSEMBLE
LLInventoryType::IT_CATEGORY, // AT_ENSEMBLE
LLInventoryType::IT_CATEGORY, // AT_ENSEMBLE
LLInventoryType::IT_CATEGORY, // AT_ENSEMBLE
LLInventoryType::IT_CATEGORY, // AT_ENSEMBLE
LLInventoryType::IT_CATEGORY, // AT_ENSEMBLE
LLInventoryType::IT_CATEGORY, // AT_ENSEMBLE
LLInventoryType::IT_CATEGORY, // AT_ENSEMBLE
LLInventoryType::IT_CATEGORY, // AT_ENSEMBLE
LLInventoryType::IT_CATEGORY, // AT_ENSEMBLE
LLInventoryType::IT_CATEGORY, // AT_ENSEMBLE
LLInventoryType::IT_CATEGORY, // AT_ENSEMBLE
LLInventoryType::IT_CATEGORY, // AT_ENSEMBLE
LLInventoryType::IT_CATEGORY, // AT_ENSEMBLE
LLInventoryType::IT_CATEGORY, // AT_ENSEMBLE
LLInventoryType::IT_CATEGORY, // AT_ENSEMBLE
LLInventoryType::IT_CATEGORY, // AT_CURRENT_OUTFIT
LLInventoryType::IT_CATEGORY, // AT_OUTFIT
LLInventoryType::IT_CATEGORY, // AT_MY_OUTFITS
};
// static

3
indra/llinventory/llinventorytype.h
View File

@ -67,8 +67,7 @@ public:
IT_WEARABLE = 18,
IT_ANIMATION = 19,
IT_GESTURE = 20,
IT_FAVORITE = 21,
IT_COUNT = 22,
IT_COUNT = 21,
IT_NONE = -1
};

4
indra/llinventory/tests/inventorymisc_test.cpp
View File

@ -94,7 +94,7 @@ LLPointer<LLInventoryCategory> create_random_inventory_cat()
LLPointer<LLInventoryCategory> cat = new LLInventoryCategory(
item_id,
parent_id,
LLAssetType::AT_NONE,
LLFolderType::FT_NONE,
std::string("Sample category"));
return cat;
}
@ -452,7 +452,7 @@ namespace tut
ensure_equals("4.type::getType() failed", dst->getType(), src->getType());
ensure_equals("5.preferred type::getPreferredType() failed", dst->getPreferredType(), src->getPreferredType());
src->setPreferredType( LLAssetType::AT_TEXTURE);
src->setPreferredType( LLFolderType::FT_TEXTURE);
sd = ll_create_sd_from_inventory_category(src);
dst = ll_create_category_from_sd(sd);
ensure_equals("6.preferred type::getPreferredType() failed", dst->getPreferredType(), src->getPreferredType());

1
indra/llmessage/lltransfersourceasset.cpp
View File

@ -292,7 +292,6 @@ bool is_asset_id_knowable(LLAssetType::EType type)
case LLAssetType::AT_BODYPART:
case LLAssetType::AT_ANIMATION:
case LLAssetType::AT_GESTURE:
case LLAssetType::AT_FAVORITE:
case LLAssetType::AT_LINK:
case LLAssetType::AT_LINK_FOLDER:
rv = true;

1
indra/llprimitive/llmediaentry.cpp
View File

@ -164,6 +164,7 @@ void LLMediaEntry::asLLSD(LLSD& sd) const
// "security" fields
sd[WHITELIST_ENABLE_KEY] = mWhiteListEnable;
sd.erase(WHITELIST_KEY);
for (U32 i=0; i<mWhiteList.size(); i++)
{
sd[WHITELIST_KEY].append(mWhiteList[i]);

116
indra/llprimitive/tests/llmediaentry_test.cpp
View File

@ -223,8 +223,7 @@ namespace tut
{
set_test_name("Test LLMediaEntry Instantiation");
LLMediaEntry entry;
ensure_llsd_equals(get_test_name(), defaultMediaEntryLLSD, entry.asLLSD());
ensure_llsd_equals(get_test_name() + " failed", defaultMediaEntryLLSD, entry.asLLSD());
}
template<> template<>
@ -251,12 +250,27 @@ namespace tut
ensure_llsd_equals(get_test_name() + " failed", golden, entry.asLLSD());
}
template<> template<>
void object::test<4>()
{
set_test_name("Test LLMediaEntry::asLLSD()");
LLMediaEntry entry;
LLSD sd;
// Put some cruft in the LLSD
sd[LLMediaEntry::CURRENT_URL_KEY] = "http://www.example.com";
LLSD whitelist;
whitelist.append("*.example.com");
sd[LLMediaEntry::WHITELIST_KEY] = whitelist;
entry.asLLSD(sd);
ensure_llsd_equals(get_test_name() + " failed", defaultMediaEntryLLSD, sd);
}
// limit tests
const char *URL_OK = "http://www.example.com";
const char *URL_TOO_BIG = "http://www.example.com.qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq";
template<> template<>
void object::test<4>()
void object::test<5>()
{
set_test_name("Test Limits on setting current URL");
LLMediaEntry entry;
@ -267,7 +281,7 @@ namespace tut
}
template<> template<>
void object::test<5>()
void object::test<6>()
{
set_test_name("Test Limits on setting home URL");
LLMediaEntry entry;
@ -278,7 +292,7 @@ namespace tut
}
template<> template<>
void object::test<6>()
void object::test<7>()
{
set_test_name("Test Limits on setting whitelist");
@ -292,7 +306,7 @@ namespace tut
}
template<> template<>
void object::test<7>()
void object::test<8>()
{
set_test_name("Test Limits on setting whitelist too big");
@ -307,7 +321,7 @@ namespace tut
}
template<> template<>
void object::test<8>()
void object::test<9>()
{
set_test_name("Test Limits on setting whitelist too many");
@ -323,7 +337,7 @@ namespace tut
}
template<> template<>
void object::test<9>()
void object::test<10>()
{
set_test_name("Test to make sure both setWhiteList() functions behave the same");
@ -341,7 +355,7 @@ namespace tut
}
template<> template<>
void object::test<10>()
void object::test<11>()
{
set_test_name("Test to make sure both setWhiteList() functions behave the same");
@ -362,7 +376,7 @@ namespace tut
}
template<> template<>
void object::test<11>()
void object::test<12>()
{
set_test_name("Test to make sure both setWhiteList() functions behave the same");
@ -386,99 +400,99 @@ namespace tut
// Check the "empty whitelist" case
template<> template<>
void object::test<12>() { whitelist_test("", "http://www.example.com", true); }
void object::test<13>() { whitelist_test("", "http://www.example.com", true); }
// Check the "missing scheme" case
template<> template<>
void object::test<13>() { whitelist_test("www.example.com", "http://www.example.com", true); }
void object::test<14>() { whitelist_test("www.example.com", "http://www.example.com", true); }
// Check the "exactly the same" case
template<> template<>
void object::test<14>() { whitelist_test("http://example.com", "http://example.com", true); }
void object::test<15>() { whitelist_test("http://example.com", "http://example.com", true); }
// Check the enable flag
template<> template<>
void object::test<15>() { whitelist_test(false, "www.example.com", "http://www.secondlife.com", true); }
void object::test<16>() { whitelist_test(false, "www.example.com", "http://www.secondlife.com", true); }
template<> template<>
void object::test<16>() { whitelist_test(true, "www.example.com", "http://www.secondlife.com", false); }
void object::test<17>() { whitelist_test(true, "www.example.com", "http://www.secondlife.com", false); }
// Check permutations of trailing slash:
template<> template<>
void object::test<17>() { whitelist_test("http://www.example.com", "http://www.example.com/", true); }
void object::test<18>() { whitelist_test("http://www.example.com", "http://www.example.com/", true); }
template<> template<>
void object::test<18>() { whitelist_test("http://www.example.com/", "http://www.example.com/", true); }
void object::test<19>() { whitelist_test("http://www.example.com/", "http://www.example.com/", true); }
template<> template<>
void object::test<19>() { whitelist_test("http://www.example.com/", "http://www.example.com", false); }
void object::test<20>() { whitelist_test("http://www.example.com/", "http://www.example.com", false); }
template<> template<>
void object::test<20>() { whitelist_test("http://www.example.com", "http://www.example.com/foobar", true); }
void object::test<21>() { whitelist_test("http://www.example.com", "http://www.example.com/foobar", true); }
template<> template<>
void object::test<21>() { whitelist_test("http://www.example.com/", "http://www.example.com/foobar", false); }
void object::test<22>() { whitelist_test("http://www.example.com/", "http://www.example.com/foobar", false); }
// More cases...
template<> template<>
void object::test<22>() { whitelist_test("http://example.com", "http://example.com/wiki", true); }
void object::test<23>() { whitelist_test("http://example.com", "http://example.com/wiki", true); }
template<> template<>
void object::test<23>() { whitelist_test("www.example.com", "http://www.example.com/help", true); }
void object::test<24>() { whitelist_test("www.example.com", "http://www.example.com/help", true); }
template<> template<>
void object::test<24>() { whitelist_test("http://www.example.com", "http://wwwexample.com", false); }
void object::test<25>() { whitelist_test("http://www.example.com", "http://wwwexample.com", false); }
template<> template<>
void object::test<25>() { whitelist_test("http://www.example.com", "http://www.example.com/wiki", true); }
void object::test<26>() { whitelist_test("http://www.example.com", "http://www.example.com/wiki", true); }
template<> template<>
void object::test<26>() { whitelist_test("example.com", "http://wwwexample.com", false); }
void object::test<27>() { whitelist_test("example.com", "http://wwwexample.com", false); }
template<> template<>
void object::test<27>() { whitelist_test("http://www.example.com/", "http://www.amazon.com/wiki", false); }
void object::test<28>() { whitelist_test("http://www.example.com/", "http://www.amazon.com/wiki", false); }
template<> template<>
void object::test<28>() { whitelist_test("www.example.com", "http://www.amazon.com", false); }
void object::test<29>() { whitelist_test("www.example.com", "http://www.amazon.com", false); }
// regexp cases
template<> template<>
void object::test<29>() { whitelist_test("*.example.com", "http://www.example.com", true); }
void object::test<30>() { whitelist_test("*.example.com", "http://www.example.com", true); }
template<> template<>
void object::test<30>() { whitelist_test("*.example.com", "http://www.amazon.com", false); }
void object::test<31>() { whitelist_test("*.example.com", "http://www.amazon.com", false); }
template<> template<>
void object::test<31>() { whitelist_test("*.example.com", "http://www.example.com/foo/bar", true); }
void object::test<32>() { whitelist_test("*.example.com", "http://www.example.com/foo/bar", true); }
template<> template<>
void object::test<32>() { whitelist_test("*.example.com", "http:/example.com/foo/bar", false); }
void object::test<33>() { whitelist_test("*.example.com", "http:/example.com/foo/bar", false); }
template<> template<>
void object::test<33>() { whitelist_test("*example.com", "http://example.com/foo/bar", true); }
void object::test<34>() { whitelist_test("*example.com", "http://example.com/foo/bar", true); }
template<> template<>
void object::test<34>() { whitelist_test("*example.com", "http://my.virus.com/foo/bar?example.com", false); }
void object::test<35>() { whitelist_test("*example.com", "http://my.virus.com/foo/bar?example.com", false); }
template<> template<>
void object::test<35>() { whitelist_test("example.com", "http://my.virus.com/foo/bar?example.com", false); }
void object::test<36>() { whitelist_test("example.com", "http://my.virus.com/foo/bar?example.com", false); }
template<> template<>
void object::test<36>() { whitelist_test("*example.com", "http://my.virus.com/foo/bar?*example.com", false); }
void object::test<37>() { whitelist_test("*example.com", "http://my.virus.com/foo/bar?*example.com", false); }
template<> template<>
void object::test<37>() { whitelist_test("http://*example.com", "http://www.example.com", true); }
void object::test<38>() { whitelist_test("http://*example.com", "http://www.example.com", true); }
template<> template<>
void object::test<38>() { whitelist_test("http://*.example.com", "http://www.example.com", true); }
void object::test<39>() { whitelist_test("http://*.example.com", "http://www.example.com", true); }
template<> template<>
void object::test<39>() { whitelist_test("http://*.e$?^.com", "http://www.e$?^.com", true); }
void object::test<40>() { whitelist_test("http://*.e$?^.com", "http://www.e$?^.com", true); }
template<> template<>
void object::test<40>() { whitelist_test("*.example.com/foo/bar", "http://www.example.com/", false); }
void object::test<41>() { whitelist_test("*.example.com/foo/bar", "http://www.example.com/", false); }
template<> template<>
void object::test<41>() { whitelist_test("*.example.com/foo/bar", "http://example.com/foo/bar", false); }
void object::test<42>() { whitelist_test("*.example.com/foo/bar", "http://example.com/foo/bar", false); }
template<> template<>
void object::test<42>() { whitelist_test("http://*.example.com/foo/bar", "http://www.example.com", false); }
void object::test<43>() { whitelist_test("http://*.example.com/foo/bar", "http://www.example.com", false); }
template<> template<>
void object::test<43>() { whitelist_test("http://*.example.com", "https://www.example.com", false); }
void object::test<44>() { whitelist_test("http://*.example.com", "https://www.example.com", false); }
template<> template<>
void object::test<44>() { whitelist_test("http*://*.example.com", "rtsp://www.example.com", false); }
void object::test<45>() { whitelist_test("http*://*.example.com", "rtsp://www.example.com", false); }
template<> template<>
void object::test<45>() { whitelist_test("http*://*.example.com", "https://www.example.com", true); }
void object::test<46>() { whitelist_test("http*://*.example.com", "https://www.example.com", true); }
template<> template<>
void object::test<46>() { whitelist_test("example.com", "http://www.example.com", false); }
void object::test<47>() { whitelist_test("example.com", "http://www.example.com", false); }
template<> template<>
void object::test<47>() { whitelist_test("www.example.com", "http://www.example.com:80", false); }
void object::test<48>() { whitelist_test("www.example.com", "http://www.example.com:80", false); }
template<> template<>
void object::test<48>() { whitelist_test("www.example.com", "http://www.example.com", true); }
void object::test<49>() { whitelist_test("www.example.com", "http://www.example.com", true); }
template<> template<>
void object::test<49>() { whitelist_test("www.example.com/", "http://www.example.com", false); }
void object::test<50>() { whitelist_test("www.example.com/", "http://www.example.com", false); }
template<> template<>
void object::test<50>() { whitelist_test("www.example.com/foo/bar/*", "http://www.example.com/foo/bar/baz", true); }
void object::test<51>() { whitelist_test("www.example.com/foo/bar/*", "http://www.example.com/foo/bar/baz", true); }
// Path only
template<> template<>
void object::test<51>() { whitelist_test("/foo/*/baz", "http://www.example.com/foo/bar/baz", true); }
void object::test<52>() { whitelist_test("/foo/*/baz", "http://www.example.com/foo/bar/baz", true); }
template<> template<>
void object::test<52>() { whitelist_test("/foo/*/baz", "http://www.example.com/foo/bar/", false); }
void object::test<53>() { whitelist_test("/foo/*/baz", "http://www.example.com/foo/bar/", false); }
}

6
indra/llui/llfloater.cpp
View File

@ -772,6 +772,12 @@ LLMultiFloater* LLFloater::getHost()
return (LLMultiFloater*)mHostHandle.get();
}
void LLFloater::applySavedVariables()
{
applyRectControl();
applyDockState();
}
void LLFloater::applyRectControl()
{
if (mRectControl.size() > 1)

3
indra/llui/llfloater.h
View File

@ -280,6 +280,9 @@ public:
protected:
void setRectControl(const std::string& rectname) { mRectControl = rectname; };
virtual void applySavedVariables();
void applyRectControl();
void applyDockState();
void storeRectControl();

3
indra/llui/llfloaterreg.cpp
View File

@ -134,8 +134,7 @@ LLFloater* LLFloaterReg::getInstance(const std::string& name, const LLSD& key)
// Note: key should eventually be a non optional LLFloater arg; for now, set mKey to be safe
res->mKey = key;
res->setInstanceName(name);
res->applyRectControl(); // Can't apply rect control until setting instance name
res->applyDockState();//same...
res->applySavedVariables(); // Can't apply rect and dock state until setting instance name
if (res->mAutoTile && !res->getHost() && index > 0)
{
const LLRect& cur_rect = res->getRect();

10
indra/newview/CMakeLists.txt
View File

@ -216,7 +216,6 @@ set(viewer_SOURCE_FILES
llfloaterwhitelistentry.cpp
llfloaterwindlight.cpp
llfloaterworldmap.cpp
llfoldertype.cpp
llfolderview.cpp
llfolderviewitem.cpp
llfollowcam.cpp
@ -317,6 +316,7 @@ set(viewer_SOURCE_FILES
llpanelimcontrolpanel.cpp
llpanelland.cpp
llpanellandaudio.cpp
llpanellandmarkinfo.cpp
llpanellandmarks.cpp
llpanellandmedia.cpp
llpanellogin.cpp
@ -337,6 +337,7 @@ set(viewer_SOURCE_FILES
llpanelpicks.cpp
llpanelplace.cpp
llpanelplaceinfo.cpp
llpanelplaceprofile.cpp
llpanelplaces.cpp
llpanelplacestab.cpp
llpanelprimmediacontrols.cpp
@ -436,12 +437,14 @@ set(viewer_SOURCE_FILES
llvectorperfoptions.cpp
llviewchildren.cpp
llviewerassetstorage.cpp
llviewerassettype.cpp
llvieweraudio.cpp
llviewercamera.cpp
llviewercontrol.cpp
llviewercontrollistener.cpp
llviewerdisplay.cpp
llviewerfloaterreg.cpp
llviewerfoldertype.cpp
llviewergenericmessage.cpp
llviewergesture.cpp
llviewerhelp.cpp
@ -702,7 +705,6 @@ set(viewer_HEADER_FILES
llfloaterwhitelistentry.h
llfloaterwindlight.h
llfloaterworldmap.h
llfoldertype.h
llfolderview.h
llfoldervieweventlistener.h
llfolderviewitem.h
@ -800,6 +802,7 @@ set(viewer_HEADER_FILES
llpanelimcontrolpanel.h
llpanelland.h
llpanellandaudio.h
llpanellandmarkinfo.h
llpanellandmarks.h
llpanellandmedia.h
llpanellogin.h
@ -820,6 +823,7 @@ set(viewer_HEADER_FILES
llpanelpicks.h
llpanelplace.h
llpanelplaceinfo.h
llpanelplaceprofile.h
llpanelplaces.h
llpanelplacestab.h
llpanelprimmediacontrols.h
@ -923,6 +927,7 @@ set(viewer_HEADER_FILES
llvectorperfoptions.h
llviewchildren.h
llviewerassetstorage.h
llviewerassettype.h
llvieweraudio.h
llviewerbuild.h
llviewercamera.h
@ -930,6 +935,7 @@ set(viewer_HEADER_FILES
llviewercontrollistener.h
llviewerdisplay.h
llviewerfloaterreg.h
llviewerfoldertype.h
llviewergenericmessage.h
llviewergesture.h
llviewerhelp.h

25
indra/newview/app_settings/foldertypes.xml
View File

@ -1,66 +1,61 @@
<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<ensemble_defs>
<ensemble
asset_num="-1"
xui_name="default"
icon_name="inv_plain_closed.tga"
/>
<ensemble
asset_num="27"
foldertype_num="27"
xui_name="head"
icon_name="inv_folder_outfit_head.tga"
allowed="hair,eyes"
/>
<ensemble
asset_num="28"
foldertype_num="28"
xui_name="gloves"
icon_name="inv_folder_outfit_gloves.tga"
allowed="gloves"
/>
<ensemble
asset_num="29"
foldertype_num="29"
xui_name="jacket"
icon_name="inv_folder_outfit_jacket.tga"
allowed="jacket"
/>
<ensemble
asset_num="30"
foldertype_num="30"
xui_name="pants"
icon_name="inv_folder_outfit_pants.tga"
allowed="pants,underpants"
/>
<ensemble
asset_num="31"
foldertype_num="31"
xui_name="shape"
icon_name="inv_folder_outfit_shape.tga"
allowed="shape,skin,hair,eyes"
/>
<ensemble
asset_num="32"
foldertype_num="32"
xui_name="shoes"
icon_name="inv_folder_outfit_shoes.tga"
allowed="shoes,socks"
/>
<ensemble
asset_num="33"
foldertype_num="33"
xui_name="shirt"
icon_name="inv_folder_outfit_shirt.tga"
allowed="shirt,undershirt"
/>
<ensemble
asset_num="34"
foldertype_num="34"
xui_name="skirt"
icon_name="inv_folder_outfit_skirt.tga"
allowed=""
/>
<ensemble
asset_num="35"
foldertype_num="35"
xui_name="underpants"
icon_name="inv_folder_outfit_underpants.tga"
allowed="underpants"
/>
<ensemble
asset_num="36"
foldertype_num="36"
xui_name="undershirt"
icon_name="inv_folder_outfit_undershirt.tga"
allowed="undershirt"

3
indra/newview/llagentpicksinfo.cpp
View File

@ -47,7 +47,8 @@ public:
~LLAgentPicksObserver()
{
LLAvatarPropertiesProcessor::getInstance()->removeObserver(gAgent.getID(), this);
if (LLAvatarPropertiesProcessor::instanceExists())
LLAvatarPropertiesProcessor::getInstance()->removeObserver(gAgent.getID(), this);
}
void sendAgentPicksRequest()

5
indra/newview/llagentui.cpp
View File

@ -92,7 +92,10 @@ std::string LLAgentUI::buildSLURL(const bool escaped /*= true*/)
//static
BOOL LLAgentUI::checkAgentDistance(const LLVector3& pole, F32 radius)
{
return (gAgent.getPositionAgent() - pole).length() < radius;
F32 delta_x = gAgent.getPositionAgent().mV[VX] - pole.mV[VX];
F32 delta_y = gAgent.getPositionAgent().mV[VY] - pole.mV[VY];
return sqrt( delta_x* delta_x + delta_y* delta_y ) < radius;
}
BOOL LLAgentUI::buildLocationString(std::string& str, ELocationFormat fmt,const LLVector3& agent_pos_region)
{

17
indra/newview/llagentwearables.cpp
View File

@ -434,7 +434,7 @@ void LLAgentWearables::saveWearableAs(const EWearableType type,
if (save_in_lost_and_found)
{
category_id = gInventory.findCategoryUUIDForType(
LLAssetType::AT_LOST_AND_FOUND);
LLFolderType::FT_LOST_AND_FOUND);
}
else
{
@ -840,7 +840,7 @@ void LLAgentWearables::processAgentInitialWearablesUpdate(LLMessageSystem* mesgs
}
// Get the UUID of the current outfit folder (will be created if it doesn't exist)
LLUUID current_outfit_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_CURRENT_OUTFIT);
const LLUUID current_outfit_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_CURRENT_OUTFIT);
LLInitialWearablesFetch* outfit = new LLInitialWearablesFetch();
@ -981,8 +981,7 @@ void LLAgentWearables::recoverMissingWearable(const EWearableType type, U32 inde
// Add a new one in the lost and found folder.
// (We used to overwrite the "not found" one, but that could potentially
// destory content.) JC
LLUUID lost_and_found_id =
gInventory.findCategoryUUIDForType(LLAssetType::AT_LOST_AND_FOUND);
const LLUUID lost_and_found_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_LOST_AND_FOUND);
LLPointer<LLInventoryCallback> cb =
new addWearableToAgentInventoryCallback(
LLPointer<LLRefCount>(NULL),
@ -1123,8 +1122,8 @@ void LLAgentWearables::makeNewOutfit(const std::string& new_folder_name,
// First, make a folder in the Clothes directory.
LLUUID folder_id = gInventory.createNewCategory(
gInventory.findCategoryUUIDForType(LLAssetType::AT_CLOTHING),
LLAssetType::AT_NONE,
gInventory.findCategoryUUIDForType(LLFolderType::FT_CLOTHING),
LLFolderType::FT_NONE,
new_folder_name);
bool found_first_item = false;
@ -1257,10 +1256,10 @@ LLUUID LLAgentWearables::makeNewOutfitLinks(const std::string& new_folder_name)
}
// First, make a folder in the My Outfits directory.
LLUUID parent_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_MY_OUTFITS);
const LLUUID parent_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_MY_OUTFITS);
LLUUID folder_id = gInventory.createNewCategory(
parent_id,
LLAssetType::AT_OUTFIT,
LLFolderType::FT_OUTFIT,
new_folder_name);
LLAppearanceManager::shallowCopyCategory(LLAppearanceManager::getCOF(),folder_id, NULL);
@ -2032,7 +2031,7 @@ void LLInitialWearablesFetch::processWearablesMessage()
{
if (!mAgentInitialWearables.empty()) // We have an empty current outfit folder, use the message data instead.
{
LLUUID current_outfit_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_CURRENT_OUTFIT);
const LLUUID current_outfit_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_CURRENT_OUTFIT);
for (U8 i = 0; i < mAgentInitialWearables.size(); ++i)
{
// Populate the current outfit folder with links to the wearables passed in the message

24
indra/newview/llappearancemgr.cpp
View File

@ -130,11 +130,11 @@ void LLOutfitObserver::done()
{
if(LLInventoryType::IT_GESTURE == item->getInventoryType())
{
pid = gInventory.findCategoryUUIDForType(LLAssetType::AT_GESTURE);
pid = gInventory.findCategoryUUIDForType(LLFolderType::FT_GESTURE);
}
else
{
pid = gInventory.findCategoryUUIDForType(LLAssetType::AT_CLOTHING);
pid = gInventory.findCategoryUUIDForType(LLFolderType::FT_CLOTHING);
}
break;
}
@ -146,7 +146,7 @@ void LLOutfitObserver::done()
LLUUID cat_id = gInventory.createNewCategory(
pid,
LLAssetType::AT_NONE,
LLFolderType::FT_NONE,
name);
mCatID = cat_id;
LLPointer<LLInventoryCallback> cb = new LLWearInventoryCategoryCallback(mCatID, mAppend);
@ -364,7 +364,7 @@ void removeDuplicateItems(LLInventoryModel::item_array_t& dst, const LLInventory
/* static */
LLUUID LLAppearanceManager::getCOF()
{
return gInventory.findCategoryUUIDForType(LLAssetType::AT_CURRENT_OUTFIT);
return gInventory.findCategoryUUIDForType(LLFolderType::FT_CURRENT_OUTFIT);
}
// Update appearance from outfit folder.
@ -384,12 +384,12 @@ void LLAppearanceManager::changeOutfit(bool proceed, const LLUUID& category, boo
else
{
LLViewerInventoryCategory* catp = gInventory.getCategory(category);
if (catp->getPreferredType() == LLAssetType::AT_NONE ||
LLAssetType::lookupIsEnsembleCategoryType(catp->getPreferredType()))
if (catp->getPreferredType() == LLFolderType::FT_NONE ||
LLFolderType::lookupIsEnsembleType(catp->getPreferredType()))
{
updateCOFFromCategory(category, append); // append is false - rebuild COF.
}
else if (catp->getPreferredType() == LLAssetType::AT_OUTFIT)
else if (catp->getPreferredType() == LLFolderType::FT_OUTFIT)
{
rebuildCOFFromOutfit(category);
}
@ -416,7 +416,7 @@ void LLAppearanceManager::updateCOFFromCategory(const LLUUID& category, bool app
return;
}
const LLUUID &current_outfit_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_CURRENT_OUTFIT);
const LLUUID current_outfit_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_CURRENT_OUTFIT);
// Processes that take time should show the busy cursor
//inc_busy_count();
@ -514,7 +514,7 @@ void LLAppearanceManager::shallowCopyCategory(const LLUUID& src_id, const LLUUID
{
LLViewerInventoryCategory *catp = item->getLinkedCategory();
// Skip copying outfit links.
if (catp && catp->getPreferredType() != LLAssetType::AT_OUTFIT)
if (catp && catp->getPreferredType() != LLFolderType::FT_OUTFIT)
{
link_inventory_item(gAgent.getID(),
item->getLinkedUUID(),
@ -652,7 +652,7 @@ void LLAppearanceManager::shallowCopyCategory(const LLUUID& src_id, const LLUUID
// Add link to outfit if category is an outfit.
LLViewerInventoryCategory* catp = gInventory.getCategory(category);
if (!append && catp && catp->getPreferredType() == LLAssetType::AT_OUTFIT)
if (!append && catp && catp->getPreferredType() == LLFolderType::FT_OUTFIT)
{
link_inventory_item(gAgent.getID(), category, cof, catp->getName(),
LLAssetType::AT_LINK_FOLDER, link_waiter);
@ -743,7 +743,7 @@ void LLAppearanceManager::rebuildCOFFromOutfit(const LLUUID& category)
LLNotifications::instance().add("CouldNotPutOnOutfit");
return;
}
// Processes that take time should show the busy cursor
//inc_busy_count();
@ -761,7 +761,7 @@ void LLAppearanceManager::rebuildCOFFromOutfit(const LLUUID& category)
// Create a link to the outfit that we wore.
LLViewerInventoryCategory* catp = gInventory.getCategory(category);
if (catp && catp->getPreferredType() == LLAssetType::AT_OUTFIT)
if (catp && catp->getPreferredType() == LLFolderType::FT_OUTFIT)
{
link_inventory_item(gAgent.getID(), category, current_outfit_id, catp->getName(),
LLAssetType::AT_LINK_FOLDER, link_waiter);

2
indra/newview/llassetuploadresponders.cpp
View File

@ -334,7 +334,7 @@ void LLNewAgentInventoryResponder::uploadComplete(const LLSD& content)
LLAssetStorage::LLStoreAssetCallback callback = NULL;
void *userdata = NULL;
upload_new_resource(next_file, asset_name, asset_name,
0, LLAssetType::AT_NONE, LLInventoryType::IT_NONE,
0, LLFolderType::FT_NONE, LLInventoryType::IT_NONE,
next_owner_perms, group_perms,
everyone_perms, display_name,
callback, expected_upload_cost, userdata);

4
indra/newview/llavataractions.cpp
View File

@ -343,7 +343,7 @@ bool LLAvatarActions::callbackAddFriend(const LLSD& notification, const LLSD& re
// Servers older than 1.25 require the text of the message to be the
// calling card folder ID for the offering user. JC
LLUUID calling_card_folder_id =
gInventory.findCategoryUUIDForType(LLAssetType::AT_CALLINGCARD);
gInventory.findCategoryUUIDForType(LLFolderType::FT_CALLINGCARD);
std::string message = calling_card_folder_id.asString();
requestFriendship(notification["payload"]["id"].asUUID(),
notification["payload"]["name"].asString(),
@ -355,7 +355,7 @@ bool LLAvatarActions::callbackAddFriend(const LLSD& notification, const LLSD& re
// static
void LLAvatarActions::requestFriendship(const LLUUID& target_id, const std::string& target_name, const std::string& message)
{
LLUUID calling_card_folder_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_CALLINGCARD);
const LLUUID calling_card_folder_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_CALLINGCARD);
send_improved_im(target_id,
target_name,
message,

35
indra/newview/llavatarlist.cpp
View File

@ -239,11 +239,46 @@ void LLAvatarList::refresh()
bool dirty = add_limit_exceeded || (have_filter && !have_names);
setDirty(dirty);
// Refreshed all items, lets send refresh_complete signal.
if(!dirty)
{
std::vector<LLSD> cur_values;
getValues(cur_values);
mRefreshCompleteSignal(this, LLSD((S32)cur_values.size()));
}
// Commit if we've added/removed items.
if (modified)
onCommit();
}
bool LLAvatarList::filterHasMatches()
{
uuid_vector_t values = getIDs();
for (uuid_vector_t::const_iterator it=values.begin(); it != values.end(); it++)
{
std::string name;
const LLUUID& buddy_id = *it;
BOOL have_name = gCacheName->getFullName(buddy_id, name);
// If name has not been loaded yet we consider it as a match.
// When the name will be loaded the filter will be applied again(in refresh()).
if (have_name && !findInsensitive(name, mNameFilter))
{
continue;
}
return true;
}
return false;
}
boost::signals2::connection LLAvatarList::setRefreshCompleteCallback(const commit_signal_t::slot_type& cb)
{
return mRefreshCompleteSignal.connect(cb);
}
void LLAvatarList::addNewItem(const LLUUID& id, const std::string& name, BOOL is_online, EAddPosition pos)
{

7
indra/newview/llavatarlist.h
View File

@ -82,6 +82,11 @@ public:
const std::string getIconParamName() const{return mIconParamName;}
virtual BOOL handleRightMouseDown(S32 x, S32 y, MASK mask);
// Return true if filter has at least one match.
bool filterHasMatches();
boost::signals2::connection setRefreshCompleteCallback(const commit_signal_t::slot_type& cb);
protected:
void refresh();
@ -107,6 +112,8 @@ private:
uuid_vector_t mIDs;
LLAvatarListItem::ContextMenu* mContextMenu;
commit_signal_t mRefreshCompleteSignal;
};
/** Abstract comparator for avatar items */

35
indra/newview/llchiclet.cpp
View File

@ -51,7 +51,7 @@
#include "lltransientfloatermgr.h"
static LLDefaultChildRegistry::Register<LLChicletPanel> t1("chiclet_panel");
static LLDefaultChildRegistry::Register<LLTalkButton> t2("chiclet_talk");
static LLDefaultChildRegistry::Register<LLTalkButton> t2("talk_button");
static LLDefaultChildRegistry::Register<LLNotificationChiclet> t3("chiclet_notification");
static LLDefaultChildRegistry::Register<LLIMP2PChiclet> t4("chiclet_im_p2p");
static LLDefaultChildRegistry::Register<LLIMGroupChiclet> t5("chiclet_im_group");
@ -830,13 +830,21 @@ LLChicletPanel::~LLChicletPanel()
void im_chiclet_callback(LLChicletPanel* panel, const LLSD& data){
LLUUID session_id = data["session_id"].asUUID();
S32 unread = data["num_unread"].asInteger();
LLIMFloater* im_floater = LLIMFloater::findInstance(session_id);
if (im_floater && im_floater->getVisible())
{
unread = 0;
}
std::list<LLChiclet*> chiclets = LLIMChiclet::sFindChicletsSignal(session_id);
std::list<LLChiclet *>::iterator iter;
for (iter = chiclets.begin(); iter != chiclets.end(); iter++) {
LLChiclet* chiclet = *iter;
if (chiclet != NULL)
{
chiclet->setCounter(data["num_unread"].asInteger());
chiclet->setCounter(unread);
}
else
{
@ -1257,27 +1265,7 @@ LLTalkButton::Params::Params()
, show_button("show_button")
, monitor("monitor")
{
// *TODO Vadim: move hardcoded labels (!) and other params to XUI.
speak_button.name("left");
speak_button.label("Speak");
speak_button.label_selected("Speak");
speak_button.font(LLFontGL::getFontSansSerifSmall());
speak_button.tab_stop(false);
speak_button.is_toggle(true);
// Use default button art. JC
//speak_button.image_selected(LLUI::getUIImage("SegmentedBtn_Left_Selected"));
//speak_button.image_unselected(LLUI::getUIImage("SegmentedBtn_Left_Off"));
show_button.name("right");
show_button.rect(LLRect(0, 0, 20, 0));
show_button.tab_stop(false);
show_button.is_toggle(true);
show_button.image_selected(LLUI::getUIImage("ComboButton_Selected"));
show_button.image_unselected(LLUI::getUIImage("ComboButton_Off"));
monitor.name("monitor");
// *TODO: Make this data driven.
monitor.rect(LLRect(0, 18, 18, 0));
// See widgets/talk_button.xml
}
LLTalkButton::LLTalkButton(const Params& p)
@ -1333,6 +1321,7 @@ LLTalkButton::LLTalkButton(const Params& p)
// never show "muted" because you can't mute yourself
mOutputMonitor->setIsMuted(false);
mOutputMonitor->setIsAgentControl(true);
}
LLTalkButton::~LLTalkButton()

6
indra/newview/llfavoritesbar.cpp
View File

@ -437,7 +437,7 @@ BOOL LLFavoritesBarCtrl::handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
}
else
{
LLUUID favorites_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_FAVORITE);
const LLUUID favorites_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_FAVORITE);
if (item->getParentUUID() == favorites_id)
{
llwarns << "Attemt to copy a favorite item into the same folder." << llendl;
@ -539,7 +539,7 @@ void LLFavoritesBarCtrl::handleNewFavoriteDragAndDrop(LLInventoryItem *item, con
LLToolDragAndDrop* tool_dad = LLToolDragAndDrop::getInstance();
if (tool_dad->getSource() == LLToolDragAndDrop::SOURCE_NOTECARD)
{
viewer_item->setType(LLAssetType::AT_FAVORITE);
viewer_item->setType(LLAssetType::AT_LANDMARK);
copy_inventory_from_notecard(tool_dad->getObjectID(), tool_dad->getSourceID(), viewer_item.get(), gInventoryCallbacks.registerCB(cb));
}
else
@ -561,7 +561,7 @@ void LLFavoritesBarCtrl::changed(U32 mask)
{
if (mFavoriteFolderId.isNull())
{
mFavoriteFolderId = gInventory.findCategoryUUIDForType(LLAssetType::AT_FAVORITE);
mFavoriteFolderId = gInventory.findCategoryUUIDForType(LLFolderType::FT_FAVORITE);
if (mFavoriteFolderId.notNull())
{

2
indra/newview/llfloateranimpreview.cpp
View File

@ -989,7 +989,7 @@ void LLFloaterAnimPreview::onBtnOK(void* userdata)
name,
desc,
0,
LLAssetType::AT_NONE,
LLFolderType::FT_NONE,
LLInventoryType::IT_ANIMATION,
LLFloaterPerms::getNextOwnerPerms(), LLFloaterPerms::getGroupPerms(), LLFloaterPerms::getEveryonePerms(),
name,

1
indra/newview/llfloaterbulkpermission.cpp
View File

@ -264,7 +264,6 @@ void LLFloaterBulkPermission::handleInventory(LLViewerObject* viewer_obj, Invent
( asstype == LLAssetType::AT_BODYPART && gSavedSettings.getBOOL("BulkChangeIncludeBodyParts" )) ||
( asstype == LLAssetType::AT_CLOTHING && gSavedSettings.getBOOL("BulkChangeIncludeClothing" )) ||
( asstype == LLAssetType::AT_GESTURE && gSavedSettings.getBOOL("BulkChangeIncludeGestures" )) ||
( asstype == LLAssetType::AT_FAVORITE && gSavedSettings.getBOOL("BulkChangeIncludeFavourite" )) ||
( asstype == LLAssetType::AT_NOTECARD && gSavedSettings.getBOOL("BulkChangeIncludeNotecards" )) ||
( asstype == LLAssetType::AT_OBJECT && gSavedSettings.getBOOL("BulkChangeIncludeObjects" )) ||
( asstype == LLAssetType::AT_LSL_TEXT && gSavedSettings.getBOOL("BulkChangeIncludeScripts" )) ||

2
indra/newview/llfloaterbuy.cpp
View File

@ -293,7 +293,7 @@ void LLFloaterBuy::onClickBuy()
{
// Put the items where we put new folders.
LLUUID category_id;
category_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_OBJECT);
category_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_OBJECT);
// *NOTE: doesn't work for multiple object buy, which UI does not
// currently support sale info is used for verification only, if

2
indra/newview/llfloaterbuycontents.cpp
View File

@ -286,7 +286,7 @@ void LLFloaterBuyContents::onClickBuy()
// Put the items where we put new folders.
LLUUID category_id;
category_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_CATEGORY);
category_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_CATEGORY);
// *NOTE: doesn't work for multiple object buy, which UI does not
// currently support sale info is used for verification only, if

1
indra/newview/llfloaterinventory.cpp
View File

@ -40,6 +40,7 @@
#include "llinventorymodel.h"
#include "llpanelmaininventory.h"
#include "llresmgr.h"
#include "llviewerfoldertype.h"
///----------------------------------------------------------------------------
/// LLFloaterInventory

1
indra/newview/llfloaterinventory.h
View File

@ -35,6 +35,7 @@
#define LL_LLFLOATERINVENTORY_H
#include "llfloater.h"
#include "llfoldertype.h"
class LLInventoryPanel;
class LLPanelMainInventory;

2
indra/newview/llfloaternamedesc.cpp
View File

@ -176,7 +176,7 @@ void LLFloaterNameDesc::onBtnOK( )
upload_new_resource(mFilenameAndPath, // file
childGetValue("name_form").asString(),
childGetValue("description_form").asString(),
0, LLAssetType::AT_NONE, LLInventoryType::IT_NONE,
0, LLFolderType::FT_NONE, LLInventoryType::IT_NONE,
LLFloaterPerms::getNextOwnerPerms(), LLFloaterPerms::getGroupPerms(), LLFloaterPerms::getEveryonePerms(),
display_name, callback, expected_upload_cost, nruserdata);
closeFloater(false);

4
indra/newview/llfloateropenobject.cpp
View File

@ -158,14 +158,14 @@ void LLFloaterOpenObject::moveToInventory(bool wear)
if (wear)
{
parent_category_id = gInventory.findCategoryUUIDForType(
LLAssetType::AT_CLOTHING);
LLFolderType::FT_CLOTHING);
}
else
{
parent_category_id = gInventory.getRootFolderID();
}
LLUUID category_id = gInventory.createNewCategory(parent_category_id,
LLAssetType::AT_NONE,
LLFolderType::FT_NONE,
name);
LLCatAndWear* data = new LLCatAndWear;

4
indra/newview/llfloaterreporter.cpp
View File

@ -770,7 +770,7 @@ void LLFloaterReporter::takeScreenshot()
if (COMPLAINT_REPORT == mReportType)
{
mResourceDatap->mAssetInfo.mType = LLAssetType::AT_TEXTURE;
mResourceDatap->mPreferredLocation = LLAssetType::EType(-2);
mResourceDatap->mPreferredLocation = LLFolderType::EType(LLResourceData::INVALID_LOCATION);
}
else
{
@ -838,7 +838,7 @@ void LLFloaterReporter::uploadDoneCallback(const LLUUID &uuid, void *user_data,
}
EReportType report_type = UNKNOWN_REPORT;
if (data->mPreferredLocation == -2)
if (data->mPreferredLocation == LLResourceData::INVALID_LOCATION)
{
report_type = COMPLAINT_REPORT;
}

2
indra/newview/llfloatersnapshot.cpp
View File

@ -980,7 +980,7 @@ void LLSnapshotLivePreview::saveTexture()
"Snapshot : " + pos_string,
"Taken by " + who_took_it + " at " + pos_string,
0,
LLAssetType::AT_SNAPSHOT_CATEGORY,
LLFolderType::FT_SNAPSHOT_CATEGORY,
LLInventoryType::IT_SNAPSHOT,
PERM_ALL, // Note: Snapshots to inventory is a special case of content upload
PERM_NONE, // that ignores the user's premissions preferences and continues to

2
indra/newview/llfloaterworldmap.cpp
View File

@ -327,7 +327,7 @@ void LLFloaterWorldMap::onOpen(const LLSD& key)
LLFirstUse::useMap();
// Start speculative download of landmarks
LLUUID landmark_folder_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_LANDMARK);
const LLUUID landmark_folder_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_LANDMARK);
gInventory.startBackgroundFetch(landmark_folder_id);
childSetFocus("location", TRUE);

5
indra/newview/llfolderview.cpp
View File

@ -55,6 +55,7 @@
#include "llviewermenu.h"
#include "lluictrlfactory.h"
#include "llviewercontrol.h"
#include "llviewerfoldertype.h"
#include "llviewerwindow.h"
#include "llvoavatar.h"
#include "llfloaterproperties.h"
@ -1108,7 +1109,7 @@ void LLFolderView::propertiesSelectedItems( void )
}
}
void LLFolderView::changeType(LLInventoryModel *model, LLAssetType::EType new_folder_type)
void LLFolderView::changeType(LLInventoryModel *model, LLFolderType::EType new_folder_type)
{
LLFolderBridge *folder_bridge = LLFolderBridge::sSelf;
@ -1958,7 +1959,7 @@ bool LLFolderView::doToSelected(LLInventoryModel* model, const LLSD& userdata)
if (action.length() > change_folder_string.length() &&
(action.compare(0,change_folder_string.length(),"change_folder_type_") == 0))
{
LLAssetType::EType new_folder_type = LLFolderType::lookupTypeFromXUIName(action.substr(change_folder_string.length()));
LLFolderType::EType new_folder_type = LLViewerFolderType::lookupTypeFromXUIName(action.substr(change_folder_string.length()));
changeType(model, new_folder_type);
return true;
}

2
indra/newview/llfolderview.h
View File

@ -192,7 +192,7 @@ public:
void propertiesSelectedItems( void );
// change the folder type
void changeType(LLInventoryModel *model, LLAssetType::EType new_folder_type);
void changeType(LLInventoryModel *model, LLFolderType::EType new_folder_type);
void autoOpenItem(LLFolderViewFolder* item);
void closeAutoOpenedFolders();

3
indra/newview/llfoldervieweventlistener.h
View File

@ -32,6 +32,7 @@
#define LLFOLDERVIEWEVENTLISTENER_H
#include "lldarray.h" // JAMESDEBUG convert to std::vector
#include "llfoldertype.h"
#include "llfontgl.h" // just for StyleFlags enum
#include "llpointer.h"
@ -57,7 +58,7 @@ public:
virtual const LLUUID& getUUID() const = 0;
virtual time_t getCreationDate() const = 0; // UTC seconds
virtual PermissionMask getPermissionMask() const = 0;
virtual LLAssetType::EType getPreferredType() const = 0;
virtual LLFolderType::EType getPreferredType() const = 0;
virtual LLPointer<LLUIImage> getIcon() const = 0;
virtual LLFontGL::StyleFlags getLabelStyle() const = 0;
virtual std::string getLabelSuffix() const = 0;

10
indra/newview/llfolderviewitem.cpp
View File

@ -248,13 +248,13 @@ void LLFolderViewItem::refreshFromListener()
if(mListener)
{
mLabel = mListener->getDisplayName();
LLAssetType::EType preferred_type = mListener->getPreferredType();
LLFolderType::EType preferred_type = mListener->getPreferredType();
// *TODO: to be removed when database supports multi language. This is a
// temporary attempt to display the inventory folder in the user locale.
// mantipov: *NOTE: be sure this code is synchronized with LLFriendCardsManager::findChildFolderUUID
// it uses the same way to find localized string
if (LLAssetType::lookupIsProtectedCategoryType(preferred_type))
if (LLFolderType::lookupIsProtectedType(preferred_type))
{
LLTrans::findString(mLabel, "InvFolder " + mLabel);
};
@ -1753,7 +1753,7 @@ bool LLFolderViewFolder::isTrash() const
{
if (mAmTrash == LLFolderViewFolder::UNKNOWN)
{
mAmTrash = mListener->getUUID() == gInventory.findCategoryUUIDForType(LLAssetType::AT_TRASH, false) ? LLFolderViewFolder::TRASH : LLFolderViewFolder::NOT_TRASH;
mAmTrash = mListener->getUUID() == gInventory.findCategoryUUIDForType(LLFolderType::FT_TRASH, false) ? LLFolderViewFolder::TRASH : LLFolderViewFolder::NOT_TRASH;
}
return mAmTrash == LLFolderViewFolder::TRASH;
}
@ -2167,7 +2167,7 @@ BOOL LLFolderViewFolder::handleDoubleClick( S32 x, S32 y, MASK mask )
{
const LLUUID &cat_uuid = getListener()->getUUID();
const LLViewerInventoryCategory *cat = gInventory.getCategory(cat_uuid);
if (cat && cat->getPreferredType() == LLAssetType::AT_OUTFIT)
if (cat && cat->getPreferredType() == LLFolderType::FT_OUTFIT)
{
getListener()->performAction(NULL, NULL,"replaceoutfit");
return TRUE;
@ -2490,7 +2490,7 @@ bool LLInventorySort::operator()(const LLFolderViewItem* const& a, const LLFolde
&& b->getListener()->getInventoryType() == LLInventoryType::IT_LANDMARK)
{
static LLUUID favorites_folder_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_FAVORITE);
static const LLUUID& favorites_folder_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_FAVORITE);
LLUUID a_uuid = a->getParentFolder()->getListener()->getUUID();
LLUUID b_uuid = b->getParentFolder()->getListener()->getUUID();

8
indra/newview/llfriendcard.cpp
View File

@ -135,14 +135,14 @@ const LLUUID LLFriendCardsManager::extractAvatarID(const LLUUID& avatarID)
// and this method must be called before any actions with friend list
void LLFriendCardsManager::ensureFriendFoldersExist()
{
LLUUID callingCardsFolderID = gInventory.findCategoryUUIDForType(LLAssetType::AT_CALLINGCARD);
const LLUUID callingCardsFolderID = gInventory.findCategoryUUIDForType(LLFolderType::FT_CALLINGCARD);
LLUUID friendFolderUUID = findFriendFolderUUIDImpl();
if (friendFolderUUID.isNull())
{
friendFolderUUID = gInventory.createNewCategory(callingCardsFolderID,
LLAssetType::AT_CALLINGCARD, get_friend_folder_name());
LLFolderType::FT_CALLINGCARD, get_friend_folder_name());
}
LLUUID friendAllSubfolderUUID = findFriendAllSubfolderUUIDImpl();
@ -150,7 +150,7 @@ void LLFriendCardsManager::ensureFriendFoldersExist()
if (friendAllSubfolderUUID.isNull())
{
friendAllSubfolderUUID = gInventory.createNewCategory(friendFolderUUID,
LLAssetType::AT_CALLINGCARD, get_friend_all_subfolder_name());
LLFolderType::FT_CALLINGCARD, get_friend_all_subfolder_name());
}
}
@ -351,7 +351,7 @@ void LLFriendCardsManager::collectFriendsLists(folderid_buddies_map_t& folderBud
/************************************************************************/
const LLUUID& LLFriendCardsManager::findFriendFolderUUIDImpl() const
{
LLUUID callingCardsFolderID = gInventory.findCategoryUUIDForType(LLAssetType::AT_CALLINGCARD);
const LLUUID callingCardsFolderID = gInventory.findCategoryUUIDForType(LLFolderType::FT_CALLINGCARD);
std::string friendFolderName = get_friend_folder_name();

7
indra/newview/llimfloater.cpp
View File

@ -106,6 +106,8 @@ void LLIMFloater::onFocusReceived()
// virtual
void LLIMFloater::onClose(bool app_quitting)
{
if (!gIMMgr->hasSession(mSessionID)) return;
setTyping(false);
gIMMgr->leaveSession(mSessionID);
}
@ -234,7 +236,10 @@ BOOL LLIMFloater::postBuild()
mChatHistory = getChild<LLChatHistory>("chat_history");
setTitle(LLIMModel::instance().getName(mSessionID));
std::string session_name(LLIMModel::instance().getName(mSessionID));
LLStringUtil::toUpper(session_name);
setTitle(session_name);
setDocked(true);
mTypingStart = LLTrans::getString("IM_typing_start_string");

19
indra/newview/llinspectavatar.cpp
View File

@ -188,7 +188,8 @@ LLInspectAvatar::LLInspectAvatar(const LLSD& sd)
{
mCommitCallbackRegistrar.add("InspectAvatar.ViewProfile", boost::bind(&LLInspectAvatar::onClickViewProfile, this));
mCommitCallbackRegistrar.add("InspectAvatar.AddFriend", boost::bind(&LLInspectAvatar::onClickAddFriend, this));
mCommitCallbackRegistrar.add("InspectAvatar.IM", boost::bind(&LLInspectAvatar::onClickIM, this));
mCommitCallbackRegistrar.add("InspectAvatar.IM",
boost::bind(&LLInspectAvatar::onClickIM, this));
mCommitCallbackRegistrar.add("InspectAvatar.Teleport", boost::bind(&LLInspectAvatar::onClickTeleport, this));
mCommitCallbackRegistrar.add("InspectAvatar.InviteToGroup", boost::bind(&LLInspectAvatar::onClickInviteToGroup, this));
mCommitCallbackRegistrar.add("InspectAvatar.Pay", boost::bind(&LLInspectAvatar::onClickPay, this));
@ -306,7 +307,21 @@ void LLInspectAvatar::requestUpdate()
// You can't re-add someone as a friend if they are already your friend
bool is_friend = LLAvatarTracker::instance().getBuddyInfo(mAvatarID) != NULL;
bool is_self = (mAvatarID == gAgentID);
childSetEnabled("add_friend_btn", !is_friend && !is_self);
if (is_self)
{
getChild<LLUICtrl>("add_friend_btn")->setVisible(false);
getChild<LLUICtrl>("im_btn")->setVisible(false);
}
else if (is_friend)
{
getChild<LLUICtrl>("add_friend_btn")->setVisible(false);
getChild<LLUICtrl>("im_btn")->setVisible(true);
}
else
{
getChild<LLUICtrl>("add_friend_btn")->setVisible(true);
getChild<LLUICtrl>("im_btn")->setVisible(false);
}
// Use an avatar_icon even though the image id will come down with the
// avatar properties because the avatar_icon code maintains a cache of icons

95
indra/newview/llinventorybridge.cpp
View File

@ -78,6 +78,7 @@
#include "llscrollcontainer.h"
#include "llimview.h"
#include "lltooldraganddrop.h"
#include "llviewerfoldertype.h"
#include "llviewertexturelist.h"
#include "llviewerinventory.h"
#include "llviewerobjectlist.h"
@ -85,6 +86,7 @@
#include "llvoavatar.h"
#include "llwearable.h"
#include "llwearablelist.h"
#include "llviewerassettype.h"
#include "llviewermessage.h"
#include "llviewerregion.h"
#include "llvoavatarself.h"
@ -202,9 +204,9 @@ PermissionMask LLInvFVBridge::getPermissionMask() const
}
// virtual
LLAssetType::EType LLInvFVBridge::getPreferredType() const
LLFolderType::EType LLInvFVBridge::getPreferredType() const
{
return LLAssetType::AT_NONE;
return LLFolderType::FT_NONE;
}
@ -339,7 +341,7 @@ void LLInvFVBridge::removeBatchNoCheck(LLDynamicArray<LLFolderViewEventListener*
LLInventoryModel* model = getInventoryModel();
if(!model) return;
LLMessageSystem* msg = gMessageSystem;
LLUUID trash_id = model->findCategoryUUIDForType(LLAssetType::AT_TRASH);
const LLUUID trash_id = model->findCategoryUUIDForType(LLFolderType::FT_TRASH);
LLViewerInventoryItem* item = NULL;
LLViewerInventoryCategory* cat = NULL;
std::vector<LLUUID> move_ids;
@ -504,7 +506,7 @@ BOOL LLInvFVBridge::isClipboardPasteableAsLink() const
}
}
const LLViewerInventoryCategory *cat = model->getCategory(objects.get(i));
if (cat && !LLAssetType::lookupCanLink(cat->getPreferredType()))
if (cat && !LLFolderType::lookupIsProtectedType(cat->getPreferredType()))
{
return FALSE;
}
@ -645,7 +647,7 @@ BOOL LLInvFVBridge::startDrag(EDragAndDropType* type, LLUUID* id) const
if(obj)
{
*type = LLAssetType::lookupDragAndDropType(obj->getActualType());
*type = LLViewerAssetType::lookupDragAndDropType(obj->getActualType());
if(*type == DAD_NONE)
{
return FALSE;
@ -686,7 +688,7 @@ BOOL LLInvFVBridge::isInTrash() const
{
LLInventoryModel* model = getInventoryModel();
if(!model) return FALSE;
const LLUUID trash_id = model->findCategoryUUIDForType(LLAssetType::AT_TRASH);
const LLUUID trash_id = model->findCategoryUUIDForType(LLFolderType::FT_TRASH);
return model->isObjectDescendentOf(mUUID, trash_id);
}
@ -699,7 +701,7 @@ BOOL LLInvFVBridge::isLinkedObjectInTrash() const
{
LLInventoryModel* model = getInventoryModel();
if(!model) return FALSE;
const LLUUID trash_id = model->findCategoryUUIDForType(LLAssetType::AT_TRASH);
const LLUUID trash_id = model->findCategoryUUIDForType(LLFolderType::FT_TRASH);
return model->isObjectDescendentOf(obj->getLinkedUUID(), trash_id);
}
return FALSE;
@ -717,7 +719,7 @@ BOOL LLInvFVBridge::isCOFFolder() const
{
const LLInventoryModel* model = getInventoryModel();
if(!model) return TRUE;
const LLUUID cof_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_CURRENT_OUTFIT);
const LLUUID cof_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_CURRENT_OUTFIT);
if (mUUID == cof_id || model->isObjectDescendentOf(mUUID, cof_id))
{
return TRUE;
@ -1044,7 +1046,7 @@ void LLItemBridge::restoreItem()
if(item)
{
LLInventoryModel* model = getInventoryModel();
const LLUUID new_parent = model->findCategoryUUIDForType(item->getType());
const LLUUID new_parent = model->findCategoryUUIDForType(LLFolderType::assetTypeToFolderType(item->getType()));
// do not restamp on restore.
LLInvFVBridge::changeItemParent(model, item, new_parent, FALSE);
}
@ -1077,7 +1079,7 @@ void LLItemBridge::restoreToWorld()
}
// Check if it's in the trash. (again similar to the normal rez logic)
const LLUUID trash_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_TRASH);
const LLUUID trash_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_TRASH);
if(gInventory.isObjectDescendentOf(itemp->getUUID(), trash_id))
{
remove_from_inventory = TRUE;
@ -1272,7 +1274,7 @@ BOOL LLItemBridge::removeItem()
LLPreview::hide(mUUID, TRUE);
LLInventoryModel* model = getInventoryModel();
if(!model) return FALSE;
LLUUID trash_id = model->findCategoryUUIDForType(LLAssetType::AT_TRASH);
const LLUUID trash_id = model->findCategoryUUIDForType(LLFolderType::FT_TRASH);
LLViewerInventoryItem* item = getItem();
// if item is not already in trash
@ -1365,7 +1367,7 @@ BOOL LLFolderBridge::isItemMovable() const
LLInventoryObject* obj = getInventoryObject();
if(obj)
{
return (!LLAssetType::lookupIsProtectedCategoryType(((LLInventoryCategory*)obj)->getPreferredType()));
return (!LLFolderType::lookupIsProtectedType(((LLInventoryCategory*)obj)->getPreferredType()));
}
return FALSE;
}
@ -1401,7 +1403,7 @@ BOOL LLFolderBridge::isItemRemovable()
return FALSE;
}
if(LLAssetType::lookupIsProtectedCategoryType(category->getPreferredType()))
if(LLFolderType::lookupIsProtectedType(category->getPreferredType()))
{
return FALSE;
}
@ -1414,7 +1416,7 @@ BOOL LLFolderBridge::isItemRemovable()
for( i = 0; i < descendent_categories.count(); i++ )
{
LLInventoryCategory* category = descendent_categories[i];
if(LLAssetType::lookupIsProtectedCategoryType(category->getPreferredType()))
if(LLFolderType::lookupIsProtectedType(category->getPreferredType()))
{
return FALSE;
}
@ -1591,20 +1593,20 @@ BOOL LLFolderBridge::dragCategoryIntoFolder(LLInventoryCategory* inv_cat,
const LLUUID& cat_id = inv_cat->getUUID();
// Is the destination the trash?
const LLUUID trash_id = model->findCategoryUUIDForType(LLAssetType::AT_TRASH);
const LLUUID trash_id = model->findCategoryUUIDForType(LLFolderType::FT_TRASH);
BOOL move_is_into_trash = (mUUID == trash_id)
|| model->isObjectDescendentOf(mUUID, trash_id);
BOOL is_movable = (!LLAssetType::lookupIsProtectedCategoryType(inv_cat->getPreferredType()));
LLUUID current_outfit_id = model->findCategoryUUIDForType(LLAssetType::AT_CURRENT_OUTFIT);
BOOL is_movable = (!LLFolderType::lookupIsProtectedType(inv_cat->getPreferredType()));
const LLUUID current_outfit_id = model->findCategoryUUIDForType(LLFolderType::FT_CURRENT_OUTFIT);
BOOL move_is_into_current_outfit = (mUUID == current_outfit_id);
BOOL move_is_into_outfit = (getCategory() && getCategory()->getPreferredType()==LLAssetType::AT_OUTFIT);
BOOL move_is_into_outfit = (getCategory() && getCategory()->getPreferredType()==LLFolderType::FT_OUTFIT);
if (move_is_into_current_outfit || move_is_into_outfit)
{
// BAP - restrictions?
is_movable = true;
}
if (mUUID == gInventory.findCategoryUUIDForType(LLAssetType::AT_FAVORITE))
if (mUUID == gInventory.findCategoryUUIDForType(LLFolderType::FT_FAVORITE))
{
is_movable = FALSE; // It's generally movable but not into Favorites folder. EXT-1604
}
@ -1616,7 +1618,7 @@ BOOL LLFolderBridge::dragCategoryIntoFolder(LLInventoryCategory* inv_cat,
for( i = 0; i < descendent_categories.count(); i++ )
{
LLInventoryCategory* category = descendent_categories[i];
if(LLAssetType::lookupIsProtectedCategoryType(category->getPreferredType()))
if(LLFolderType::lookupIsProtectedType(category->getPreferredType()))
{
// ...can't move "special folders" like Textures
is_movable = FALSE;
@ -1849,8 +1851,8 @@ bool LLFindCOFValidItems::operator()(LLInventoryCategory* cat,
LLViewerInventoryCategory *linked_category = ((LLViewerInventoryItem*)item)->getLinkedCategory(); // BAP - safe?
// BAP remove AT_NONE support after ensembles are fully working?
return (linked_category &&
((linked_category->getPreferredType() == LLAssetType::AT_NONE) ||
(LLAssetType::lookupIsEnsembleCategoryType(linked_category->getPreferredType()))));
((linked_category->getPreferredType() == LLFolderType::FT_NONE) ||
(LLFolderType::lookupIsEnsembleType(linked_category->getPreferredType()))));
}
}
@ -2152,7 +2154,7 @@ void LLFolderBridge::determineFolderType()
BOOL LLFolderBridge::isItemRenameable() const
{
LLViewerInventoryCategory* cat = (LLViewerInventoryCategory*)getCategory();
if(cat && !LLAssetType::lookupIsProtectedCategoryType(cat->getPreferredType())
if(cat && !LLFolderType::lookupIsProtectedType(cat->getPreferredType())
&& (cat->getOwnerID() == gAgent.getID()))
{
return TRUE;
@ -2167,15 +2169,15 @@ void LLFolderBridge::restoreItem()
if(cat)
{
LLInventoryModel* model = getInventoryModel();
LLUUID new_parent = model->findCategoryUUIDForType(cat->getType());
const LLUUID new_parent = model->findCategoryUUIDForType(LLFolderType::assetTypeToFolderType(cat->getType()));
// do not restamp children on restore
LLInvFVBridge::changeCategoryParent(model, cat, new_parent, FALSE);
}
}
LLAssetType::EType LLFolderBridge::getPreferredType() const
LLFolderType::EType LLFolderBridge::getPreferredType() const
{
LLAssetType::EType preferred_type = LLAssetType::AT_NONE;
LLFolderType::EType preferred_type = LLFolderType::FT_NONE;
LLViewerInventoryCategory* cat = getCategory();
if(cat)
{
@ -2188,7 +2190,7 @@ LLAssetType::EType LLFolderBridge::getPreferredType() const
// Icons for folders are based on the preferred type
LLUIImagePtr LLFolderBridge::getIcon() const
{
LLAssetType::EType preferred_type = LLAssetType::AT_NONE;
LLFolderType::EType preferred_type = LLFolderType::FT_NONE;
LLViewerInventoryCategory* cat = getCategory();
if(cat)
{
@ -2197,7 +2199,7 @@ LLUIImagePtr LLFolderBridge::getIcon() const
return getIcon(preferred_type);
}
LLUIImagePtr LLFolderBridge::getIcon(LLAssetType::EType preferred_type)
LLUIImagePtr LLFolderBridge::getIcon(LLFolderType::EType preferred_type)
{
// we only have one folder image now
return LLUI::getUIImage("Inv_FolderClosed");
@ -2236,7 +2238,7 @@ BOOL LLFolderBridge::removeItem()
LLInventoryModel* model = getInventoryModel();
if(!model) return FALSE;
LLUUID trash_id = model->findCategoryUUIDForType(LLAssetType::AT_TRASH);
const LLUUID trash_id = model->findCategoryUUIDForType(LLFolderType::FT_TRASH);
// Look for any gestures and deactivate them
LLInventoryModel::cat_array_t descendent_categories;
@ -2354,11 +2356,11 @@ void LLFolderBridge::folderOptionsMenu()
if(!model) return;
const LLInventoryCategory* category = model->getCategory(mUUID);
LLAssetType::EType type = category->getPreferredType();
const bool is_default_folder = category && LLAssetType::lookupIsProtectedCategoryType(type);
LLFolderType::EType type = category->getPreferredType();
const bool is_default_folder = category && LLFolderType::lookupIsProtectedType(type);
// BAP change once we're no longer treating regular categories as ensembles.
const bool is_ensemble = category && (type == LLAssetType::AT_NONE ||
LLAssetType::lookupIsEnsembleCategoryType(type));
const bool is_ensemble = category && (type == LLFolderType::FT_NONE ||
LLFolderType::lookupIsEnsembleType(type));
// calling card related functionality for folders.
@ -2424,8 +2426,8 @@ void LLFolderBridge::buildContextMenu(LLMenuGL& menu, U32 flags)
// std::vector<std::string> disabled_items;
LLInventoryModel* model = getInventoryModel();
if(!model) return;
LLUUID trash_id = model->findCategoryUUIDForType(LLAssetType::AT_TRASH);
LLUUID lost_and_found_id = model->findCategoryUUIDForType(LLAssetType::AT_LOST_AND_FOUND);
const LLUUID trash_id = model->findCategoryUUIDForType(LLFolderType::FT_TRASH);
const LLUUID lost_and_found_id = model->findCategoryUUIDForType(LLFolderType::FT_LOST_AND_FOUND);
mItems.clear(); //adding code to clear out member Items (which means Items should not have other data here at this point)
mDisabledItems.clear(); //adding code to clear out disabled members from previous
@ -2455,7 +2457,6 @@ void LLFolderBridge::buildContextMenu(LLMenuGL& menu, U32 flags)
else if(isAgentInventory()) // do not allow creating in library
{
LLViewerInventoryCategory *cat = getCategory();
// BAP removed protected check to re-enable standard ops in untyped folders.
// Not sure what the right thing is to do here.
if (!isCOFFolder() && cat /*&&
@ -2472,7 +2473,7 @@ void LLFolderBridge::buildContextMenu(LLMenuGL& menu, U32 flags)
mItems.push_back(std::string("Change Type"));
LLViewerInventoryCategory *cat = getCategory();
if (cat && LLAssetType::lookupIsProtectedCategoryType(cat->getPreferredType()))
if (cat && LLFolderType::lookupIsProtectedType(cat->getPreferredType()))
{
mDisabledItems.push_back(std::string("Change Type"));
}
@ -2482,7 +2483,7 @@ void LLFolderBridge::buildContextMenu(LLMenuGL& menu, U32 flags)
else
{
// Want some but not all of the items from getClipboardEntries for outfits.
if (cat && cat->getPreferredType()==LLAssetType::AT_OUTFIT)
if (cat && cat->getPreferredType()==LLFolderType::FT_OUTFIT)
{
mItems.push_back(std::string("Rename"));
mItems.push_back(std::string("Delete"));
@ -2618,7 +2619,7 @@ void LLFolderBridge::createNewCategory(void* user_data)
if(!model) return;
LLUUID id;
id = model->createNewCategory(bridge->getUUID(),
LLAssetType::AT_NONE,
LLFolderType::FT_NONE,
LLStringUtil::null);
model->notifyObservers();
@ -2703,7 +2704,7 @@ void LLFolderBridge::createWearable(LLFolderBridge* bridge, EWearableType type)
// Separate function so can be called by global menu as well as right-click
// menu.
// static
void LLFolderBridge::createWearable(LLUUID parent_id, EWearableType type)
void LLFolderBridge::createWearable(const LLUUID &parent_id, EWearableType type)
{
LLWearable* wearable = LLWearableList::instance().createNewWearable(type);
LLAssetType::EType asset_type = wearable->getAssetType();
@ -2846,17 +2847,17 @@ BOOL LLFolderBridge::dragItemIntoFolder(LLInventoryItem* inv_item,
break;
case LLAssetType::AT_CATEGORY:
is_movable = !LLAssetType::lookupIsProtectedCategoryType(((LLInventoryCategory*)inv_item)->getPreferredType());
is_movable = !LLFolderType::lookupIsProtectedType(((LLInventoryCategory*)inv_item)->getPreferredType());
break;
default:
break;
}
LLUUID trash_id = model->findCategoryUUIDForType(LLAssetType::AT_TRASH);
const LLUUID trash_id = model->findCategoryUUIDForType(LLFolderType::FT_TRASH);
BOOL move_is_into_trash = (mUUID == trash_id) || model->isObjectDescendentOf(mUUID, trash_id);
LLUUID current_outfit_id = model->findCategoryUUIDForType(LLAssetType::AT_CURRENT_OUTFIT);
const LLUUID current_outfit_id = model->findCategoryUUIDForType(LLFolderType::FT_CURRENT_OUTFIT);
BOOL move_is_into_current_outfit = (mUUID == current_outfit_id);
BOOL move_is_into_outfit = (getCategory() && getCategory()->getPreferredType()==LLAssetType::AT_OUTFIT);
BOOL move_is_into_outfit = (getCategory() && getCategory()->getPreferredType()==LLFolderType::FT_OUTFIT);
if(is_movable && move_is_into_trash)
{
@ -2886,7 +2887,7 @@ BOOL LLFolderBridge::dragItemIntoFolder(LLInventoryItem* inv_item,
.isObjDirectDescendentOfCategory (inv_item, getCategory());
}
LLUUID favorites_id = model->findCategoryUUIDForType(LLAssetType::AT_FAVORITE);
const LLUUID& favorites_id = model->findCategoryUUIDForType(LLFolderType::FT_FAVORITE);
// we can move item inside a folder only if this folder is Favorites. See EXT-719
accept = is_movable && ((mUUID != inv_item->getParentUUID()) || (mUUID == favorites_id));
@ -4934,7 +4935,7 @@ void LLLSLTextBridgeAction::doIt()
BOOL LLWearableBridgeAction::isInTrash() const
{
if(!mModel) return FALSE;
LLUUID trash_id = mModel->findCategoryUUIDForType(LLAssetType::AT_TRASH);
const LLUUID trash_id = mModel->findCategoryUUIDForType(LLFolderType::FT_TRASH);
return mModel->isObjectDescendentOf(mUUID, trash_id);
}
@ -5073,7 +5074,7 @@ std::string LLLinkFolderBridge::sPrefix("Link: ");
LLUIImagePtr LLLinkFolderBridge::getIcon() const
{
LLAssetType::EType preferred_type = LLAssetType::AT_NONE;
LLFolderType::EType preferred_type = LLFolderType::FT_NONE;
if (LLViewerInventoryItem *item = getItem())
{
if (const LLViewerInventoryCategory* cat = item->getLinkedCategory())

8
indra/newview/llinventorybridge.h
View File

@ -159,7 +159,7 @@ public:
virtual const std::string& getName() const;
virtual const std::string& getDisplayName() const;
virtual PermissionMask getPermissionMask() const;
virtual LLAssetType::EType getPreferredType() const;
virtual LLFolderType::EType getPreferredType() const;
virtual time_t getCreationDate() const;
virtual LLFontGL::StyleFlags getLabelStyle() const
{
@ -298,9 +298,9 @@ public:
virtual void selectItem();
virtual void restoreItem();
virtual LLAssetType::EType getPreferredType() const;
virtual LLFolderType::EType getPreferredType() const;
virtual LLUIImagePtr getIcon() const;
static LLUIImagePtr getIcon(LLAssetType::EType asset_type);
static LLUIImagePtr getIcon(LLFolderType::EType preferred_type);
virtual BOOL renameItem(const std::string& new_name);
virtual BOOL removeItem();
@ -321,7 +321,7 @@ public:
virtual BOOL copyToClipboard() const;
static void createWearable(LLFolderBridge* bridge, EWearableType type);
static void createWearable(LLUUID parent_folder_id, EWearableType type);
static void createWearable(const LLUUID &parent_folder_id, EWearableType type);
LLViewerInventoryCategory* getCategory() const;

4
indra/newview/llinventoryfunctions.cpp
View File

@ -317,10 +317,6 @@ const std::string& get_item_icon_name(LLAssetType::EType asset_type,
case LLAssetType::AT_GESTURE:
idx = GESTURE_ICON_NAME;
break;
case LLAssetType::AT_FAVORITE:
//TODO - need bette idx
idx = LANDMARK_ICON_NAME;
break;
case LLAssetType::AT_LINK:
idx = LINKITEM_ICON_NAME;
break;

63
indra/newview/llinventorymodel.cpp
View File

@ -49,6 +49,7 @@
#include "llinventoryfunctions.h"
#include "llinventorypanel.h"
#include "llfloaterinventory.h"
#include "llviewerfoldertype.h"
#include "llviewerinventory.h"
#include "llviewermessage.h"
#include "llviewerwindow.h"
@ -316,7 +317,7 @@ void LLInventoryModel::unlockDirectDescendentArrays(const LLUUID& cat_id)
// specifies 'type' as what it defaults to containing. The category is
// not necessarily only for that type. *NOTE: This will create a new
// inventory category on the fly if one does not exist.
LLUUID LLInventoryModel::findCategoryUUIDForType(LLAssetType::EType t, bool create_folder)
const LLUUID LLInventoryModel::findCategoryUUIDForType(LLFolderType::EType t, bool create_folder)
{
const LLUUID &rv = findCatUUID(t);
if(rv.isNull() && isInventoryUsable() && create_folder)
@ -332,10 +333,10 @@ LLUUID LLInventoryModel::findCategoryUUIDForType(LLAssetType::EType t, bool crea
// Internal method which looks for a category with the specified
// preferred type. Returns LLUUID::null if not found.
const LLUUID &LLInventoryModel::findCatUUID(LLAssetType::EType preferred_type) const
const LLUUID &LLInventoryModel::findCatUUID(LLFolderType::EType preferred_type) const
{
const LLUUID &root_id = gInventory.getRootFolderID();
if(LLAssetType::AT_CATEGORY == preferred_type)
if(LLFolderType::FT_CATEGORY == preferred_type)
{
return root_id;
}
@ -363,7 +364,7 @@ const LLUUID &LLInventoryModel::findCatUUID(LLAssetType::EType preferred_type) c
// version will take care of details like what the name should be
// based on preferred type. Returns the UUID of the new category.
LLUUID LLInventoryModel::createNewCategory(const LLUUID& parent_id,
LLAssetType::EType preferred_type,
LLFolderType::EType preferred_type,
const std::string& pname)
{
LLUUID id;
@ -373,9 +374,9 @@ LLUUID LLInventoryModel::createNewCategory(const LLUUID& parent_id,
return id;
}
if(preferred_type == LLAssetType::AT_SIMSTATE)
if(LLFolderType::lookup(preferred_type) == LLFolderType::badLookup())
{
lldebugs << "Attempt to create simstate category." << llendl;
lldebugs << "Attempt to create undefined category." << llendl;
return id;
}
@ -387,7 +388,7 @@ LLUUID LLInventoryModel::createNewCategory(const LLUUID& parent_id,
}
else
{
name.assign(LLAssetType::lookupCategoryName(preferred_type));
name.assign(LLViewerFolderType::lookupNewCategoryName(preferred_type));
}
// Add the category to the internal representation
@ -451,7 +452,7 @@ void LLInventoryModel::collectDescendentsIf(const LLUUID& id,
// Start with categories
if(!include_trash)
{
const LLUUID trash_id = findCategoryUUIDForType(LLAssetType::AT_TRASH);
const LLUUID trash_id = findCategoryUUIDForType(LLFolderType::FT_TRASH);
if(trash_id.notNull() && (trash_id == id))
return;
}
@ -485,7 +486,7 @@ void LLInventoryModel::collectDescendentsIf(const LLUUID& id,
if (item->getActualType() == LLAssetType::AT_LINK_FOLDER)
{
LLViewerInventoryCategory *linked_cat = item->getLinkedCategory();
if (linked_cat && linked_cat->getPreferredType() != LLAssetType::AT_OUTFIT)
if (linked_cat && linked_cat->getPreferredType() != LLFolderType::FT_OUTFIT)
// BAP - was
// LLAssetType::lookupIsEnsembleCategoryType(linked_cat->getPreferredType()))
// Change back once ensemble typing is in place.
@ -665,7 +666,7 @@ U32 LLInventoryModel::updateItem(const LLViewerInventoryItem* item)
if(item->getParentUUID().isNull())
{
LLUUID category_id = findCategoryUUIDForType(new_item->getType());
const LLUUID category_id = findCategoryUUIDForType(LLFolderType::assetTypeToFolderType(new_item->getType()));
new_item->setParent(category_id);
item_array_t* item_array = get_ptr_in_map(mParentChildItemTree, category_id);
if( item_array )
@ -689,7 +690,7 @@ U32 LLInventoryModel::updateItem(const LLViewerInventoryItem* item)
LLUUID parent_id = item->getParentUUID();
if(parent_id == CATEGORIZE_LOST_AND_FOUND_ID)
{
parent_id = findCategoryUUIDForType(LLAssetType::AT_LOST_AND_FOUND);
parent_id = findCategoryUUIDForType(LLFolderType::FT_LOST_AND_FOUND);
new_item->setParent(parent_id);
}
item_array_t* item_array = get_ptr_in_map(mParentChildItemTree, parent_id);
@ -702,7 +703,7 @@ U32 LLInventoryModel::updateItem(const LLViewerInventoryItem* item)
// Whoops! No such parent, make one.
llinfos << "Lost item: " << new_item->getUUID() << " - "
<< new_item->getName() << llendl;
parent_id = findCategoryUUIDForType(LLAssetType::AT_LOST_AND_FOUND);
parent_id = findCategoryUUIDForType(LLFolderType::FT_LOST_AND_FOUND);
new_item->setParent(parent_id);
item_array = get_ptr_in_map(mParentChildItemTree, parent_id);
if(item_array)
@ -1184,7 +1185,7 @@ void LLInventoryModel::mock(const LLUUID& root_id)
root_id,
LLUUID::null,
LLAssetType::AT_CATEGORY,
LLAssetType::lookupCategoryName(LLAssetType::AT_ROOT_CATEGORY),
LLFolderType::lookupNewCategoryName(LLFolderType::FT_ROOT_CATEGORY),
gAgent.getID());
addCategory(cat);
gInventory.buildParentChildMap();
@ -1342,7 +1343,7 @@ void fetchDescendentsResponder::result(const LLSD& content)
item_it != folder_sd["items"].endArray();
++item_it)
{
LLUUID lost_uuid = gInventory.findCategoryUUIDForType(LLAssetType::AT_LOST_AND_FOUND);
const LLUUID lost_uuid = gInventory.findCategoryUUIDForType(LLFolderType::FT_LOST_AND_FOUND);
if (lost_uuid.notNull())
{
LLSD item = *item_it;
@ -2049,11 +2050,11 @@ bool LLInventoryModel::loadSkeleton(
cat->setUUID(folder_id.asUUID());
cat->setParent(parent_id.asUUID());
LLAssetType::EType preferred_type = LLAssetType::AT_NONE;
LLFolderType::EType preferred_type = LLFolderType::FT_NONE;
LLSD type_default = (*it)["type_default"];
if(type_default.isDefined())
{
preferred_type = (LLAssetType::EType)type_default.asInteger();
preferred_type = (LLFolderType::EType)type_default.asInteger();
}
cat->setPreferredType(preferred_type);
cat->setVersion(version.asInteger());
@ -2400,12 +2401,12 @@ void LLInventoryModel::buildParentChildMap()
<< cat->getName() << llendl;
++lost;
// plop it into the lost & found.
LLAssetType::EType pref = cat->getPreferredType();
if(LLAssetType::AT_NONE == pref)
LLFolderType::EType pref = cat->getPreferredType();
if(LLFolderType::FT_NONE == pref)
{
cat->setParent(findCategoryUUIDForType(LLAssetType::AT_LOST_AND_FOUND));
cat->setParent(findCategoryUUIDForType(LLFolderType::FT_LOST_AND_FOUND));
}
else if(LLAssetType::AT_CATEGORY == pref)
else if(LLFolderType::FT_CATEGORY == pref)
{
// it's the root
cat->setParent(LLUUID::null);
@ -2464,7 +2465,7 @@ void LLInventoryModel::buildParentChildMap()
++lost;
// plop it into the lost & found.
//
item->setParent(findCategoryUUIDForType(LLAssetType::AT_LOST_AND_FOUND));
item->setParent(findCategoryUUIDForType(LLFolderType::FT_LOST_AND_FOUND));
// move it later using a special message to move items. If
// we update server here, the client might crash.
//item->updateServer();
@ -2485,7 +2486,7 @@ void LLInventoryModel::buildParentChildMap()
llwarns << "Found " << lost << " lost items." << llendl;
LLMessageSystem* msg = gMessageSystem;
BOOL start_new_message = TRUE;
LLUUID lnf = findCategoryUUIDForType(LLAssetType::AT_LOST_AND_FOUND);
const LLUUID lnf = findCategoryUUIDForType(LLFolderType::FT_LOST_AND_FOUND);
for(std::vector<LLUUID>::iterator it = lost_item_ids.begin() ; it < lost_item_ids.end(); ++it)
{
if(start_new_message)
@ -2938,7 +2939,7 @@ void LLInventoryModel::processUpdateInventoryFolder(LLMessageSystem* msg,
lastfolder = tfolder;
tfolder->unpackMessage(msg, _PREHASH_FolderData, i);
// make sure it's not a protected folder
tfolder->setPreferredType(LLAssetType::AT_NONE);
tfolder->setPreferredType(LLFolderType::FT_NONE);
folders.push_back(tfolder);
// examine update for changes.
LLViewerInventoryCategory* folderp = gInventory.getCategory(tfolder->getUUID());
@ -3325,31 +3326,31 @@ void LLInventoryModel::processMoveInventoryItem(LLMessageSystem* msg, void**)
//----------------------------------------------------------------------------
// Trash: LLAssetType::AT_TRASH, "ConfirmEmptyTrash"
// Lost&Found: LLAssetType::AT_LOST_AND_FOUND, "ConfirmEmptyLostAndFound"
// Trash: LLFolderType::FT_TRASH, "ConfirmEmptyTrash"
// Lost&Found: LLFolderType::FT_LOST_AND_FOUND, "ConfirmEmptyLostAndFound"
bool LLInventoryModel::callbackEmptyFolderType(const LLSD& notification, const LLSD& response, LLAssetType::EType folder_type)
bool LLInventoryModel::callbackEmptyFolderType(const LLSD& notification, const LLSD& response, LLFolderType::EType preferred_type)
{
S32 option = LLNotification::getSelectedOption(notification, response);
if (option == 0) // YES
{
LLUUID folder_id = findCategoryUUIDForType(folder_type);
const LLUUID folder_id = findCategoryUUIDForType(preferred_type);
purgeDescendentsOf(folder_id);
notifyObservers();
}
return false;
}
void LLInventoryModel::emptyFolderType(const std::string notification, LLAssetType::EType folder_type)
void LLInventoryModel::emptyFolderType(const std::string notification, LLFolderType::EType preferred_type)
{
if (!notification.empty())
{
LLNotifications::instance().add(notification, LLSD(), LLSD(),
boost::bind(&LLInventoryModel::callbackEmptyFolderType, this, _1, _2, folder_type));
boost::bind(&LLInventoryModel::callbackEmptyFolderType, this, _1, _2, preferred_type));
}
else
{
LLUUID folder_id = findCategoryUUIDForType(folder_type);
const LLUUID folder_id = findCategoryUUIDForType(preferred_type);
purgeDescendentsOf(folder_id);
notifyObservers();
}
@ -3360,7 +3361,7 @@ void LLInventoryModel::emptyFolderType(const std::string notification, LLAssetTy
void LLInventoryModel::removeItem(const LLUUID& item_id)
{
LLViewerInventoryItem* item = getItem(item_id);
const LLUUID new_parent = findCategoryUUIDForType(LLAssetType::AT_TRASH);
const LLUUID new_parent = findCategoryUUIDForType(LLFolderType::FT_TRASH);
if (item && item->getParentUUID() != new_parent)
{
LLInventoryModel::update_list_t update;

13
indra/newview/llinventorymodel.h
View File

@ -34,6 +34,7 @@
#define LL_LLINVENTORYMODEL_H
#include "llassettype.h"
#include "llfoldertype.h"
#include "lldarray.h"
#include "llframetimer.h"
#include "llhttpclient.h"
@ -280,7 +281,7 @@ public:
// SDK: Added flag to specify whether the folder should be created if not found. This fixes the horrible
// multiple trash can bug.
LLUUID findCategoryUUIDForType(LLAssetType::EType preferred_type, bool create_folder = true);
const LLUUID findCategoryUUIDForType(LLFolderType::EType preferred_type, bool create_folder = true);
// Call this method when it's time to update everyone on a new
// state, by default, the inventory model will not update
@ -329,7 +330,7 @@ public:
// category. If you want to use the default name based on type,
// pass in a NULL to the 'name parameter.
LLUUID createNewCategory(const LLUUID& parent_id,
LLAssetType::EType preferred_type,
LLFolderType::EType preferred_type,
const std::string& name);
// methods to load up inventory skeleton & meat. These are used
@ -385,9 +386,9 @@ public:
bool isCategoryComplete(const LLUUID& cat_id) const;
// callbacks
// Trigger a notification and empty the folder type (AT_TRASH or AT_LOST_AND_FOUND) if confirmed
void emptyFolderType(const std::string notification, LLAssetType::EType folder_type);
bool callbackEmptyFolderType(const LLSD& notification, const LLSD& response, LLAssetType::EType folder_type);
// Trigger a notification and empty the folder type (FT_TRASH or FT_LOST_AND_FOUND) if confirmed
void emptyFolderType(const std::string notification, LLFolderType::EType folder_type);
bool callbackEmptyFolderType(const LLSD& notification, const LLSD& response, LLFolderType::EType preferred_type);
// Utility Functions
void removeItem(const LLUUID& item_id);
@ -431,7 +432,7 @@ protected:
//
// Internal method which looks for a category with the specified
// preferred type. Returns LLUUID::null if not found
const LLUUID &findCatUUID(LLAssetType::EType preferred_type) const;
const LLUUID &findCatUUID(LLFolderType::EType preferred_type) const;
// Empty the entire contents
void empty();

30
indra/newview/llinventorypanel.cpp
View File

@ -78,6 +78,7 @@
#include "lltabcontainer.h"
#include "lltooldraganddrop.h"
#include "lluictrlfactory.h"
#include "llviewerfoldertype.h"
#include "llviewerinventory.h"
#include "llviewermessage.h"
#include "llviewerobjectlist.h"
@ -110,8 +111,8 @@ LLInventoryPanel::LLInventoryPanel(const LLInventoryPanel::Params& p) :
// contex menu callbacks
mCommitCallbackRegistrar.add("Inventory.DoToSelected", boost::bind(&LLInventoryPanel::doToSelected, this, _2));
mCommitCallbackRegistrar.add("Inventory.EmptyTrash", boost::bind(&LLInventoryModel::emptyFolderType, &gInventory, "ConfirmEmptyTrash", LLAssetType::AT_TRASH));
mCommitCallbackRegistrar.add("Inventory.EmptyLostAndFound", boost::bind(&LLInventoryModel::emptyFolderType, &gInventory, "ConfirmEmptyLostAndFound", LLAssetType::AT_LOST_AND_FOUND));
mCommitCallbackRegistrar.add("Inventory.EmptyTrash", boost::bind(&LLInventoryModel::emptyFolderType, &gInventory, "ConfirmEmptyTrash", LLFolderType::FT_TRASH));
mCommitCallbackRegistrar.add("Inventory.EmptyLostAndFound", boost::bind(&LLInventoryModel::emptyFolderType, &gInventory, "ConfirmEmptyLostAndFound", LLFolderType::FT_LOST_AND_FOUND));
mCommitCallbackRegistrar.add("Inventory.DoCreate", boost::bind(&LLInventoryPanel::doCreate, this, _2));
mCommitCallbackRegistrar.add("Inventory.AttachObject", boost::bind(&LLInventoryPanel::attachObject, this, _2));
mCommitCallbackRegistrar.add("Inventory.BeginIMSession", boost::bind(&LLInventoryPanel::beginIMSession, this));
@ -169,19 +170,19 @@ BOOL LLInventoryPanel::postBuild()
// determine the root folder, if any, so inventory contents show just the children
// of that folder (i.e. not including the folder itself).
const LLAssetType::EType preferred_type = LLAssetType::lookupHumanReadable(mStartFolderString);
const LLFolderType::EType preferred_type = LLViewerFolderType::lookupTypeFromNewCategoryName(mStartFolderString);
if ("inventory" == mStartFolderString)
if ("INVENTORY" == mStartFolderString)
{
mStartFolderID = gInventory.getRootFolderID();
}
else if ("library" == mStartFolderString)
else if ("LIBRARY" == mStartFolderString)
{
mStartFolderID = gInventory.getLibraryRootFolderID();
}
else
{
mStartFolderID = (preferred_type != LLAssetType::AT_NONE ? gInventory.findCategoryUUIDForType(preferred_type) : LLUUID::null);
mStartFolderID = (preferred_type != LLFolderType::FT_NONE ? gInventory.findCategoryUUIDForType(preferred_type) : LLUUID::null);
}
// build view of inventory if we need default full hierarchy and inventory ready, otherwise wait for modelChanged() callback
@ -192,7 +193,7 @@ BOOL LLInventoryPanel::postBuild()
}
// bit of a hack to make sure the inventory is open.
mFolders->openFolder(preferred_type != LLAssetType::AT_NONE ? LLAssetType::lookupCategoryName(preferred_type) : "My Inventory");
mFolders->openFolder(preferred_type != LLFolderType::FT_NONE ? LLViewerFolderType::lookupNewCategoryName(preferred_type) : "My Inventory");
if (mSortOrderSetting != INHERIT_SORT_ORDER)
{
@ -382,6 +383,19 @@ void LLInventoryPanel::modelChanged(U32 mask)
view_item->getParentFolder()->extractItem(view_item);
view_item->addToFolder(new_parent, mFolders);
}
/*
on the other side in case Inventory Panel has content of the any folder
it is possible that item moved to some folder which is absent in current
Panel. For ex. removing item (via moving to trash).
In this case we need to check if new parent is other then inventory start folder
and simply remove its View from the hierarchy.
See details in EXT-2098.
*/
// So, let check if item was moved into folder out of this Inventory Panel.
else if (mStartFolderID.notNull() && NULL == new_parent && model_item->getParentUUID() != mStartFolderID)
{
view_item->getParentFolder()->extractItem(view_item);
}
}
}
else
@ -650,7 +664,7 @@ void LLInventoryPanel::openAllFolders()
mFolders->arrangeAll();
}
void LLInventoryPanel::openDefaultFolderForType(LLAssetType::EType type)
void LLInventoryPanel::openDefaultFolderForType(LLFolderType::EType type)
{
LLUUID category_id = mInventory->findCategoryUUIDForType(type);
LLOpenFolderByID opener(category_id);

2
indra/newview/llinventorypanel.h
View File

@ -122,7 +122,7 @@ public:
// Call this method to set the selection.
void openAllFolders();
void openDefaultFolderForType(LLAssetType::EType);
void openDefaultFolderForType(LLFolderType::EType);
void setSelection(const LLUUID& obj_id, BOOL take_keyboard_focus);
void setSelectCallback(const LLFolderView::signal_t::slot_type& cb) { if (mFolders) mFolders->setSelectCallback(cb); }
void clearSelection();

14
indra/newview/lllandmarkactions.cpp
View File

@ -135,13 +135,13 @@ public:
// Returns true if the given inventory item is a landmark pointing to the current parcel.
// Used to find out if there is at least one landmark from current parcel.
class LLFistAgentParcelLandmark : public LLInventoryCollectFunctor
class LLFirstAgentParcelLandmark : public LLInventoryCollectFunctor
{
private:
bool mFounded;// to avoid unnecessary check
public:
LLFistAgentParcelLandmark(): mFounded(false){}
LLFirstAgentParcelLandmark(): mFounded(false){}
/*virtual*/ bool operator()(LLInventoryCategory* cat, LLInventoryItem* item)
{
@ -165,8 +165,7 @@ static void fetch_landmarks(LLInventoryModel::cat_array_t& cats,
LLInventoryCollectFunctor& add)
{
// Look in "My Favorites"
LLUUID favorites_folder_id =
gInventory.findCategoryUUIDForType(LLAssetType::AT_FAVORITE);
const LLUUID favorites_folder_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_FAVORITE);
gInventory.collectDescendentsIf(favorites_folder_id,
cats,
items,
@ -174,8 +173,7 @@ static void fetch_landmarks(LLInventoryModel::cat_array_t& cats,
add);
// Look in "Landmarks"
LLUUID landmarks_folder_id =
gInventory.findCategoryUUIDForType(LLAssetType::AT_LANDMARK);
const LLUUID landmarks_folder_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_LANDMARK);
gInventory.collectDescendentsIf(landmarks_folder_id,
cats,
items,
@ -202,7 +200,7 @@ bool LLLandmarkActions::landmarkAlreadyExists()
//static
bool LLLandmarkActions::hasParcelLandmark()
{
LLFistAgentParcelLandmark get_first_agent_landmark;
LLFirstAgentParcelLandmark get_first_agent_landmark;
LLInventoryModel::cat_array_t cats;
LLInventoryModel::item_array_t items;
fetch_landmarks(cats, items, get_first_agent_landmark);
@ -287,7 +285,7 @@ void LLLandmarkActions::createLandmarkHere()
LLAgentUI::buildLocationString(landmark_name, LLAgentUI::LOCATION_FORMAT_LANDMARK);
LLAgentUI::buildLocationString(landmark_desc, LLAgentUI::LOCATION_FORMAT_FULL);
LLUUID folder_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_LANDMARK);
const LLUUID folder_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_LANDMARK);
createLandmarkHere(landmark_name, landmark_desc, folder_id);
}

2
indra/newview/lllandmarkactions.h
View File

@ -55,7 +55,7 @@ public:
static bool landmarkAlreadyExists();
/**
* @brief Checks whether landmark exists for current parcel.
* @brief Checks whether landmark exists for current agent parcel.
*/
static bool hasParcelLandmark();

7
indra/newview/llnavigationbar.cpp
View File

@ -50,6 +50,7 @@
#include "llslurl.h"
#include "llurlsimstring.h"
#include "llviewerinventory.h"
#include "llviewermenu.h"
#include "llviewerparcelmgr.h"
#include "llworldmap.h"
#include "llappviewer.h"
@ -271,6 +272,12 @@ void LLNavigationBar::draw()
LLPanel::draw();
}
BOOL LLNavigationBar::handleRightMouseDown(S32 x, S32 y, MASK mask)
{
show_navbar_context_menu(this,x,y);
return TRUE;
}
void LLNavigationBar::onBackButtonClicked()
{
LLTeleportHistory::getInstance()->goBack();

1
indra/newview/llnavigationbar.h
View File

@ -54,6 +54,7 @@ public:
virtual ~LLNavigationBar();
/*virtual*/ void draw();
/*virtual*/ BOOL handleRightMouseDown(S32 x, S32 y, MASK mask);
/*virtual*/ BOOL postBuild();
void handleLoginComplete();

37
indra/newview/llnearbychat.cpp
View File

@ -97,14 +97,39 @@ BOOL LLNearbyChat::postBuild()
if (getDockControl() == NULL)
{
setDockControl(new LLDockControl(
LLBottomTray::getInstance()->getNearbyChatBar(), this,
getDockTongue(), LLDockControl::LEFT, boost::bind(&LLNearbyChat::getAllowedRect, this, _1)));
LLBottomTray::getInstance()->getNearbyChatBar(), this,
getDockTongue(), LLDockControl::LEFT, boost::bind(&LLNearbyChat::getAllowedRect, this, _1)));
}
return true;
}
void LLNearbyChat::applySavedVariables()
{
if (mRectControl.size() > 1)
{
const LLRect& rect = LLUI::sSettingGroups["floater"]->getRect(mRectControl);
reshape(rect.getWidth(), rect.getHeight());
setRect(rect);
}
if(!LLUI::sSettingGroups["floater"]->controlExists(mDocStateControl))
{
setDocked(true);
}
else
{
if (mDocStateControl.size() > 1)
{
bool dockState = LLUI::sSettingGroups["floater"]->getBOOL(mDocStateControl);
setDocked(dockState);
}
}
}
LLColor4 nearbychat_get_text_color(const LLChat& chat)
{
LLColor4 text_color;
@ -265,11 +290,5 @@ void LLNearbyChat::getAllowedRect(LLRect& rect)
{
rect = gViewerWindow->getWorldViewRect();
}
void LLNearbyChat::setVisible (BOOL visible)
{
LLDockableFloater::setVisible(visible);
}
void LLNearbyChat::toggleWindow()
{
}

7
indra/newview/llnearbychat.h
View File

@ -52,16 +52,15 @@ public:
void onNearbyChatContextMenuItemClicked(const LLSD& userdata);
bool onNearbyChatCheckContextMenuItem(const LLSD& userdata);
void setDocked (bool docked, bool pop_on_undock);
void toggleWindow ();
void setDocked (bool docked, bool pop_on_undock = true);
/*virtual*/ void onOpen (const LLSD& key);
virtual void setVisible (BOOL visible);
virtual void setRect (const LLRect &rect);
private:
virtual void applySavedVariables();
void getAllowedRect (LLRect& rect);
void onNearbySpeakers ();

9
indra/newview/llnearbychatbar.cpp
View File

@ -77,6 +77,10 @@ LLGestureComboBox::LLGestureComboBox(const LLGestureComboBox::Params& p)
// refresh list from current active gestures
refreshGestures();
// This forces using of halign from xml, since LLComboBox
// sets it to LLFontGL::LEFT, if text entry is disabled
mButton->setHAlign(p.drop_down_button.font_halign);
}
LLGestureComboBox::~LLGestureComboBox()
@ -207,6 +211,7 @@ LLNearbyChatBar::LLNearbyChatBar()
: LLPanel()
, mChatBox(NULL)
{
mSpeakerMgr = LLLocalSpeakerMgr::getInstance();
}
//virtual
@ -516,8 +521,8 @@ void LLNearbyChatBar::displaySpeakingIndicator()
LLUUID id;
id.setNull();
mSpeakerMgr.update(TRUE);
mSpeakerMgr.getSpeakerList(&speaker_list, FALSE);
mSpeakerMgr->update(TRUE);
mSpeakerMgr->getSpeakerList(&speaker_list, FALSE);
for (LLSpeakerMgr::speaker_list_t::iterator i = speaker_list.begin(); i != speaker_list.end(); ++i)
{

2
indra/newview/llnearbychatbar.h
View File

@ -127,7 +127,7 @@ protected:
LLLineEditor* mChatBox;
LLTalkButton* mTalkBtn;
LLOutputMonitorCtrl* mOutputMonitor;
LLActiveSpeakerMgr mSpeakerMgr;
LLLocalSpeakerMgr* mSpeakerMgr;
};
#endif

12
indra/newview/lloutputmonitorctrl.cpp
View File

@ -80,7 +80,8 @@ LLOutputMonitorCtrl::LLOutputMonitorCtrl(const LLOutputMonitorCtrl::Params& p)
mImageLevel2(p.image_level_2),
mImageLevel3(p.image_level_3),
mAutoUpdate(p.auto_update),
mSpeakerId(p.speaker_id)
mSpeakerId(p.speaker_id),
mIsAgentControl(false)
{
//static LLUIColor output_monitor_muted_color = LLUIColorTable::instance().getColor("OutputMonitorMutedColor", LLColor4::orange);
//static LLUIColor output_monitor_overdriven_color = LLUIColorTable::instance().getColor("OutputMonitorOverdrivenColor", LLColor4::red);
@ -132,7 +133,14 @@ void LLOutputMonitorCtrl::draw()
if (getVisible() && mAutoUpdate && !mIsMuted && mSpeakerId.notNull())
{
setPower(gVoiceClient->getCurrentPower(mSpeakerId));
setIsTalking(gVoiceClient->getIsSpeaking(mSpeakerId));
if(mIsAgentControl)
{
setIsTalking(gVoiceClient->getUserPTTState());
}
else
{
setIsTalking(gVoiceClient->getIsSpeaking(mSpeakerId));
}
}
LLPointer<LLUIImage> icon;

3
indra/newview/lloutputmonitorctrl.h
View File

@ -81,6 +81,8 @@ public:
// For the current user, need to know the PTT state to show
// correct button image.
void setIsAgentControl(bool val) { mIsAgentControl = val; }
void setIsTalking(bool val) { mIsTalking = val; }
void setSpeakerId(const LLUUID& speaker_id);
@ -100,6 +102,7 @@ private:
F32 mPower;
bool mIsAgentControl;
bool mIsMuted;
bool mIsTalking;
LLPointer<LLUIImage> mImageMute;

3
indra/newview/llpanelcontents.cpp
View File

@ -59,6 +59,7 @@
#include "lltoolcomp.h"
#include "lltoolmgr.h"
#include "lltrans.h"
#include "llviewerassettype.h"
#include "llviewerobject.h"
#include "llviewerregion.h"
#include "llviewerwindow.h"
@ -167,7 +168,7 @@ void LLPanelContents::onClickNewScript(void *userdata)
PERM_NONE,
PERM_MOVE | PERM_TRANSFER);
std::string desc;
LLAssetType::generateDescriptionFor(LLAssetType::AT_LSL_TEXT, desc);
LLViewerAssetType::generateDescriptionFor(LLAssetType::AT_LSL_TEXT, desc);
LLPointer<LLViewerInventoryItem> new_item =
new LLViewerInventoryItem(
LLUUID::null,

35
indra/newview/llpanelimcontrolpanel.cpp
View File

@ -112,21 +112,32 @@ BOOL LLPanelIMControlPanel::postBuild()
childSetAction("add_friend_btn", boost::bind(&LLPanelIMControlPanel::onAddFriendButtonClicked, this));
childSetAction("share_btn", boost::bind(&LLPanelIMControlPanel::onShareButtonClicked, this));
childSetAction("teleport_btn", boost::bind(&LLPanelIMControlPanel::onTeleportButtonClicked, this));
childSetAction("pay_btn", boost::bind(&LLPanelIMControlPanel::onPayButtonClicked, this));
childSetEnabled("add_friend_btn", !LLAvatarActions::isFriend(getChild<LLAvatarIconCtrl>("avatar_icon")->getAvatarId()));
return LLPanelChatControlPanel::postBuild();
}
void LLPanelIMControlPanel::onTeleportButtonClicked()
{
LLAvatarActions::offerTeleport(mAvatarID);
}
void LLPanelIMControlPanel::onPayButtonClicked()
{
LLAvatarActions::pay(mAvatarID);
}
void LLPanelIMControlPanel::onViewProfileButtonClicked()
{
LLAvatarActions::showProfile(getChild<LLAvatarIconCtrl>("avatar_icon")->getAvatarId());
LLAvatarActions::showProfile(mAvatarID);
}
void LLPanelIMControlPanel::onAddFriendButtonClicked()
{
LLAvatarIconCtrl* avatar_icon = getChild<LLAvatarIconCtrl>("avatar_icon");
std::string full_name = avatar_icon->getFirstName() + " " + avatar_icon->getLastName();
LLAvatarActions::requestFriendshipDialog(avatar_icon->getAvatarId(), full_name);
LLAvatarActions::requestFriendshipDialog(mAvatarID, full_name);
}
void LLPanelIMControlPanel::onShareButtonClicked()
@ -140,12 +151,12 @@ void LLPanelIMControlPanel::setSessionId(const LLUUID& session_id)
LLIMModel& im_model = LLIMModel::instance();
LLUUID avatar_id = im_model.getOtherParticipantID(session_id);
mAvatarID = im_model.getOtherParticipantID(session_id);
// Disable "Add friend" button for friends.
childSetEnabled("add_friend_btn", !LLAvatarActions::isFriend(avatar_id));
childSetEnabled("add_friend_btn", !LLAvatarActions::isFriend(mAvatarID));
getChild<LLAvatarIconCtrl>("avatar_icon")->setValue(avatar_id);
getChild<LLAvatarIconCtrl>("avatar_icon")->setValue(mAvatarID);
// Disable profile button if participant is not realy SL avatar
LLIMModel::LLIMSession* im_session =
@ -188,6 +199,20 @@ void LLPanelGroupControlPanel::onGroupInfoButtonClicked()
LLGroupActions::show(mGroupID);
}
void LLPanelGroupControlPanel::onSortMenuItemClicked(const LLSD& userdata)
{
// TODO: Check this code when when sort order menu will be added. (EM)
if (false && !mParticipantList)
return;
std::string chosen_item = userdata.asString();
if (chosen_item == "sort_name")
{
mParticipantList->setSortOrder(LLParticipantList::E_SORT_BY_NAME);
}
}
void LLPanelGroupControlPanel::setSessionId(const LLUUID& session_id)
{

3
indra/newview/llpanelimcontrolpanel.h
View File

@ -73,6 +73,8 @@ private:
void onViewProfileButtonClicked();
void onAddFriendButtonClicked();
void onShareButtonClicked();
void onTeleportButtonClicked();
void onPayButtonClicked();
LLUUID mAvatarID;
};
@ -97,6 +99,7 @@ protected:
private:
void onGroupInfoButtonClicked();
void onSortMenuItemClicked(const LLSD& userdata);
};
class LLPanelAdHocControlPanel : public LLPanelGroupControlPanel

85
indra/newview/llpanellandmarkinfo.h Normal file
View File

@ -0,0 +1,85 @@
/**
* @file llpanellandmarkinfo.h
* @brief Displays landmark info in Side Tray.
*
* $LicenseInfo:firstyear=2009&license=viewergpl$
*
* Copyright (c) 2004-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#ifndef LL_LLPANELLANDMARKINFO_H
#define LL_LLPANELLANDMARKINFO_H
#include "llpanelplaceinfo.h"
class LLComboBox;
class LLLineEditor;
class LLTextEditor;
class LLPanelLandmarkInfo : public LLPanelPlaceInfo
{
public:
LLPanelLandmarkInfo();
/*virtual*/ ~LLPanelLandmarkInfo();
/*virtual*/ BOOL postBuild();
/*virtual*/ void resetLocation();
/*virtual*/ void setInfoType(INFO_TYPE type);
/*virtual*/ void processParcelInfo(const LLParcelData& parcel_data);
// Displays landmark owner, creator and creation date info.
void displayItemInfo(const LLInventoryItem* pItem);
void toggleLandmarkEditMode(BOOL enabled);
const std::string& getLandmarkTitle() const;
const std::string getLandmarkNotes() const;
const LLUUID getLandmarkFolder() const;
// Select current landmark folder in combobox.
BOOL setLandmarkFolder(const LLUUID& id);
// Create a landmark for the current location
// in a folder specified by folder_id.
void createLandmark(const LLUUID& folder_id);
static std::string getFullFolderName(const LLViewerInventoryCategory* cat);
private:
void populateFoldersList();
LLTextBox* mOwner;
LLTextBox* mCreator;
LLTextBox* mCreated;
LLLineEditor* mTitleEditor;
LLTextEditor* mNotesEditor;
LLComboBox* mFolderCombo;
};
#endif // LL_LLPANELLANDMARKINFO_H

33
indra/newview/llpanellandmarks.cpp
View File

@ -553,14 +553,16 @@ void LLLandmarksPanel::onAddAction(const LLSD& userdata) const
std::string command_name = userdata.asString();
if("add_landmark" == command_name)
{
if(LLLandmarkActions::landmarkAlreadyExists())
LLViewerInventoryItem* landmark = LLLandmarkActions::findLandmarkForAgentPos();
if(landmark)
{
std::string location;
LLAgentUI::buildLocationString(location, LLAgentUI::LOCATION_FORMAT_FULL);
llwarns<<" Landmark already exists at location: "<< location<<llendl;
return;
LLSideTray::getInstance()->showPanel("panel_places",
LLSD().insert("type", "landmark").insert("id",landmark->getUUID()));
}
else
{
LLSideTray::getInstance()->showPanel("panel_places", LLSD().insert("type", "create_landmark"));
}
LLSideTray::getInstance()->showPanel("panel_places", LLSD().insert("type", "create_landmark"));
}
else if ("category" == command_name)
{
@ -584,7 +586,7 @@ void LLLandmarksPanel::onAddAction(const LLSD& userdata) const
menu_create_inventory_item(mCurrentSelectedList->getRootFolder(),
dynamic_cast<LLFolderBridge*> (folder_bridge), LLSD(
"category"), gInventory.findCategoryUUIDForType(
LLAssetType::AT_LANDMARK));
LLFolderType::FT_LANDMARK));
}
}
}
@ -616,19 +618,21 @@ void LLLandmarksPanel::onClipboardAction(const LLSD& userdata) const
void LLLandmarksPanel::onFoldingAction(const LLSD& userdata)
{
if(!mCurrentSelectedList) return;
LLFolderView* root_folder = mCurrentSelectedList->getRootFolder();
LLFolderView* landmarks_folder = mLandmarksInventoryPanel->getRootFolder();
LLFolderView* fav_folder = mFavoritesInventoryPanel->getRootFolder();
std::string command_name = userdata.asString();
if ("expand_all" == command_name)
{
root_folder->setOpenArrangeRecursively(TRUE, LLFolderViewFolder::RECURSE_DOWN);
root_folder->arrangeAll();
landmarks_folder->setOpenArrangeRecursively(TRUE, LLFolderViewFolder::RECURSE_DOWN);
fav_folder->setOpenArrangeRecursively(TRUE, LLFolderViewFolder::RECURSE_DOWN);
landmarks_folder->arrangeAll();
fav_folder->arrangeAll();
}
else if ("collapse_all" == command_name)
{
root_folder->closeAllFolders();
landmarks_folder->closeAllFolders();
fav_folder->closeAllFolders();
}
else if ( "sort_by_date" == command_name)
{
@ -639,6 +643,9 @@ void LLLandmarksPanel::onFoldingAction(const LLSD& userdata)
}
else
{
if(!mCurrentSelectedList) return;
LLFolderView* root_folder = mCurrentSelectedList->getRootFolder();
root_folder->doToSelected(&gInventory, userdata);
}
}

4
indra/newview/llpanelmaininventory.cpp
View File

@ -84,8 +84,8 @@ LLPanelMainInventory::LLPanelMainInventory()
// Menu Callbacks (non contex menus)
mCommitCallbackRegistrar.add("Inventory.DoToSelected", boost::bind(&LLPanelMainInventory::doToSelected, this, _2));
mCommitCallbackRegistrar.add("Inventory.CloseAllFolders", boost::bind(&LLPanelMainInventory::closeAllFolders, this));
mCommitCallbackRegistrar.add("Inventory.EmptyTrash", boost::bind(&LLInventoryModel::emptyFolderType, &gInventory, "ConfirmEmptyTrash", LLAssetType::AT_TRASH));
mCommitCallbackRegistrar.add("Inventory.EmptyLostAndFound", boost::bind(&LLInventoryModel::emptyFolderType, &gInventory, "ConfirmEmptyLostAndFound", LLAssetType::AT_LOST_AND_FOUND));
mCommitCallbackRegistrar.add("Inventory.EmptyTrash", boost::bind(&LLInventoryModel::emptyFolderType, &gInventory, "ConfirmEmptyTrash", LLFolderType::FT_TRASH));
mCommitCallbackRegistrar.add("Inventory.EmptyLostAndFound", boost::bind(&LLInventoryModel::emptyFolderType, &gInventory, "ConfirmEmptyLostAndFound", LLFolderType::FT_LOST_AND_FOUND));
mCommitCallbackRegistrar.add("Inventory.DoCreate", boost::bind(&LLPanelMainInventory::doCreate, this, _2));
mCommitCallbackRegistrar.add("Inventory.NewWindow", boost::bind(&LLPanelMainInventory::newWindow, this));
mCommitCallbackRegistrar.add("Inventory.ShowFilters", boost::bind(&LLPanelMainInventory::toggleFindOptions, this));

14
indra/newview/llpanelobjectinventory.cpp
View File

@ -60,6 +60,7 @@
#include "llsidetray.h"
#include "llstatusbar.h"
#include "lltrans.h"
#include "llviewerassettype.h"
#include "llviewerregion.h"
#include "llviewerobjectlist.h"
#include "llviewermessage.h"
@ -102,7 +103,7 @@ public:
virtual const std::string& getName() const;
virtual const std::string& getDisplayName() const;
virtual PermissionMask getPermissionMask() const { return PERM_NONE; }
/*virtual*/ LLAssetType::EType getPreferredType() const { return LLAssetType::AT_NONE; }
/*virtual*/ LLFolderType::EType getPreferredType() const { return LLFolderType::FT_NONE; }
virtual const LLUUID& getUUID() const { return mUUID; }
virtual time_t getCreationDate() const;
virtual LLUIImagePtr getIcon() const;
@ -275,7 +276,7 @@ bool LLTaskInvFVBridge::commitBuyItem(const LLSD& notification, const LLSD& resp
msg->addUUIDFast(_PREHASH_ObjectID, notification["payload"]["task_id"].asUUID());
msg->addUUIDFast(_PREHASH_ItemID, notification["payload"]["item_id"].asUUID());
msg->addUUIDFast(_PREHASH_FolderID,
gInventory.findCategoryUUIDForType((LLAssetType::EType)notification["payload"]["type"].asInteger()));
gInventory.findCategoryUUIDForType((LLFolderType::EType)notification["payload"]["type"].asInteger()));
msg->sendReliable(object->getRegion()->getHost());
}
return false;
@ -573,7 +574,7 @@ BOOL LLTaskInvFVBridge::startDrag(EDragAndDropType* type, LLUUID* id) const
// || gAgent.isGodlike())
{
*type = LLAssetType::lookupDragAndDropType(inv->getType());
*type = LLViewerAssetType::lookupDragAndDropType(inv->getType());
*id = inv->getUUID();
return TRUE;
@ -778,7 +779,7 @@ BOOL LLTaskCategoryBridge::startDrag(EDragAndDropType* type, LLUUID* id) const
// || gAgent.isGodlike())
{
*type = LLAssetType::lookupDragAndDropType(inv->getType());
*type = LLViewerAssetType::lookupDragAndDropType(inv->getType());
*id = inv->getUUID();
return TRUE;
@ -1461,7 +1462,6 @@ LLTaskInvFVBridge* LLTaskInvFVBridge::createObjectBridge(LLPanelObjectInventory*
item->getFlags());
break;
case LLAssetType::AT_CATEGORY:
case LLAssetType::AT_FAVORITE:
new_bridge = new LLTaskCategoryBridge(panel,
object->getUUID(),
object->getName());
@ -1503,8 +1503,8 @@ LLPanelObjectInventory::LLPanelObjectInventory(const LLPanelObjectInventory::Par
{
// Setup context menu callbacks
mCommitCallbackRegistrar.add("Inventory.DoToSelected", boost::bind(&LLPanelObjectInventory::doToSelected, this, _2));
mCommitCallbackRegistrar.add("Inventory.EmptyTrash", boost::bind(&LLInventoryModel::emptyFolderType, &gInventory, "ConfirmEmptyTrash", LLAssetType::AT_TRASH));
mCommitCallbackRegistrar.add("Inventory.EmptyLostAndFound", boost::bind(&LLInventoryModel::emptyFolderType, &gInventory, "ConfirmEmptyLostAndFound", LLAssetType::AT_LOST_AND_FOUND));
mCommitCallbackRegistrar.add("Inventory.EmptyTrash", boost::bind(&LLInventoryModel::emptyFolderType, &gInventory, "ConfirmEmptyTrash", LLFolderType::FT_TRASH));
mCommitCallbackRegistrar.add("Inventory.EmptyLostAndFound", boost::bind(&LLInventoryModel::emptyFolderType, &gInventory, "ConfirmEmptyLostAndFound", LLFolderType::FT_LOST_AND_FOUND));
mCommitCallbackRegistrar.add("Inventory.DoCreate", boost::bind(&do_nothing));
mCommitCallbackRegistrar.add("Inventory.AttachObject", boost::bind(&do_nothing));
mCommitCallbackRegistrar.add("Inventory.BeginIMSession", boost::bind(&do_nothing));

67
indra/newview/llpanelpeople.cpp
View File

@ -42,6 +42,7 @@
#include "llpanelpeople.h"
// newview
#include "llaccordionctrl.h"
#include "llaccordionctrltab.h"
#include "llagent.h"
#include "llavataractions.h"
@ -516,6 +517,9 @@ BOOL LLPanelPeople::postBuild()
// call this method in case some list is empty and buttons can be in inconsistent state
updateButtons();
mOnlineFriendList->setRefreshCompleteCallback(boost::bind(&LLPanelPeople::onFriendListRefreshComplete, this, _1, _2));
mAllFriendList->setRefreshCompleteCallback(boost::bind(&LLPanelPeople::onFriendListRefreshComplete, this, _1, _2));
return TRUE;
}
@ -560,6 +564,8 @@ void LLPanelPeople::updateFriendList()
mOnlineFriendList->setDirty();
mAllFriendList->setDirty();
showFriendsAccordionsIfNeeded();
}
void LLPanelPeople::updateNearbyList()
@ -797,14 +803,15 @@ void LLPanelPeople::reSelectedCurrentTab()
void LLPanelPeople::onFilterEdit(const std::string& search_string)
{
if (mFilterSubString == search_string)
std::string search_upper = search_string;
// Searches are case-insensitive
LLStringUtil::toUpper(search_upper);
LLStringUtil::trimHead(search_upper);
if (mFilterSubString == search_upper)
return;
mFilterSubString = search_string;
// Searches are case-insensitive
LLStringUtil::toUpper(mFilterSubString);
LLStringUtil::trimHead(mFilterSubString);
mFilterSubString = search_upper;
// Apply new filter.
mNearbyList->setNameFilter(mFilterSubString);
@ -812,6 +819,8 @@ void LLPanelPeople::onFilterEdit(const std::string& search_string)
mAllFriendList->setNameFilter(mFilterSubString);
mRecentList->setNameFilter(mFilterSubString);
mGroupList->setNameFilter(mFilterSubString);
showFriendsAccordionsIfNeeded();
}
void LLPanelPeople::onTabSelected(const LLSD& param)
@ -1124,3 +1133,49 @@ void LLPanelPeople::onOpen(const LLSD& key)
else
reSelectedCurrentTab();
}
void LLPanelPeople::showAccordion(const std::string name, bool show)
{
if(name.empty())
{
llwarns << "No name provided" << llendl;
return;
}
LLAccordionCtrlTab* tab = getChild<LLAccordionCtrlTab>(name);
tab->setVisible(show);
if(show)
{
// expand accordion
tab->changeOpenClose(false);
}
}
void LLPanelPeople::showFriendsAccordionsIfNeeded()
{
if(FRIENDS_TAB_NAME == getActiveTabName())
{
// Expand and show accordions if needed, else - hide them
showAccordion("tab_online", mOnlineFriendList->filterHasMatches());
showAccordion("tab_all", mAllFriendList->filterHasMatches());
// Rearrange accordions
LLAccordionCtrl* accordion = getChild<LLAccordionCtrl>("friends_accordion");
accordion->arrange();
}
}
void LLPanelPeople::onFriendListRefreshComplete(LLUICtrl*ctrl, const LLSD& param)
{
if(ctrl == mOnlineFriendList)
{
showAccordion("tab_online", param.asInteger());
}
else if(ctrl == mAllFriendList)
{
showAccordion("tab_all", param.asInteger());
}
LLAccordionCtrl* accordion = getChild<LLAccordionCtrl>("friends_accordion");
accordion->arrange();
}

6
indra/newview/llpanelpeople.h
View File

@ -124,6 +124,12 @@ private:
void onFriendsAccordionExpandedCollapsed(const LLSD& param, LLAvatarList* avatar_list);
void showAccordion(const std::string name, bool show);
void showFriendsAccordionsIfNeeded();
void onFriendListRefreshComplete(LLUICtrl*ctrl, const LLSD& param);
LLFilterEditor* mFilterEditor;
LLTabContainer* mTabContainer;
LLAvatarList* mOnlineFriendList;

937
indra/newview/llpanelplaceinfo.cpp
View File

File diff suppressed because it is too large Load Diff

144
indra/newview/llpanelplaceinfo.h
View File

@ -1,6 +1,6 @@
/**
* @file llpanelplaceinfo.h
* @brief Displays place information in Side Tray.
* @brief Base class for place information in Side Tray.
*
* $LicenseInfo:firstyear=2009&license=viewergpl$
*
@ -38,19 +38,13 @@
#include "v3dmath.h"
#include "lluuid.h"
#include "llpanelmedia.h"
#include "llremoteparcelrequest.h"
class LLButton;
class LLComboBox;
class LLExpandableTextBox;
class LLInventoryItem;
class LLLineEditor;
class LLPanelPickEdit;
class LLParcel;
class LLIconCtrl;
class LLTextBox;
class LLTextEditor;
class LLTextureCtrl;
class LLViewerRegion;
class LLViewerInventoryCategory;
@ -74,30 +68,18 @@ public:
// Ignore all old location information, useful if you are
// recycling an existing dialog and need to clear it.
void resetLocation();
virtual void resetLocation();
// Sends a request for data about the given parcel, which will
// only update the location if there is none already available.
/*virtual*/ void setParcelID(const LLUUID& parcel_id);
// Depending on how the panel was triggered
// (from landmark or current location, or other)
// Depending on how the panel was triggered
// (from landmark or current location, or other)
// sets a corresponding title and contents.
void setInfoType(INFO_TYPE type);
// Create a landmark for the current location
// in a folder specified by folder_id.
void createLandmark(const LLUUID& folder_id);
// Create a pick for the location specified
// by global_pos.
void createPick(const LLVector3d& pos_global, LLPanelPickEdit* pick_panel);
BOOL isMediaPanelVisible();
void toggleMediaPanel(BOOL visible);
void displayItemInfo(const LLInventoryItem* pItem);
/*virtual*/ void setErrorStatus(U32 status, const std::string& reason);
virtual void setInfoType(INFO_TYPE type);
// Requests remote parcel info by parcel ID.
void sendParcelInfoRequest();
// Displays information about a remote parcel.
@ -105,109 +87,37 @@ public:
void displayParcelInfo(const LLUUID& region_id,
const LLVector3d& pos_global);
// Displays information about the currently selected parcel
// without sending a request to the server.
// If is_current_parcel true shows "You Are Here" banner.
void displaySelectedParcelInfo(LLParcel* parcel,
LLViewerRegion* region,
const LLVector3d& pos_global,
bool is_current_parcel);
void updateEstateName(const std::string& name);
void updateEstateOwnerName(const std::string& name);
void updateCovenantText(const std::string &text);
void updateLastVisitedText(const LLDate &date);
void nameUpdatedCallback(LLTextBox* text,
const std::string& first,
const std::string& last);
void toggleLandmarkEditMode(BOOL enabled);
const std::string& getLandmarkTitle() const;
const std::string getLandmarkNotes() const;
const LLUUID getLandmarkFolder() const;
// Select current landmark folder in combobox.
BOOL setLandmarkFolder(const LLUUID& id);
/*virtual*/ void setErrorStatus(U32 status, const std::string& reason);
/*virtual*/ void processParcelInfo(const LLParcelData& parcel_data);
/*virtual*/ void handleVisibilityChange (BOOL new_visibility);
static std::string getFullFolderName(const LLViewerInventoryCategory* cat);
private:
// Create a pick for the location specified
// by global_pos.
void createPick(const LLVector3d& pos_global, LLPanelPickEdit* pick_panel);
void populateFoldersList();
static void updateYouAreHereBanner(void*);// added to gIdleCallbacks
void onForSaleBannerClick();
protected:
static void nameUpdatedCallback(LLTextBox* text,
const std::string& first,
const std::string& last);
/**
* mParcelID is valid only for remote places, in other cases it's null. See resetLocation()
*/
LLUUID mParcelID;
LLUUID mRequestedID;
LLUUID mLandmarkID;
LLVector3 mPosRegion;
std::string mCurrentTitle;
S32 mMinHeight;
INFO_TYPE mInfoType;
LLUUID mParcelID;
LLUUID mRequestedID;
LLVector3 mPosRegion;
std::string mCurrentTitle;
S32 mMinHeight;
INFO_TYPE mInfoType;
/**
* Hold last displayed parcel. Needs for YouAreHere banner.
*/
S32 mSelectedParcelID;
LLUUID mLastSelectedRegionID;
LLTextBox* mTitle;
LLPanel* mForSalePanel;
LLPanel* mYouAreHerePanel;
LLTextureCtrl* mSnapshotCtrl;
LLTextBox* mRegionName;
LLTextBox* mParcelName;
LLExpandableTextBox*mDescEditor;
LLTextBox* mMaturityRatingText;
LLTextBox* mParcelOwner;
LLTextBox* mLastVisited;
LLTextBox* mRatingText;
LLTextBox* mVoiceText;
LLTextBox* mFlyText;
LLTextBox* mPushText;
LLTextBox* mBuildText;
LLTextBox* mScriptsText;
LLTextBox* mDamageText;
LLTextBox* mRegionNameText;
LLTextBox* mRegionTypeText;
LLTextBox* mRegionRatingText;
LLTextBox* mRegionOwnerText;
LLTextBox* mRegionGroupText;
LLTextBox* mEstateNameText;
LLTextBox* mEstateRatingText;
LLTextBox* mEstateOwnerText;
LLTextEditor* mCovenantText;
LLTextBox* mSalesPriceText;
LLTextBox* mAreaText;
LLTextBox* mTrafficText;
LLTextBox* mPrimitivesText;
LLTextBox* mParcelScriptsText;
LLTextBox* mTerraformLimitsText;
LLTextEditor* mSubdivideText;
LLTextEditor* mResaleText;
LLTextBox* mSaleToText;
LLTextBox* mOwner;
LLTextBox* mCreator;
LLTextBox* mCreated;
LLLineEditor* mTitleEditor;
LLTextEditor* mNotesEditor;
LLComboBox* mFolderCombo;
LLPanel* mScrollingPanel;
LLPanel* mInfoPanel;
LLMediaPanel* mMediaPanel;
LLTextBox* mTitle;
LLTextureCtrl* mSnapshotCtrl;
LLTextBox* mRegionName;
LLTextBox* mParcelName;
LLExpandableTextBox* mDescEditor;
LLTextBox* mMaturityRatingText;
};
#endif // LL_LLPANELPLACEINFO_H

541
indra/newview/llpanelplaceprofile.cpp Normal file
View File

@ -0,0 +1,541 @@
/**
* @file llpanelplaceprofile.cpp
* @brief Displays place profile in Side Tray.
*
* $LicenseInfo:firstyear=2009&license=viewergpl$
*
* Copyright (c) 2004-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#include "llviewerprecompiledheaders.h"
#include "llpanelplaceprofile.h"
#include "llparcel.h"
#include "llqueryflags.h"
#include "lliconctrl.h"
#include "lllineeditor.h"
#include "lltextbox.h"
#include "lltexteditor.h"
#include "llaccordionctrl.h"
#include "llaccordionctrltab.h"
#include "llagent.h"
#include "llagentui.h"
#include "llappviewer.h"
#include "llcallbacklist.h"
#include "llfloaterbuycurrency.h"
#include "llstatusbar.h"
#include "llviewercontrol.h"
#include "llviewerparcelmgr.h"
#include "llviewerregion.h"
static LLRegisterPanelClassWrapper<LLPanelPlaceProfile> t_place_profile("panel_place_profile");
LLPanelPlaceProfile::LLPanelPlaceProfile()
: LLPanelPlaceInfo(),
mForSalePanel(NULL),
mYouAreHerePanel(NULL),
mSelectedParcelID(-1)
{}
// virtual
LLPanelPlaceProfile::~LLPanelPlaceProfile()
{}
// virtual
BOOL LLPanelPlaceProfile::postBuild()
{
LLPanelPlaceInfo::postBuild();
mForSalePanel = getChild<LLPanel>("for_sale_panel");
mYouAreHerePanel = getChild<LLPanel>("here_panel");
gIdleCallbacks.addFunction(&LLPanelPlaceProfile::updateYouAreHereBanner, this);
//Icon value should contain sale price of last selected parcel.
mForSalePanel->getChild<LLIconCtrl>("icon_for_sale")->
setMouseDownCallback(boost::bind(&LLPanelPlaceProfile::onForSaleBannerClick, this));
mParcelOwner = getChild<LLTextBox>("owner_value");
mLastVisited = getChild<LLTextBox>("last_visited_value");
mRatingText = getChild<LLTextBox>("rating_value");
mVoiceText = getChild<LLTextBox>("voice_value");
mFlyText = getChild<LLTextBox>("fly_value");
mPushText = getChild<LLTextBox>("push_value");
mBuildText = getChild<LLTextBox>("build_value");
mScriptsText = getChild<LLTextBox>("scripts_value");
mDamageText = getChild<LLTextBox>("damage_value");
mRegionNameText = getChild<LLTextBox>("region_name");
mRegionTypeText = getChild<LLTextBox>("region_type");
mRegionRatingText = getChild<LLTextBox>("region_rating");
mRegionOwnerText = getChild<LLTextBox>("region_owner");
mRegionGroupText = getChild<LLTextBox>("region_group");
mEstateNameText = getChild<LLTextBox>("estate_name");
mEstateRatingText = getChild<LLTextBox>("estate_rating");
mEstateOwnerText = getChild<LLTextBox>("estate_owner");
mCovenantText = getChild<LLTextEditor>("covenant");
mSalesPriceText = getChild<LLTextBox>("sales_price");
mAreaText = getChild<LLTextBox>("area");
mTrafficText = getChild<LLTextBox>("traffic");
mPrimitivesText = getChild<LLTextBox>("primitives");
mParcelScriptsText = getChild<LLTextBox>("parcel_scripts");
mTerraformLimitsText = getChild<LLTextBox>("terraform_limits");
mSubdivideText = getChild<LLTextEditor>("subdivide");
mResaleText = getChild<LLTextEditor>("resale");
mSaleToText = getChild<LLTextBox>("sale_to");
return TRUE;
}
// virtual
void LLPanelPlaceProfile::resetLocation()
{
LLPanelPlaceInfo::resetLocation();
mForSalePanel->setVisible(FALSE);
mYouAreHerePanel->setVisible(FALSE);
std::string not_available = getString("not_available");
mParcelOwner->setValue(not_available);
mLastVisited->setValue(not_available);
mRatingText->setText(not_available);
mVoiceText->setText(not_available);
mFlyText->setText(not_available);
mPushText->setText(not_available);
mBuildText->setText(not_available);
mParcelScriptsText->setText(not_available);
mDamageText->setText(not_available);
mRegionNameText->setValue(not_available);
mRegionTypeText->setValue(not_available);
mRegionRatingText->setValue(not_available);
mRegionOwnerText->setValue(not_available);
mRegionGroupText->setValue(not_available);
mEstateNameText->setValue(not_available);
mEstateRatingText->setValue(not_available);
mEstateOwnerText->setValue(not_available);
mCovenantText->setValue(not_available);
mSalesPriceText->setValue(not_available);
mAreaText->setValue(not_available);
mTrafficText->setValue(not_available);
mPrimitivesText->setValue(not_available);
mParcelScriptsText->setValue(not_available);
mTerraformLimitsText->setValue(not_available);
mSubdivideText->setValue(not_available);
mResaleText->setValue(not_available);
mSaleToText->setValue(not_available);
}
// virtual
void LLPanelPlaceProfile::setInfoType(INFO_TYPE type)
{
bool is_info_type_agent = type == AGENT;
bool is_info_type_teleport_history = type == TELEPORT_HISTORY;
getChild<LLTextBox>("maturity_label")->setVisible(!is_info_type_agent);
mMaturityRatingText->setVisible(!is_info_type_agent);
getChild<LLTextBox>("owner_label")->setVisible(is_info_type_agent);
mParcelOwner->setVisible(is_info_type_agent);
getChild<LLTextBox>("last_visited_label")->setVisible(is_info_type_teleport_history);
mLastVisited->setVisible(is_info_type_teleport_history);
getChild<LLAccordionCtrl>("advanced_info_accordion")->setVisible(is_info_type_agent);
switch(type)
{
case AGENT:
case PLACE:
default:
mCurrentTitle = getString("title_place");
break;
case TELEPORT_HISTORY:
mCurrentTitle = getString("title_teleport_history");
break;
}
LLPanelPlaceInfo::setInfoType(type);
}
// virtual
void LLPanelPlaceProfile::processParcelInfo(const LLParcelData& parcel_data)
{
LLPanelPlaceInfo::processParcelInfo(parcel_data);
// HACK: Flag 0x2 == adult region,
// Flag 0x1 == mature region, otherwise assume PG
std::string rating = LLViewerRegion::accessToString(SIM_ACCESS_PG);
if (parcel_data.flags & 0x2)
{
rating = LLViewerRegion::accessToString(SIM_ACCESS_ADULT);
}
else if (parcel_data.flags & 0x1)
{
rating = LLViewerRegion::accessToString(SIM_ACCESS_MATURE);
}
mMaturityRatingText->setValue(rating);
mRatingText->setValue(rating);
//update for_sale banner, here we should use DFQ_FOR_SALE instead of PF_FOR_SALE
//because we deal with remote parcel response format
bool is_for_sale = (parcel_data.flags & DFQ_FOR_SALE) &&
mInfoType == AGENT ? TRUE : FALSE;
mForSalePanel->setVisible(is_for_sale);
}
void LLPanelPlaceProfile::displaySelectedParcelInfo(LLParcel* parcel,
LLViewerRegion* region,
const LLVector3d& pos_global,
bool is_current_parcel)
{
if (!region || !parcel)
return;
// send EstateCovenantInfo message
LLMessageSystem *msg = gMessageSystem;
msg->newMessage("EstateCovenantRequest");
msg->nextBlockFast(_PREHASH_AgentData);
msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
msg->addUUIDFast(_PREHASH_SessionID,gAgent.getSessionID());
msg->sendReliable(region->getHost());
LLParcelData parcel_data;
// HACK: Converting sim access flags to the format
// returned by remote parcel response.
switch(region->getSimAccess())
{
case SIM_ACCESS_MATURE:
parcel_data.flags = 0x1;
break;
case SIM_ACCESS_ADULT:
parcel_data.flags = 0x2;
break;
default:
parcel_data.flags = 0;
}
parcel_data.desc = parcel->getDesc();
parcel_data.name = parcel->getName();
parcel_data.sim_name = region->getName();
parcel_data.snapshot_id = parcel->getSnapshotID();
mPosRegion.setVec((F32)fmod(pos_global.mdV[VX], (F64)REGION_WIDTH_METERS),
(F32)fmod(pos_global.mdV[VY], (F64)REGION_WIDTH_METERS),
(F32)pos_global.mdV[VZ]);
parcel_data.global_x = pos_global.mdV[VX];
parcel_data.global_y = pos_global.mdV[VY];
parcel_data.global_z = pos_global.mdV[VZ];
std::string on = getString("on");
std::string off = getString("off");
// Processing parcel characteristics
if (parcel->getParcelFlagAllowVoice())
{
mVoiceText->setText(on);
}
else
{
mVoiceText->setText(off);
}
if (!region->getBlockFly() && parcel->getAllowFly())
{
mFlyText->setText(on);
}
else
{
mFlyText->setText(off);
}
if (region->getRestrictPushObject() || parcel->getRestrictPushObject())
{
mPushText->setText(off);
}
else
{
mPushText->setText(on);
}
if (parcel->getAllowModify())
{
mBuildText->setText(on);
}
else
{
mBuildText->setText(off);
}
if((region->getRegionFlags() & REGION_FLAGS_SKIP_SCRIPTS) ||
(region->getRegionFlags() & REGION_FLAGS_ESTATE_SKIP_SCRIPTS) ||
!parcel->getAllowOtherScripts())
{
mScriptsText->setText(off);
}
else
{
mScriptsText->setText(on);
}
if (region->getAllowDamage() || parcel->getAllowDamage())
{
mDamageText->setText(on);
}
else
{
mDamageText->setText(off);
}
mRegionNameText->setText(region->getName());
mRegionTypeText->setText(region->getSimProductName());
mRegionRatingText->setText(region->getSimAccessString());
// Determine parcel owner
if (parcel->isPublic())
{
mParcelOwner->setText(getString("public"));
mRegionOwnerText->setText(getString("public"));
}
else
{
if (parcel->getIsGroupOwned())
{
mRegionOwnerText->setText(getString("group_owned_text"));
if(!parcel->getGroupID().isNull())
{
// FIXME: Using parcel group as region group.
gCacheName->get(parcel->getGroupID(), TRUE,
boost::bind(&LLPanelPlaceInfo::nameUpdatedCallback, mRegionGroupText, _2, _3));
gCacheName->get(parcel->getGroupID(), TRUE,
boost::bind(&LLPanelPlaceInfo::nameUpdatedCallback, mParcelOwner, _2, _3));
}
else
{
std::string owner = getString("none_text");
mRegionGroupText->setText(owner);
mParcelOwner->setText(owner);
}
}
else
{
// Figure out the owner's name
gCacheName->get(parcel->getOwnerID(), FALSE,
boost::bind(&LLPanelPlaceInfo::nameUpdatedCallback, mParcelOwner, _2, _3));
gCacheName->get(region->getOwner(), FALSE,
boost::bind(&LLPanelPlaceInfo::nameUpdatedCallback, mRegionOwnerText, _2, _3));
}
if(LLParcel::OS_LEASE_PENDING == parcel->getOwnershipStatus())
{
mRegionOwnerText->setText(mRegionOwnerText->getText() + getString("sale_pending_text"));
}
}
mEstateRatingText->setText(region->getSimAccessString());
S32 area;
S32 claim_price;
S32 rent_price;
F32 dwell;
BOOL for_sale = parcel->getForSale();
LLViewerParcelMgr::getInstance()->getDisplayInfo(&area,
&claim_price,
&rent_price,
&for_sale,
&dwell);
if (for_sale)
{
// Adding "For Sale" flag in remote parcel response format.
parcel_data.flags |= DFQ_FOR_SALE;
const LLUUID& auth_buyer_id = parcel->getAuthorizedBuyerID();
if(auth_buyer_id.notNull())
{
gCacheName->get(auth_buyer_id, TRUE,
boost::bind(&LLPanelPlaceInfo::nameUpdatedCallback, mSaleToText, _2, _3));
// Show sales info to a specific person or a group he belongs to.
if (auth_buyer_id != gAgent.getID() && !gAgent.isInGroup(auth_buyer_id))
{
for_sale = FALSE;
}
}
else
{
mSaleToText->setText(getString("anyone"));
}
const U8* sign = (U8*)getString("price_text").c_str();
const U8* sqm = (U8*)getString("area_text").c_str();
mSalesPriceText->setText(llformat("%s%d ", sign, parcel->getSalePrice()));
mAreaText->setText(llformat("%d %s", area, sqm));
mTrafficText->setText(llformat("%.0f", dwell));
// Can't have more than region max tasks, regardless of parcel
// object bonus factor.
S32 primitives = llmin(llround(parcel->getMaxPrimCapacity() * parcel->getParcelPrimBonus()),
(S32)region->getMaxTasks());
const U8* available = (U8*)getString("available").c_str();
const U8* allocated = (U8*)getString("allocated").c_str();
mPrimitivesText->setText(llformat("%d %s, %d %s", primitives, available, parcel->getPrimCount(), allocated));
if (parcel->getAllowOtherScripts())
{
mParcelScriptsText->setText(getString("all_residents_text"));
}
else if (parcel->getAllowGroupScripts())
{
mParcelScriptsText->setText(getString("group_text"));
}
else
{
mParcelScriptsText->setText(off);
}
mTerraformLimitsText->setText(parcel->getAllowTerraform() ? on : off);
if (region->getRegionFlags() & REGION_FLAGS_ALLOW_PARCEL_CHANGES)
{
mSubdivideText->setText(getString("can_change"));
}
else
{
mSubdivideText->setText(getString("can_not_change"));
}
if (region->getRegionFlags() & REGION_FLAGS_BLOCK_LAND_RESELL)
{
mResaleText->setText(getString("can_not_resell"));
}
else
{
mResaleText->setText(getString("can_resell"));
}
}
mSelectedParcelID = parcel->getLocalID();
mLastSelectedRegionID = region->getRegionID();
processParcelInfo(parcel_data);
mYouAreHerePanel->setVisible(is_current_parcel);
getChild<LLAccordionCtrlTab>("sales_tab")->setVisible(for_sale);
}
void LLPanelPlaceProfile::updateEstateName(const std::string& name)
{
mEstateNameText->setText(name);
}
void LLPanelPlaceProfile::updateEstateOwnerName(const std::string& name)
{
mEstateOwnerText->setText(name);
}
void LLPanelPlaceProfile::updateCovenantText(const std::string &text)
{
mCovenantText->setText(text);
}
void LLPanelPlaceProfile::updateLastVisitedText(const LLDate &date)
{
if (date.isNull())
{
mLastVisited->setText(getString("unknown"));
}
else
{
std::string timeStr = getString("acquired_date");
LLSD substitution;
substitution["datetime"] = (S32) date.secondsSinceEpoch();
LLStringUtil::format (timeStr, substitution);
mLastVisited->setText(timeStr);
}
}
void LLPanelPlaceProfile::onForSaleBannerClick()
{
LLViewerParcelMgr* mgr = LLViewerParcelMgr::getInstance();
LLParcelSelectionHandle hParcel = mgr->getFloatingParcelSelection();
LLViewerRegion* selected_region = mgr->getSelectionRegion();
if(!hParcel.isNull() && selected_region)
{
if(hParcel->getParcel()->getLocalID() == mSelectedParcelID &&
mLastSelectedRegionID ==selected_region->getRegionID())
{
if(hParcel->getParcel()->getSalePrice() - gStatusBar->getBalance() > 0)
{
LLFloaterBuyCurrency::buyCurrency("Buying selected land ", hParcel->getParcel()->getSalePrice());
}
else
{
LLViewerParcelMgr::getInstance()->startBuyLand();
}
}
else
{
LL_WARNS("Places") << "User is trying to buy remote parcel.Operation is not supported"<< LL_ENDL;
}
}
}
// static
void LLPanelPlaceProfile::updateYouAreHereBanner(void* userdata)
{
//YouAreHere Banner should be displayed only for selected places,
// If you want to display it for landmark or teleport history item, you should check by mParcelId
LLPanelPlaceProfile* self = static_cast<LLPanelPlaceProfile*>(userdata);
if(!self->getVisible())
return;
if(!gDisconnected)
{
static F32 radius = gSavedSettings.getF32("YouAreHereDistance");
BOOL display_banner = gAgent.getRegion()->getRegionID() == self->mLastSelectedRegionID &&
LLAgentUI::checkAgentDistance(self->mPosRegion, radius);
self->mYouAreHerePanel->setVisible(display_banner);
}
}

114
indra/newview/llpanelplaceprofile.h Normal file
View File

@ -0,0 +1,114 @@
/**
* @file llpanelplaceprofile.h
* @brief Displays place profile in Side Tray.
*
* $LicenseInfo:firstyear=2009&license=viewergpl$
*
* Copyright (c) 2004-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#ifndef LL_LLPANELPLACEPROFILE_H
#define LL_LLPANELPLACEPROFILE_H
#include "llpanelplaceinfo.h"
class LLTextEditor;
class LLPanelPlaceProfile : public LLPanelPlaceInfo
{
public:
LLPanelPlaceProfile();
/*virtual*/ ~LLPanelPlaceProfile();
/*virtual*/ BOOL postBuild();
/*virtual*/ void resetLocation();
/*virtual*/ void setInfoType(INFO_TYPE type);
/*virtual*/ void processParcelInfo(const LLParcelData& parcel_data);
// Displays information about the currently selected parcel
// without sending a request to the server.
// If is_current_parcel true shows "You Are Here" banner.
void displaySelectedParcelInfo(LLParcel* parcel,
LLViewerRegion* region,
const LLVector3d& pos_global,
bool is_current_parcel);
void updateEstateName(const std::string& name);
void updateEstateOwnerName(const std::string& name);
void updateCovenantText(const std::string &text);
void updateLastVisitedText(const LLDate &date);
private:
void onForSaleBannerClick();
static void updateYouAreHereBanner(void*);// added to gIdleCallbacks
/**
* Holds last displayed parcel. Needed for YouAreHere banner.
*/
S32 mSelectedParcelID;
LLUUID mLastSelectedRegionID;
LLPanel* mForSalePanel;
LLPanel* mYouAreHerePanel;
LLTextBox* mParcelOwner;
LLTextBox* mLastVisited;
LLTextBox* mRatingText;
LLTextBox* mVoiceText;
LLTextBox* mFlyText;
LLTextBox* mPushText;
LLTextBox* mBuildText;
LLTextBox* mScriptsText;
LLTextBox* mDamageText;
LLTextBox* mRegionNameText;
LLTextBox* mRegionTypeText;
LLTextBox* mRegionRatingText;
LLTextBox* mRegionOwnerText;
LLTextBox* mRegionGroupText;
LLTextBox* mEstateNameText;
LLTextBox* mEstateRatingText;
LLTextBox* mEstateOwnerText;
LLTextEditor* mCovenantText;
LLTextBox* mSalesPriceText;
LLTextBox* mAreaText;
LLTextBox* mTrafficText;
LLTextBox* mPrimitivesText;
LLTextBox* mParcelScriptsText;
LLTextBox* mTerraformLimitsText;
LLTextEditor* mSubdivideText;
LLTextEditor* mResaleText;
LLTextBox* mSaleToText;
};
#endif // LL_LLPANELPLACEPROFILE_H

231
indra/newview/llpanelplaces.cpp
View File

@ -57,9 +57,10 @@
#include "llinventorymodel.h"
#include "lllandmarkactions.h"
#include "lllandmarklist.h"
#include "llpanelplaceinfo.h"
#include "llpanellandmarkinfo.h"
#include "llpanellandmarks.h"
#include "llpanelpick.h"
#include "llpanelplaceprofile.h"
#include "llpanelteleporthistory.h"
#include "llteleporthistorystorage.h"
#include "lltoggleablemenu.h"
@ -121,7 +122,8 @@ LLPanelPlaces::LLPanelPlaces()
mFilterSubString(LLStringUtil::null),
mActivePanel(NULL),
mFilterEditor(NULL),
mPlaceInfo(NULL),
mPlaceProfile(NULL),
mLandmarkInfo(NULL),
mPickPanel(NULL),
mItem(NULL),
mPlaceMenu(NULL),
@ -135,7 +137,7 @@ LLPanelPlaces::LLPanelPlaces()
gInventory.addObserver(mInventoryObserver);
LLViewerParcelMgr::getInstance()->addAgentParcelChangedCallback(
boost::bind(&LLPanelPlaces::onAgentParcelChange, this));
boost::bind(&LLPanelPlaces::updateVerbs, this));
//LLUICtrlFactory::getInstance()->buildPanel(this, "panel_places.xml"); // Called from LLRegisterPanelClass::defaultPanelClassBuilder()
}
@ -206,25 +208,32 @@ BOOL LLPanelPlaces::postBuild()
mFilterEditor->setCommitCallback(boost::bind(&LLPanelPlaces::onFilterEdit, this, _2, false));
}
mPlaceInfo = getChild<LLPanelPlaceInfo>("panel_place_info");
mPlaceProfile = getChild<LLPanelPlaceProfile>("panel_place_profile");
mLandmarkInfo = getChild<LLPanelLandmarkInfo>("panel_landmark_info");
if (!mPlaceProfile || !mLandmarkInfo)
return FALSE;
LLButton* back_btn = mPlaceInfo->getChild<LLButton>("back_btn");
LLButton* back_btn = mPlaceProfile->getChild<LLButton>("back_btn");
back_btn->setClickedCallback(boost::bind(&LLPanelPlaces::onBackButtonClicked, this));
LLLineEditor* title_editor = mPlaceInfo->getChild<LLLineEditor>("title_editor");
back_btn = mLandmarkInfo->getChild<LLButton>("back_btn");
back_btn->setClickedCallback(boost::bind(&LLPanelPlaces::onBackButtonClicked, this));
LLLineEditor* title_editor = mLandmarkInfo->getChild<LLLineEditor>("title_editor");
title_editor->setKeystrokeCallback(boost::bind(&LLPanelPlaces::onEditButtonClicked, this), NULL);
LLTextEditor* notes_editor = mPlaceInfo->getChild<LLTextEditor>("notes_editor");
LLTextEditor* notes_editor = mLandmarkInfo->getChild<LLTextEditor>("notes_editor");
notes_editor->setKeystrokeCallback(boost::bind(&LLPanelPlaces::onEditButtonClicked, this));
LLComboBox* folder_combo = mPlaceInfo->getChild<LLComboBox>("folder_combo");
LLComboBox* folder_combo = mLandmarkInfo->getChild<LLComboBox>("folder_combo");
folder_combo->setSelectionCallback(boost::bind(&LLPanelPlaces::onEditButtonClicked, this));
return TRUE;
}
void LLPanelPlaces::onOpen(const LLSD& key)
{
if(mPlaceInfo == NULL || key.size() == 0)
if(!mPlaceProfile || !mLandmarkInfo || key.size() == 0)
return;
mFilterEditor->clear();
@ -239,11 +248,11 @@ void LLPanelPlaces::onOpen(const LLSD& key)
if (mPlaceInfoType == AGENT_INFO_TYPE)
{
mPlaceInfo->setInfoType(LLPanelPlaceInfo::AGENT);
mPlaceProfile->setInfoType(LLPanelPlaceInfo::AGENT);
}
else if (mPlaceInfoType == CREATE_LANDMARK_INFO_TYPE)
{
mPlaceInfo->setInfoType(LLPanelPlaceInfo::CREATE_LANDMARK);
mLandmarkInfo->setInfoType(LLPanelPlaceInfo::CREATE_LANDMARK);
if (key.has("x") && key.has("y") && key.has("z"))
{
@ -256,11 +265,11 @@ void LLPanelPlaces::onOpen(const LLSD& key)
mPosGlobal = gAgent.getPositionGlobal();
}
mPlaceInfo->displayParcelInfo(LLUUID(), mPosGlobal);
mLandmarkInfo->displayParcelInfo(LLUUID(), mPosGlobal);
}
else if (mPlaceInfoType == LANDMARK_INFO_TYPE)
{
mPlaceInfo->setInfoType(LLPanelPlaceInfo::LANDMARK);
mLandmarkInfo->setInfoType(LLPanelPlaceInfo::LANDMARK);
LLInventoryItem* item = gInventory.getItem(key["id"].asUUID());
if (!item)
@ -270,17 +279,12 @@ void LLPanelPlaces::onOpen(const LLSD& key)
}
else if (mPlaceInfoType == REMOTE_PLACE_INFO_TYPE)
{
if (mPlaceInfo->isMediaPanelVisible())
{
toggleMediaPanel();
}
mPosGlobal = LLVector3d(key["x"].asReal(),
key["y"].asReal(),
key["z"].asReal());
mPlaceInfo->setInfoType(LLPanelPlaceInfo::PLACE);
mPlaceInfo->displayParcelInfo(LLUUID(), mPosGlobal);
mPlaceProfile->setInfoType(LLPanelPlaceInfo::PLACE);
mPlaceProfile->displayParcelInfo(LLUUID(), mPosGlobal);
}
else if (mPlaceInfoType == TELEPORT_HISTORY_INFO_TYPE)
{
@ -291,9 +295,9 @@ void LLPanelPlaces::onOpen(const LLSD& key)
mPosGlobal = hist_items[index].mGlobalPos;
mPlaceInfo->setInfoType(LLPanelPlaceInfo::TELEPORT_HISTORY);
mPlaceInfo->updateLastVisitedText(hist_items[index].mDate);
mPlaceInfo->displayParcelInfo(LLUUID(), mPosGlobal);
mPlaceProfile->setInfoType(LLPanelPlaceInfo::TELEPORT_HISTORY);
mPlaceProfile->updateLastVisitedText(hist_items[index].mDate);
mPlaceProfile->displayParcelInfo(LLUUID(), mPosGlobal);
}
LLViewerParcelMgr* parcel_mgr = LLViewerParcelMgr::getInstance();
@ -321,7 +325,7 @@ void LLPanelPlaces::onOpen(const LLSD& key)
void LLPanelPlaces::setItem(LLInventoryItem* item)
{
if (!mPlaceInfo || !item)
if (!mLandmarkInfo || !item)
return;
mItem = item;
@ -351,19 +355,19 @@ void LLPanelPlaces::setItem(LLInventoryItem* item)
if (is_landmark_editable)
{
if(!mPlaceInfo->setLandmarkFolder(mItem->getParentUUID()) && !mItem->getParentUUID().isNull())
if(!mLandmarkInfo->setLandmarkFolder(mItem->getParentUUID()) && !mItem->getParentUUID().isNull())
{
const LLViewerInventoryCategory* cat = gInventory.getCategory(mItem->getParentUUID());
if(cat)
if (cat)
{
std::string cat_fullname = LLPanelPlaceInfo::getFullFolderName(cat);
LLComboBox* folderList = mPlaceInfo->getChild<LLComboBox>("folder_combo");
folderList->add(cat_fullname, cat->getUUID(),ADD_TOP);
std::string cat_fullname = LLPanelLandmarkInfo::getFullFolderName(cat);
LLComboBox* folderList = mLandmarkInfo->getChild<LLComboBox>("folder_combo");
folderList->add(cat_fullname, cat->getUUID(), ADD_TOP);
}
}
}
mPlaceInfo->displayItemInfo(mItem);
mLandmarkInfo->displayItemInfo(mItem);
LLLandmark* lm = gLandmarkList.getAsset(mItem->getAssetUUID(),
boost::bind(&LLPanelPlaces::onLandmarkLoaded, this, _1));
@ -375,13 +379,13 @@ void LLPanelPlaces::setItem(LLInventoryItem* item)
void LLPanelPlaces::onLandmarkLoaded(LLLandmark* landmark)
{
if (!mPlaceInfo)
if (!mLandmarkInfo)
return;
LLUUID region_id;
landmark->getRegionID(region_id);
landmark->getGlobalPos(mPosGlobal);
mPlaceInfo->displayParcelInfo(region_id, mPosGlobal);
mLandmarkInfo->displayParcelInfo(region_id, mPosGlobal);
}
void LLPanelPlaces::onFilterEdit(const std::string& search_string, bool force_filter)
@ -418,10 +422,8 @@ void LLPanelPlaces::onShareButtonClicked()
void LLPanelPlaces::onTeleportButtonClicked()
{
if (!mPlaceInfo)
return;
if (mPlaceInfo->getVisible())
LLPanelPlaceInfo* panel = getCurrentInfoPanel();
if (panel && panel->getVisible())
{
if (mPlaceInfoType == LANDMARK_INFO_TYPE)
{
@ -450,10 +452,8 @@ void LLPanelPlaces::onTeleportButtonClicked()
void LLPanelPlaces::onShowOnMapButtonClicked()
{
if (!mPlaceInfo)
return;
if (mPlaceInfo->getVisible())
LLPanelPlaceInfo* panel = getCurrentInfoPanel();
if (panel && panel->getVisible())
{
LLFloaterWorldMap* worldmap_instance = LLFloaterWorldMap::getInstance();
if(!worldmap_instance)
@ -496,31 +496,31 @@ void LLPanelPlaces::onShowOnMapButtonClicked()
void LLPanelPlaces::onEditButtonClicked()
{
if (!mPlaceInfo || isLandmarkEditModeOn)
if (!mLandmarkInfo || isLandmarkEditModeOn)
return;
isLandmarkEditModeOn = true;
mPlaceInfo->toggleLandmarkEditMode(TRUE);
mLandmarkInfo->toggleLandmarkEditMode(TRUE);
updateVerbs();
}
void LLPanelPlaces::onSaveButtonClicked()
{
if (!mPlaceInfo || mItem.isNull())
if (!mLandmarkInfo || mItem.isNull())
return;
std::string current_title_value = mPlaceInfo->getLandmarkTitle();
std::string current_title_value = mLandmarkInfo->getLandmarkTitle();
std::string item_title_value = mItem->getName();
std::string current_notes_value = mPlaceInfo->getLandmarkNotes();
std::string current_notes_value = mLandmarkInfo->getLandmarkNotes();
std::string item_notes_value = mItem->getDescription();
LLStringUtil::trim(current_title_value);
LLStringUtil::trim(current_notes_value);
LLUUID item_id = mItem->getUUID();
LLUUID folder_id = mPlaceInfo->getLandmarkFolder();
LLUUID folder_id = mLandmarkInfo->getLandmarkFolder();
LLPointer<LLViewerInventoryItem> new_item = new LLViewerInventoryItem(mItem);
@ -553,7 +553,7 @@ void LLPanelPlaces::onSaveButtonClicked()
void LLPanelPlaces::onCancelButtonClicked()
{
if (!mPlaceInfo)
if (!mLandmarkInfo)
return;
if (mPlaceInfoType == CREATE_LANDMARK_INFO_TYPE)
@ -562,13 +562,13 @@ void LLPanelPlaces::onCancelButtonClicked()
}
else
{
mPlaceInfo->toggleLandmarkEditMode(FALSE);
mLandmarkInfo->toggleLandmarkEditMode(FALSE);
isLandmarkEditModeOn = false;
updateVerbs();
// Reload the landmark properties.
mPlaceInfo->displayItemInfo(mItem);
mLandmarkInfo->displayItemInfo(mItem);
}
}
@ -597,7 +597,7 @@ void LLPanelPlaces::onOverflowButtonClicked()
if (mItem.notNull())
{
const LLUUID& item_id = mItem->getUUID();
const LLUUID& trash_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_TRASH);
const LLUUID trash_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_TRASH);
is_landmark_removable = gInventory.isObjectDescendentOf(item_id, gInventory.getRootFolderID()) &&
!gInventory.isObjectDescendentOf(item_id, trash_id);
}
@ -652,9 +652,6 @@ void LLPanelPlaces::onOverflowMenuItemClicked(const LLSD& param)
}
else if (item == "pick")
{
if (!mPlaceInfo)
return;
if (mPickPanel == NULL)
{
mPickPanel = LLPanelPickEdit::create();
@ -667,7 +664,12 @@ void LLPanelPlaces::onOverflowMenuItemClicked(const LLSD& param)
togglePickPanel(TRUE);
mPickPanel->onOpen(LLSD());
mPlaceInfo->createPick(mPosGlobal, mPickPanel);
LLPanelPlaceInfo* panel = getCurrentInfoPanel();
if (panel)
{
panel->createPick(mPosGlobal, mPickPanel);
}
LLRect rect = getRect();
mPickPanel->reshape(rect.getWidth(), rect.getHeight());
@ -677,7 +679,7 @@ void LLPanelPlaces::onOverflowMenuItemClicked(const LLSD& param)
{
if ( mItem.notNull() )
{
LLUUID favorites_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_FAVORITE);
const LLUUID& favorites_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_FAVORITE);
if ( favorites_id.notNull() )
{
copy_inventory_item(gAgent.getID(),
@ -694,39 +696,16 @@ void LLPanelPlaces::onOverflowMenuItemClicked(const LLSD& param)
void LLPanelPlaces::onBackButtonClicked()
{
if (!mPlaceInfo)
return;
if (mPlaceInfo->isMediaPanelVisible())
{
toggleMediaPanel();
}
else
{
togglePlaceInfoPanel(FALSE);
togglePlaceInfoPanel(FALSE);
// Resetting mPlaceInfoType when Place Info panel is closed.
mPlaceInfoType = LLStringUtil::null;
// Resetting mPlaceInfoType when Place Info panel is closed.
mPlaceInfoType = LLStringUtil::null;
isLandmarkEditModeOn = false;
}
isLandmarkEditModeOn = false;
updateVerbs();
}
void LLPanelPlaces::toggleMediaPanel()
{
if (!mPlaceInfo)
return;
mPlaceInfo->toggleMediaPanel(!mPlaceInfo->isMediaPanelVisible());
// Refresh the current place info because
// the media panel controls can't refer to
// the remote parcel media.
onOpen(LLSD().insert("type", AGENT_INFO_TYPE));
}
void LLPanelPlaces::togglePickPanel(BOOL visible)
{
setAllChildrenVisible(this, !visible);
@ -737,26 +716,50 @@ void LLPanelPlaces::togglePickPanel(BOOL visible)
void LLPanelPlaces::togglePlaceInfoPanel(BOOL visible)
{
if (!mPlaceInfo)
if (!mPlaceProfile || !mLandmarkInfo)
return;
mPlaceInfo->setVisible(visible);
mFilterEditor->setVisible(!visible);
mTabContainer->setVisible(!visible);
if (visible)
if (mPlaceInfoType == AGENT_INFO_TYPE ||
mPlaceInfoType == REMOTE_PLACE_INFO_TYPE ||
mPlaceInfoType == TELEPORT_HISTORY_INFO_TYPE)
{
mPlaceInfo->resetLocation();
mPlaceProfile->setVisible(visible);
LLRect rect = getRect();
LLRect new_rect = LLRect(rect.mLeft, rect.mTop, rect.mRight, mTabContainer->getRect().mBottom);
mPlaceInfo->reshape(new_rect.getWidth(),new_rect.getHeight());
if (visible)
{
mPlaceProfile->resetLocation();
LLRect rect = getRect();
LLRect new_rect = LLRect(rect.mLeft, rect.mTop, rect.mRight, mTabContainer->getRect().mBottom);
mPlaceProfile->reshape(new_rect.getWidth(), new_rect.getHeight());
mLandmarkInfo->setVisible(FALSE);
}
}
else if (mPlaceInfoType == CREATE_LANDMARK_INFO_TYPE ||
mPlaceInfoType == LANDMARK_INFO_TYPE)
{
mLandmarkInfo->setVisible(visible);
if (visible)
{
mLandmarkInfo->resetLocation();
LLRect rect = getRect();
LLRect new_rect = LLRect(rect.mLeft, rect.mTop, rect.mRight, mTabContainer->getRect().mBottom);
mLandmarkInfo->reshape(new_rect.getWidth(), new_rect.getHeight());
mPlaceProfile->setVisible(FALSE);
}
}
}
void LLPanelPlaces::changedParcelSelection()
{
if (!mPlaceInfo)
if (!mPlaceProfile)
return;
LLViewerParcelMgr* parcel_mgr = LLViewerParcelMgr::getInstance();
@ -782,8 +785,8 @@ void LLPanelPlaces::changedParcelSelection()
}
}
mPlaceInfo->resetLocation();
mPlaceInfo->displaySelectedParcelInfo(parcel, region, mPosGlobal, is_current_parcel);
mPlaceProfile->resetLocation();
mPlaceProfile->displaySelectedParcelInfo(parcel, region, mPosGlobal, is_current_parcel);
updateVerbs();
}
@ -830,30 +833,22 @@ void LLPanelPlaces::changedInventory(U32 mask)
gInventory.removeObserver(mInventoryObserver);
}
void LLPanelPlaces::onAgentParcelChange()
void LLPanelPlaces::updateVerbs()
{
if (!mPlaceInfo)
return;
bool is_place_info_visible;
if (mPlaceInfo->isMediaPanelVisible())
LLPanelPlaceInfo* panel = getCurrentInfoPanel();
if (panel)
{
onOpen(LLSD().insert("type", AGENT_INFO_TYPE));
is_place_info_visible = panel->getVisible();
}
else
{
updateVerbs();
is_place_info_visible = false;
}
}
void LLPanelPlaces::updateVerbs()
{
if (!mPlaceInfo)
return;
bool is_place_info_visible = mPlaceInfo->getVisible();
bool is_agent_place_info_visible = mPlaceInfoType == AGENT_INFO_TYPE;
bool is_create_landmark_visible = mPlaceInfoType == CREATE_LANDMARK_INFO_TYPE;
bool is_media_panel_visible = mPlaceInfo->isMediaPanelVisible();
mTeleportBtn->setVisible(!is_create_landmark_visible && !isLandmarkEditModeOn);
mShowOnMapBtn->setVisible(!is_create_landmark_visible && !isLandmarkEditModeOn);
@ -864,7 +859,7 @@ void LLPanelPlaces::updateVerbs()
mCancelBtn->setVisible(isLandmarkEditModeOn);
mCloseBtn->setVisible(is_create_landmark_visible && !isLandmarkEditModeOn);
mOverflowBtn->setEnabled(is_place_info_visible && !is_media_panel_visible && !is_create_landmark_visible);
mOverflowBtn->setEnabled(is_place_info_visible && !is_create_landmark_visible);
if (is_place_info_visible)
{
@ -872,16 +867,13 @@ void LLPanelPlaces::updateVerbs()
{
// We don't need to teleport to the current location
// so check if the location is not within the current parcel.
mTeleportBtn->setEnabled(!is_media_panel_visible &&
!mPosGlobal.isExactlyZero() &&
mTeleportBtn->setEnabled(!mPosGlobal.isExactlyZero() &&
!LLViewerParcelMgr::getInstance()->inAgentParcel(mPosGlobal));
}
else if (mPlaceInfoType == LANDMARK_INFO_TYPE || mPlaceInfoType == REMOTE_PLACE_INFO_TYPE)
{
mTeleportBtn->setEnabled(TRUE);
}
mShowOnMapBtn->setEnabled(!is_media_panel_visible);
}
else
{
@ -890,6 +882,23 @@ void LLPanelPlaces::updateVerbs()
}
}
LLPanelPlaceInfo* LLPanelPlaces::getCurrentInfoPanel()
{
if (mPlaceInfoType == AGENT_INFO_TYPE ||
mPlaceInfoType == REMOTE_PLACE_INFO_TYPE ||
mPlaceInfoType == TELEPORT_HISTORY_INFO_TYPE)
{
return mPlaceProfile;
}
else if (mPlaceInfoType == CREATE_LANDMARK_INFO_TYPE ||
mPlaceInfoType == LANDMARK_INFO_TYPE)
{
return mLandmarkInfo;
}
return NULL;
}
static bool is_agent_in_selected_parcel(LLParcel* parcel)
{
LLViewerParcelMgr* parcel_mgr = LLViewerParcelMgr::getInstance();

11
indra/newview/llpanelplaces.h
View File

@ -37,6 +37,10 @@
class LLInventoryItem;
class LLFilterEditor;
class LLLandmark;
class LLPanelLandmarkInfo;
class LLPanelPlaceProfile;
class LLPanelPickEdit;
class LLPanelPlaceInfo;
class LLPanelPlacesTab;
@ -85,13 +89,16 @@ private:
void togglePickPanel(BOOL visible);
void togglePlaceInfoPanel(BOOL visible);
void onAgentParcelChange();
void updateVerbs();
LLPanelPlaceInfo* getCurrentInfoPanel();
LLFilterEditor* mFilterEditor;
LLPanelPlacesTab* mActivePanel;
LLTabContainer* mTabContainer;
LLPanelPlaceInfo* mPlaceInfo;
LLPanelPlaceProfile* mPlaceProfile;
LLPanelLandmarkInfo* mLandmarkInfo;
LLPanelPickEdit* mPickPanel;
LLToggleableMenu* mPlaceMenu;
LLToggleableMenu* mLandmarkMenu;

14
indra/newview/llpanelprofileview.h
View File

@ -36,6 +36,8 @@
#include "llpanel.h"
#include "llpanelprofile.h"
#include "llavatarpropertiesprocessor.h"
#include "llagent.h"
#include "lltooldraganddrop.h"
class LLPanelProfile;
class LLPanelProfileTab;
@ -64,6 +66,18 @@ public:
/*virtual*/ void togglePanel(LLPanel* panel);
BOOL handleDragAndDrop(S32 x, S32 y, MASK mask,
BOOL drop, EDragAndDropType cargo_type,
void *cargo_data, EAcceptance *accept,
std::string& tooltip_msg)
{
LLToolDragAndDrop::handleGiveDragAndDrop(getAvatarId(), gAgent.getSessionID(), drop,
cargo_type, cargo_data, accept);
return TRUE;
}
protected:
void onBackBtnClick();

110
indra/newview/llparticipantlist.cpp
View File

@ -32,6 +32,11 @@
#include "llviewerprecompiledheaders.h"
// common includes
#include "lltrans.h"
#include "llavataractions.h"
#include "llagent.h"
#include "llparticipantlist.h"
#include "llavatarlist.h"
#include "llspeakers.h"
@ -39,15 +44,18 @@
//LLParticipantList retrieves add, clear and remove events and updates view accordingly
LLParticipantList::LLParticipantList(LLSpeakerMgr* data_source, LLAvatarList* avatar_list):
mSpeakerMgr(data_source),
mAvatarList(avatar_list)
mAvatarList(avatar_list),
mSpeakerAddListener(*this),
mSpeakerRemoveListener(*this),
mSpeakerClearListener(*this),
mSortOrder(E_SORT_BY_NAME)
{
mSpeakerAddListener = new SpeakerAddListener(mAvatarList);
mSpeakerRemoveListener = new SpeakerRemoveListener(mAvatarList);
mSpeakerClearListener = new SpeakerClearListener(mAvatarList);
mSpeakerMgr->addListener(&mSpeakerAddListener, "add");
mSpeakerMgr->addListener(&mSpeakerRemoveListener, "remove");
mSpeakerMgr->addListener(&mSpeakerClearListener, "clear");
mSpeakerMgr->addListener(mSpeakerAddListener, "add");
mSpeakerMgr->addListener(mSpeakerRemoveListener, "remove");
mSpeakerMgr->addListener(mSpeakerClearListener, "clear");
mAvatarList->setNoItemsCommentText(LLTrans::getString("LoadingData"));
mAvatarList->setDoubleClickCallback(boost::bind(&LLParticipantList::onAvatarListDoubleClicked, this, mAvatarList));
//Lets fill avatarList with existing speakers
LLAvatarList::uuid_vector_t& group_members = mAvatarList->getIDs();
@ -58,24 +66,33 @@ LLParticipantList::LLParticipantList(LLSpeakerMgr* data_source, LLAvatarList* av
{
group_members.push_back((*it)->mID);
}
mAvatarList->setDirty();
mAvatarList->sortByName();
sort();
}
LLParticipantList::~LLParticipantList()
{
delete mSpeakerAddListener;
delete mSpeakerRemoveListener;
delete mSpeakerClearListener;
mSpeakerAddListener = NULL;
mSpeakerRemoveListener = NULL;
mSpeakerClearListener = NULL;
}
//
// LLParticipantList::SpeakerAddListener
//
bool LLParticipantList::SpeakerAddListener::handleEvent(LLPointer<LLOldEvents::LLEvent> event, const LLSD& userdata)
void LLParticipantList::onAvatarListDoubleClicked(LLAvatarList* list)
{
LLUUID clicked_id = list->getSelectedUUID();
if (clicked_id.isNull() || clicked_id == gAgent.getID())
return;
LLAvatarActions::startIM(clicked_id);
}
void LLParticipantList::setSortOrder(EParticipantSortOrder order)
{
if ( mSortOrder != order )
{
mSortOrder = order;
sort();
}
}
bool LLParticipantList::onAddItemEvent(LLPointer<LLOldEvents::LLEvent> event, const LLSD& userdata)
{
LLAvatarList::uuid_vector_t& group_members = mAvatarList->getIDs();
LLUUID uu_id = event->getValue().asUUID();
@ -88,15 +105,11 @@ bool LLParticipantList::SpeakerAddListener::handleEvent(LLPointer<LLOldEvents::L
}
group_members.push_back(uu_id);
mAvatarList->setDirty();
mAvatarList->sortByName();
sort();
return true;
}
//
// LLParticipantList::SpeakerRemoveListener
//
bool LLParticipantList::SpeakerRemoveListener::handleEvent(LLPointer<LLOldEvents::LLEvent> event, const LLSD& userdata)
bool LLParticipantList::onRemoveItemEvent(LLPointer<LLOldEvents::LLEvent> event, const LLSD& userdata)
{
LLAvatarList::uuid_vector_t& group_members = mAvatarList->getIDs();
LLAvatarList::uuid_vector_t::iterator pos = std::find(group_members.begin(), group_members.end(), event->getValue().asUUID());
@ -108,10 +121,7 @@ bool LLParticipantList::SpeakerRemoveListener::handleEvent(LLPointer<LLOldEvents
return true;
}
//
// LLParticipantList::SpeakerClearListener
//
bool LLParticipantList::SpeakerClearListener::handleEvent(LLPointer<LLOldEvents::LLEvent> event, const LLSD& userdata)
bool LLParticipantList::onClearListEvent(LLPointer<LLOldEvents::LLEvent> event, const LLSD& userdata)
{
LLAvatarList::uuid_vector_t& group_members = mAvatarList->getIDs();
group_members.clear();
@ -119,3 +129,45 @@ bool LLParticipantList::SpeakerClearListener::handleEvent(LLPointer<LLOldEvents:
return true;
}
void LLParticipantList::sort()
{
if ( !mAvatarList )
return;
// Mark AvatarList as dirty one
mAvatarList->setDirty();
// TODO: Implement more sorting orders after specs updating (EM)
switch ( mSortOrder ) {
case E_SORT_BY_NAME :
mAvatarList->sortByName();
break;
default :
llwarns << "Unrecognized sort order for " << mAvatarList->getName() << llendl;
return;
}
}
//
// LLParticipantList::SpeakerAddListener
//
bool LLParticipantList::SpeakerAddListener::handleEvent(LLPointer<LLOldEvents::LLEvent> event, const LLSD& userdata)
{
return mParent.onAddItemEvent(event, userdata);
}
//
// LLParticipantList::SpeakerRemoveListener
//
bool LLParticipantList::SpeakerRemoveListener::handleEvent(LLPointer<LLOldEvents::LLEvent> event, const LLSD& userdata)
{
return mParent.onRemoveItemEvent(event, userdata);
}
//
// LLParticipantList::SpeakerClearListener
//
bool LLParticipantList::SpeakerClearListener::handleEvent(LLPointer<LLOldEvents::LLEvent> event, const LLSD& userdata)
{
return mParent.onClearListEvent(event, userdata);
}

64
indra/newview/llparticipantlist.h
View File

@ -38,46 +38,74 @@ class LLAvatarList;
class LLParticipantList
{
LOG_CLASS(LLParticipantList);
public:
LLParticipantList(LLSpeakerMgr* data_source, LLAvatarList* avatar_list);
~LLParticipantList();
typedef enum e_participant_sort_oder {
E_SORT_BY_NAME = 0,
} EParticipantSortOrder;
/**
* Set and sort Avatarlist by given order
*/
void setSortOrder(EParticipantSortOrder order = E_SORT_BY_NAME);
protected:
/**
* LLSpeakerMgr event handlers
*/
bool onAddItemEvent(LLPointer<LLOldEvents::LLEvent> event, const LLSD& userdata);
bool onRemoveItemEvent(LLPointer<LLOldEvents::LLEvent> event, const LLSD& userdata);
bool onClearListEvent(LLPointer<LLOldEvents::LLEvent> event, const LLSD& userdata);
/**
* Sorts the Avatarlist by stored order
*/
void sort();
//List of listeners implementing LLOldEvents::LLSimpleListener.
//There is no way to handle all the events in one listener as LLSpeakerMgr registers listeners in such a way
//that one listener can handle only one type of event
class SpeakerAddListener : public LLOldEvents::LLSimpleListener
class BaseSpeakerListner : public LLOldEvents::LLSimpleListener
{
public:
SpeakerAddListener(LLAvatarList* avatar_list) : mAvatarList(avatar_list) {}
/*virtual*/ bool handleEvent(LLPointer<LLOldEvents::LLEvent> event, const LLSD& userdata);
LLAvatarList* mAvatarList;
BaseSpeakerListner(LLParticipantList& parent) : mParent(parent) {}
protected:
LLParticipantList& mParent;
};
class SpeakerRemoveListener : public LLOldEvents::LLSimpleListener
class SpeakerAddListener : public BaseSpeakerListner
{
public:
SpeakerRemoveListener(LLAvatarList* avatar_list) : mAvatarList(avatar_list) {}
SpeakerAddListener(LLParticipantList& parent) : BaseSpeakerListner(parent) {}
/*virtual*/ bool handleEvent(LLPointer<LLOldEvents::LLEvent> event, const LLSD& userdata);
LLAvatarList* mAvatarList;
};
class SpeakerClearListener : public LLOldEvents::LLSimpleListener
class SpeakerRemoveListener : public BaseSpeakerListner
{
public:
SpeakerClearListener(LLAvatarList* avatar_list) : mAvatarList(avatar_list) {}
SpeakerRemoveListener(LLParticipantList& parent) : BaseSpeakerListner(parent) {}
/*virtual*/ bool handleEvent(LLPointer<LLOldEvents::LLEvent> event, const LLSD& userdata);
LLAvatarList* mAvatarList;
};
class SpeakerClearListener : public BaseSpeakerListner
{
public:
SpeakerClearListener(LLParticipantList& parent) : BaseSpeakerListner(parent) {}
/*virtual*/ bool handleEvent(LLPointer<LLOldEvents::LLEvent> event, const LLSD& userdata);
};
private:
LLSpeakerMgr* mSpeakerMgr;
LLAvatarList* mAvatarList;
void onAvatarListDoubleClicked(LLAvatarList* list);
SpeakerAddListener* mSpeakerAddListener;
SpeakerRemoveListener* mSpeakerRemoveListener;
SpeakerClearListener* mSpeakerClearListener;
LLSpeakerMgr* mSpeakerMgr;
LLAvatarList* mAvatarList;
SpeakerAddListener mSpeakerAddListener;
SpeakerRemoveListener mSpeakerRemoveListener;
SpeakerClearListener mSpeakerClearListener;
EParticipantSortOrder mSortOrder;
};

5
indra/newview/llpreview.cpp
View File

@ -45,6 +45,7 @@
#include "lltooldraganddrop.h"
#include "llradiogroup.h"
#include "llassetstorage.h"
#include "llviewerassettype.h"
#include "llviewerobject.h"
#include "llviewerobjectlist.h"
#include "lldbstrings.h"
@ -317,7 +318,7 @@ BOOL LLPreview::handleHover(S32 x, S32 y, MASK mask)
&& LLToolDragAndDrop::getInstance()->isOverThreshold(screen_x, screen_y))
{
EDragAndDropType type;
type = LLAssetType::lookupDragAndDropType(item->getType());
type = LLViewerAssetType::lookupDragAndDropType(item->getType());
LLToolDragAndDrop::ESource src = LLToolDragAndDrop::SOURCE_LIBRARY;
if(!mObjectUUID.isNull())
{
@ -406,7 +407,7 @@ void LLPreview::onDiscardBtn(void* data)
*/
// Move the item to the trash
LLUUID trash_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_TRASH);
const LLUUID trash_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_TRASH);
if (item->getParentUUID() != trash_id)
{
LLInventoryModel::update_list_t update;

4
indra/newview/llpreviewgesture.cpp
View File

@ -130,10 +130,10 @@ LLPreviewGesture* LLPreviewGesture::show(const LLUUID& item_id, const LLUUID& ob
preview->setObjectID(object_id);
// Start speculative download of sounds and animations
LLUUID animation_folder_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_ANIMATION);
const LLUUID animation_folder_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_ANIMATION);
gInventory.startBackgroundFetch(animation_folder_id);
LLUUID sound_folder_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_SOUND);
const LLUUID sound_folder_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_SOUND);
gInventory.startBackgroundFetch(sound_folder_id);
// this will call refresh when we have everything.

3
indra/newview/llresourcedata.h
View File

@ -39,11 +39,12 @@
struct LLResourceData
{
LLAssetInfo mAssetInfo;
LLAssetType::EType mPreferredLocation;
LLFolderType::EType mPreferredLocation;
LLInventoryType::EType mInventoryType;
U32 mNextOwnerPerm;
S32 mExpectedUploadCost;
void *mUserData;
static const S8 INVALID_LOCATION = -2;
};
#endif

2
indra/newview/llselectmgr.cpp
View File

@ -2827,7 +2827,7 @@ bool LLSelectMgr::confirmDelete(const LLSD& notification, const LLSD& response,
case 0:
{
// TODO: Make sure you have delete permissions on all of them.
LLUUID trash_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_TRASH);
const LLUUID trash_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_TRASH);
// attempt to derez into the trash.
LLDeRezInfo* info = new LLDeRezInfo(DRD_TRASH, trash_id);
LLSelectMgr::getInstance()->sendListToRegions("DeRezObject",

6
indra/newview/llstartup.cpp
View File

@ -334,7 +334,7 @@ void populate_favorites_bar()
S32 count = lib_cats->count();
for(S32 i = 0; i < count; ++i)
{
if(lib_cats->get(i)->getPreferredType() == LLAssetType::AT_LANDMARK)
if(lib_cats->get(i)->getPreferredType() == LLFolderType::FT_LANDMARK)
{
lib_landmarks = lib_cats->get(i)->getUUID();
break;
@ -351,7 +351,7 @@ void populate_favorites_bar()
gInventory.getDirectDescendentsOf(lib_landmarks, lm_cats, lm_items);
if (!lm_items) return;
LLUUID favorites_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_FAVORITE);
const LLUUID favorites_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_FAVORITE);
if (favorites_id.isNull())
{
llerror("My Inventory is missing My Favorites", 0);
@ -1673,7 +1673,7 @@ bool idle_startup()
gInventory.buildParentChildMap();
//all categories loaded. lets create "My Favorites" category
gInventory.findCategoryUUIDForType(LLAssetType::AT_FAVORITE,true);
gInventory.findCategoryUUIDForType(LLFolderType::FT_FAVORITE,true);
// lets create "Friends" and "Friends/All" in the Inventory "Calling Cards" and fill it with buddies
LLFriendCardsManager::instance().syncFriendsFolder();

4
indra/newview/lltexturectrl.cpp
View File

@ -426,7 +426,7 @@ BOOL LLFloaterTexturePicker::postBuild()
mInventoryPanel->getRootFolder()->getFilter()->markDefault();
// Commented out to stop opening all folders with textures
// mInventoryPanel->openDefaultFolderForType(LLAssetType::AT_TEXTURE);
// mInventoryPanel->openDefaultFolderForType(LLFolderType::FT_TEXTURE);
// don't put keyboard focus on selected item, because the selection callback
// will assume that this was user input
@ -1073,7 +1073,7 @@ BOOL LLTextureCtrl::handleMouseDown(S32 x, S32 y, MASK mask)
{
showPicker(FALSE);
//grab textures first...
gInventory.startBackgroundFetch(gInventory.findCategoryUUIDForType(LLAssetType::AT_TEXTURE));
gInventory.startBackgroundFetch(gInventory.findCategoryUUIDForType(LLFolderType::FT_TEXTURE));
//...then start full inventory fetch.
gInventory.startBackgroundFetch();
handled = TRUE;

1
indra/newview/lltoastgroupnotifypanel.cpp
View File

@ -220,7 +220,6 @@ bool LLToastGroupNotifyPanel::isAttachmentOpenable(LLAssetType::EType type)
switch(type)
{
case LLAssetType::AT_LANDMARK:
case LLAssetType::AT_FAVORITE:
case LLAssetType::AT_NOTECARD:
case LLAssetType::AT_IMAGE_JPEG:
case LLAssetType::AT_IMAGE_TGA:

21
indra/newview/lltooldraganddrop.cpp
View File

@ -92,7 +92,7 @@ public:
virtual bool operator()(LLInventoryCategory* cat,
LLInventoryItem* item)
{
if(cat && (cat->getPreferredType() == LLAssetType::AT_NONE))
if(cat && (cat->getPreferredType() == LLFolderType::FT_NONE))
{
return true;
}
@ -109,7 +109,7 @@ public:
LLInventoryItem* item)
{
if(item) return true;
if(cat && (cat->getPreferredType() == LLAssetType::AT_NONE))
if(cat && (cat->getPreferredType() == LLFolderType::FT_NONE))
{
return true;
}
@ -1317,8 +1317,7 @@ void LLToolDragAndDrop::dropObject(LLViewerObject* raycast_target,
// Check if it's in the trash.
bool is_in_trash = false;
LLUUID trash_id;
trash_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_TRASH);
const LLUUID trash_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_TRASH);
if(gInventory.isObjectDescendentOf(item->getUUID(), trash_id))
{
is_in_trash = true;
@ -2088,7 +2087,7 @@ EAcceptance LLToolDragAndDrop::dad3dRezAttachmentFromInv(
if(!item || !item->isComplete()) return ACCEPT_NO;
// must not be in the trash
LLUUID trash_id(gInventory.findCategoryUUIDForType(LLAssetType::AT_TRASH));
const LLUUID trash_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_TRASH);
if( gInventory.isObjectDescendentOf( item->getUUID(), trash_id ) )
{
return ACCEPT_NO;
@ -2170,8 +2169,7 @@ EAcceptance LLToolDragAndDrop::dad3dRezObjectOnLand(
}
// Check if it's in the trash.
LLUUID trash_id;
trash_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_TRASH);
const LLUUID trash_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_TRASH);
if(gInventory.isObjectDescendentOf(item->getUUID(), trash_id))
{
accept = ACCEPT_YES_SINGLE;
@ -2249,8 +2247,7 @@ EAcceptance LLToolDragAndDrop::dad3dRezObjectOnObject(
}
// Check if it's in the trash.
LLUUID trash_id;
trash_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_TRASH);
const LLUUID trash_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_TRASH);
if(gInventory.isObjectDescendentOf(item->getUUID(), trash_id))
{
accept = ACCEPT_YES_SINGLE;
@ -2388,7 +2385,7 @@ EAcceptance LLToolDragAndDrop::dad3dWearItem(
if(mSource == SOURCE_AGENT || mSource == SOURCE_LIBRARY)
{
// it's in the agent inventory
LLUUID trash_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_TRASH);
const LLUUID trash_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_TRASH);
if( gInventory.isObjectDescendentOf( item->getUUID(), trash_id ) )
{
return ACCEPT_NO;
@ -2443,7 +2440,7 @@ EAcceptance LLToolDragAndDrop::dad3dActivateGesture(
if(mSource == SOURCE_AGENT || mSource == SOURCE_LIBRARY)
{
// it's in the agent inventory
LLUUID trash_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_TRASH);
const LLUUID trash_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_TRASH);
if( gInventory.isObjectDescendentOf( item->getUUID(), trash_id ) )
{
return ACCEPT_NO;
@ -2502,7 +2499,7 @@ EAcceptance LLToolDragAndDrop::dad3dWearCategory(
if(mSource == SOURCE_AGENT)
{
LLUUID trash_id(gInventory.findCategoryUUIDForType(LLAssetType::AT_TRASH));
const LLUUID trash_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_TRASH);
if( gInventory.isObjectDescendentOf( category->getUUID(), trash_id ) )
{
return ACCEPT_NO;

114
indra/newview/llviewerassettype.cpp Normal file
View File

@ -0,0 +1,114 @@
/**
* @file llassettype.cpp
* @brief Implementatino of LLViewerAssetType functionality.
*
* $LicenseInfo:firstyear=2001&license=viewergpl$
*
* Copyright (c) 2001-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#include "llviewerprecompiledheaders.h"
#include "llviewerassettype.h"
#include "lldictionary.h"
#include "llmemory.h"
#include "llsingleton.h"
static const std::string empty_string;
struct ViewerAssetEntry : public LLDictionaryEntry
{
ViewerAssetEntry(EDragAndDropType dad_type // drag and drop type
)
:
LLDictionaryEntry(empty_string), // no reverse lookup needed for now, so just leave this blank
mDadType(dad_type)
{
}
EDragAndDropType mDadType;
};
class LLViewerAssetDictionary : public LLSingleton<LLViewerAssetDictionary>,
public LLDictionary<LLViewerAssetType::EType, ViewerAssetEntry>
{
public:
LLViewerAssetDictionary();
};
LLViewerAssetDictionary::LLViewerAssetDictionary()
{
// DRAG&DROP TYPE
// |--------------------|
addEntry(LLViewerAssetType::AT_TEXTURE, new ViewerAssetEntry(DAD_TEXTURE));
addEntry(LLViewerAssetType::AT_SOUND, new ViewerAssetEntry(DAD_SOUND));
addEntry(LLViewerAssetType::AT_CALLINGCARD, new ViewerAssetEntry(DAD_CALLINGCARD));
addEntry(LLViewerAssetType::AT_LANDMARK, new ViewerAssetEntry(DAD_LANDMARK));
addEntry(LLViewerAssetType::AT_SCRIPT, new ViewerAssetEntry(DAD_NONE));
addEntry(LLViewerAssetType::AT_CLOTHING, new ViewerAssetEntry(DAD_CLOTHING));
addEntry(LLViewerAssetType::AT_OBJECT, new ViewerAssetEntry(DAD_OBJECT));
addEntry(LLViewerAssetType::AT_NOTECARD, new ViewerAssetEntry(DAD_NOTECARD));
addEntry(LLViewerAssetType::AT_CATEGORY, new ViewerAssetEntry(DAD_CATEGORY));
addEntry(LLViewerAssetType::AT_ROOT_CATEGORY, new ViewerAssetEntry(DAD_ROOT_CATEGORY));
addEntry(LLViewerAssetType::AT_LSL_TEXT, new ViewerAssetEntry(DAD_SCRIPT));
addEntry(LLViewerAssetType::AT_LSL_BYTECODE, new ViewerAssetEntry(DAD_NONE));
addEntry(LLViewerAssetType::AT_TEXTURE_TGA, new ViewerAssetEntry(DAD_NONE));
addEntry(LLViewerAssetType::AT_BODYPART, new ViewerAssetEntry(DAD_BODYPART));
addEntry(LLViewerAssetType::AT_SOUND_WAV, new ViewerAssetEntry(DAD_NONE));
addEntry(LLViewerAssetType::AT_IMAGE_TGA, new ViewerAssetEntry(DAD_NONE));
addEntry(LLViewerAssetType::AT_IMAGE_JPEG, new ViewerAssetEntry(DAD_NONE));
addEntry(LLViewerAssetType::AT_ANIMATION, new ViewerAssetEntry(DAD_ANIMATION));
addEntry(LLViewerAssetType::AT_GESTURE, new ViewerAssetEntry(DAD_GESTURE));
addEntry(LLViewerAssetType::AT_SIMSTATE, new ViewerAssetEntry(DAD_NONE));
addEntry(LLViewerAssetType::AT_LINK, new ViewerAssetEntry(DAD_LINK));
addEntry(LLViewerAssetType::AT_LINK_FOLDER, new ViewerAssetEntry(DAD_LINK));
addEntry(LLViewerAssetType::AT_NONE, new ViewerAssetEntry(DAD_NONE));
};
EDragAndDropType LLViewerAssetType::lookupDragAndDropType(EType asset_type)
{
const LLViewerAssetDictionary *dict = LLViewerAssetDictionary::getInstance();
const ViewerAssetEntry *entry = dict->lookup(asset_type);
if (entry)
return entry->mDadType;
else
return DAD_NONE;
}
// Generate a good default description
void LLViewerAssetType::generateDescriptionFor(LLViewerAssetType::EType asset_type,
std::string& description)
{
const S32 BUF_SIZE = 30;
char time_str[BUF_SIZE]; /* Flawfinder: ignore */
time_t now;
time(&now);
memset(time_str, '\0', BUF_SIZE);
strftime(time_str, BUF_SIZE - 1, "%Y-%m-%d %H:%M:%S ", localtime(&now));
description.assign(time_str);
description.append(LLAssetType::lookupHumanReadable(asset_type));
}

54
indra/newview/llviewerassettype.h Normal file
View File

@ -0,0 +1,54 @@
/**
* @file llviewerassettype.h
* @brief Declaration of LLViewerViewerAssetType.
*
* $LicenseInfo:firstyear=2001&license=viewergpl$
*
* Copyright (c) 2001-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#ifndef LL_LLVIEWERASSETTYPE_H
#define LL_LLVIEWERASSETTYPE_H
#include <string>
#include "llassettype.h"
// This class is similar to llassettype, but contains methods
// only used by the viewer.
class LLViewerAssetType : public LLAssetType
{
public:
// Generate a good default description. You may want to add a verb
// or agent name after this depending on your application.
static void generateDescriptionFor(LLViewerAssetType::EType asset_type,
std::string& description);
static EDragAndDropType lookupDragAndDropType(EType asset_type);
protected:
LLViewerAssetType() {}
~LLViewerAssetType() {}
};
#endif // LL_LLVIEWERASSETTYPE_H

263
indra/newview/llviewerfoldertype.cpp Normal file
View File

@ -0,0 +1,263 @@
/**
* @file llfoldertype.cpp
* @brief Implementation of LLViewerFolderType functionality.
*
* $LicenseInfo:firstyear=2001&license=viewergpl$
*
* Copyright (c) 2001-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#include "llviewerprecompiledheaders.h"
#include "llviewerfoldertype.h"
#include "lldictionary.h"
#include "llmemory.h"
#include "llvisualparam.h"
static const std::string empty_string;
struct ViewerFolderEntry : public LLDictionaryEntry
{
// Constructor for non-ensembles
ViewerFolderEntry(const std::string &new_category_name, // default name when creating a new category of this type
const std::string &icon_name // name of the folder icon
)
:
LLDictionaryEntry(empty_string), // no reverse lookup needed on non-ensembles, so just leave this blank
mIconName(icon_name),
mNewCategoryName(new_category_name)
{
mAllowedNames.clear();
}
// Constructor for ensembles
ViewerFolderEntry(const std::string &xui_name, // name of the xui menu item
const std::string &new_category_name, // default name when creating a new category of this type
const std::string &icon_name, // name of the folder icon
const std::string allowed_names // allowed item typenames for this folder type
)
:
LLDictionaryEntry(xui_name),
mIconName(icon_name),
mNewCategoryName(new_category_name)
{
const std::string delims (",");
LLStringUtilBase<char>::getTokens(allowed_names, mAllowedNames, delims);
}
bool getIsAllowedName(const std::string &name) const
{
if (mAllowedNames.empty())
return false;
for (name_vec_t::const_iterator iter = mAllowedNames.begin();
iter != mAllowedNames.end();
iter++)
{
if (name == (*iter))
return true;
}
return false;
}
const std::string mIconName;
const std::string mNewCategoryName;
typedef std::vector<std::string> name_vec_t;
name_vec_t mAllowedNames;
};
class LLViewerFolderDictionary : public LLSingleton<LLViewerFolderDictionary>,
public LLDictionary<LLFolderType::EType, ViewerFolderEntry>
{
public:
LLViewerFolderDictionary();
protected:
bool initEnsemblesFromFile(); // Reads in ensemble information from foldertypes.xml
};
LLViewerFolderDictionary::LLViewerFolderDictionary()
{
initEnsemblesFromFile();
// NEW CATEGORY NAME FOLDER ICON NAME
// |-------------------------|---------------------------|
addEntry(LLFolderType::FT_TEXTURE, new ViewerFolderEntry("Textures", "inv_folder_texture.tga"));
addEntry(LLFolderType::FT_SOUND, new ViewerFolderEntry("Sounds", "inv_folder_sound.tga"));
addEntry(LLFolderType::FT_CALLINGCARD, new ViewerFolderEntry("Calling Cards", "inv_folder_callingcard.tga"));
addEntry(LLFolderType::FT_LANDMARK, new ViewerFolderEntry("Landmarks", "inv_folder_landmark.tga"));
addEntry(LLFolderType::FT_CLOTHING, new ViewerFolderEntry("Clothing", "inv_folder_clothing.tga"));
addEntry(LLFolderType::FT_OBJECT, new ViewerFolderEntry("Objects", "inv_folder_object.tga"));
addEntry(LLFolderType::FT_NOTECARD, new ViewerFolderEntry("Notecards", "inv_folder_notecard.tga"));
addEntry(LLFolderType::FT_CATEGORY, new ViewerFolderEntry("New Folder", "inv_folder_plain_closed.tga"));
addEntry(LLFolderType::FT_ROOT_CATEGORY, new ViewerFolderEntry("Inventory", ""));
addEntry(LLFolderType::FT_LSL_TEXT, new ViewerFolderEntry("Scripts", "inv_folder_script.tga"));
addEntry(LLFolderType::FT_BODYPART, new ViewerFolderEntry("Body Parts", "inv_folder_bodypart.tga"));
addEntry(LLFolderType::FT_TRASH, new ViewerFolderEntry("Trash", "inv_folder_trash.tga"));
addEntry(LLFolderType::FT_SNAPSHOT_CATEGORY, new ViewerFolderEntry("Photo Album", "inv_folder_snapshot.tga"));
addEntry(LLFolderType::FT_LOST_AND_FOUND, new ViewerFolderEntry("Lost And Found", "inv_folder_lostandfound.tga"));
addEntry(LLFolderType::FT_ANIMATION, new ViewerFolderEntry("Animations", "inv_folder_animation.tga"));
addEntry(LLFolderType::FT_GESTURE, new ViewerFolderEntry("Gestures", "inv_folder_gesture.tga"));
addEntry(LLFolderType::FT_FAVORITE, new ViewerFolderEntry("Favorite", "inv_folder_plain_closed.tga"));
addEntry(LLFolderType::FT_CURRENT_OUTFIT, new ViewerFolderEntry("Current Outfit", "inv_folder_current_outfit.tga"));
addEntry(LLFolderType::FT_OUTFIT, new ViewerFolderEntry("New Outfit", "inv_folder_outfit.tga"));
addEntry(LLFolderType::FT_MY_OUTFITS, new ViewerFolderEntry("My Outfits", "inv_folder_my_outfits.tga"));
addEntry(LLFolderType::FT_INBOX, new ViewerFolderEntry("Inbox", "inv_folder_inbox.tga"));
addEntry(LLFolderType::FT_NONE, new ViewerFolderEntry("New Folder", "inv_folder_plain_closed.tga"));
}
bool LLViewerFolderDictionary::initEnsemblesFromFile()
{
std::string xml_filename = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS,"foldertypes.xml");
LLXmlTree folder_def;
if (!folder_def.parseFile(xml_filename))
{
llerrs << "Failed to parse folders file " << xml_filename << llendl;
return false;
}
LLXmlTreeNode* rootp = folder_def.getRoot();
for (LLXmlTreeNode* ensemble = rootp->getFirstChild();
ensemble;
ensemble = rootp->getNextChild())
{
if (!ensemble->hasName("ensemble"))
{
llwarns << "Invalid ensemble definition node " << ensemble->getName() << llendl;
continue;
}
S32 ensemble_type;
static LLStdStringHandle ensemble_num_string = LLXmlTree::addAttributeString("foldertype_num");
if (!ensemble->getFastAttributeS32(ensemble_num_string, ensemble_type))
{
llwarns << "No ensemble type defined" << llendl;
continue;
}
if (ensemble_type < S32(LLFolderType::FT_ENSEMBLE_START) || ensemble_type > S32(LLFolderType::FT_ENSEMBLE_END))
{
llwarns << "Exceeded maximum ensemble index" << LLFolderType::FT_ENSEMBLE_END << llendl;
break;
}
std::string xui_name;
static LLStdStringHandle xui_name_string = LLXmlTree::addAttributeString("xui_name");
if (!ensemble->getFastAttributeString(xui_name_string, xui_name))
{
llwarns << "No xui name defined" << llendl;
continue;
}
std::string icon_name;
static LLStdStringHandle icon_name_string = LLXmlTree::addAttributeString("icon_name");
if (!ensemble->getFastAttributeString(icon_name_string, icon_name))
{
llwarns << "No ensemble icon name defined" << llendl;
continue;
}
std::string allowed_names;
static LLStdStringHandle allowed_names_string = LLXmlTree::addAttributeString("allowed");
if (!ensemble->getFastAttributeString(allowed_names_string, allowed_names))
{
}
// Add the entry and increment the asset number.
const static std::string new_ensemble_name = "New Ensemble";
addEntry(LLFolderType::EType(ensemble_type), new ViewerFolderEntry(xui_name, new_ensemble_name, icon_name, allowed_names));
}
return true;
}
const std::string &LLViewerFolderType::lookupXUIName(LLFolderType::EType folder_type)
{
const ViewerFolderEntry *entry = LLViewerFolderDictionary::getInstance()->lookup(folder_type);
if (entry)
{
return entry->mName;
}
return badLookup();
}
LLFolderType::EType LLViewerFolderType::lookupTypeFromXUIName(const std::string &name)
{
return LLViewerFolderDictionary::getInstance()->lookup(name);
}
const std::string &LLViewerFolderType::lookupIconName(LLFolderType::EType folder_type)
{
const ViewerFolderEntry *entry = LLViewerFolderDictionary::getInstance()->lookup(folder_type);
if (entry)
{
return entry->mIconName;
}
return badLookup();
}
const std::string &LLViewerFolderType::lookupNewCategoryName(LLFolderType::EType folder_type)
{
const ViewerFolderEntry *entry = LLViewerFolderDictionary::getInstance()->lookup(folder_type);
if (entry)
{
return entry->mNewCategoryName;
}
return badLookup();
}
LLFolderType::EType LLViewerFolderType::lookupTypeFromNewCategoryName(const std::string& name)
{
for (LLViewerFolderDictionary::const_iterator iter = LLViewerFolderDictionary::getInstance()->begin();
iter != LLViewerFolderDictionary::getInstance()->end();
iter++)
{
const ViewerFolderEntry *entry = iter->second;
if (entry->mNewCategoryName == name)
{
return iter->first;
}
}
return FT_NONE;
}
U64 LLViewerFolderType::lookupValidFolderTypes(const std::string& item_name)
{
U64 matching_folders = 0;
for (LLViewerFolderDictionary::const_iterator iter = LLViewerFolderDictionary::getInstance()->begin();
iter != LLViewerFolderDictionary::getInstance()->end();
iter++)
{
const ViewerFolderEntry *entry = iter->second;
if (entry->getIsAllowedName(item_name))
{
matching_folders |= 1LL << iter->first;
}
}
return matching_folders;
}

57
indra/newview/llviewerfoldertype.h Normal file
View File

@ -0,0 +1,57 @@
/**
* @file llviewerfoldertype.h
* @brief Declaration of LLAssetType.
*
* $LicenseInfo:firstyear=2001&license=viewergpl$
*
* Copyright (c) 2001-2009, Linden Research, Inc.
*
* Second Life Viewer Source Code
* The source code in this file ("Source Code") is provided by Linden Lab
* to you under the terms of the GNU General Public License, version 2.0
* ("GPL"), unless you have obtained a separate licensing agreement
* ("Other License"), formally executed by you and Linden Lab. Terms of
* the GPL can be found in doc/GPL-license.txt in this distribution, or
* online at http://secondlifegrid.net/programs/open_source/licensing/gplv2
*
* There are special exceptions to the terms and conditions of the GPL as
* it is applied to this Source Code. View the full text of the exception
* in the file doc/FLOSS-exception.txt in this software distribution, or
* online at
* http://secondlifegrid.net/programs/open_source/licensing/flossexception
*
* By copying, modifying or distributing this software, you acknowledge
* that you have read and understood your obligations described above,
* and agree to abide by those obligations.
*
* ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
* WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
* COMPLETENESS OR PERFORMANCE.
* $/LicenseInfo$
*/
#ifndef LL_LLVIEWERFOLDERTYPE_H
#define LL_LLVIEWERFOLDERTYPE_H
#include <string>
#include "llfoldertype.h"
// This class is similar to llfoldertype, but contains methods
// only used by the viewer. This also handles ensembles.
class LLViewerFolderType : public LLFolderType
{
public:
static const std::string& lookupXUIName(EType folder_type); // name used by the UI
static LLFolderType::EType lookupTypeFromXUIName(const std::string& name);
static const std::string& lookupIconName(EType asset_type); // folder icon name
static const std::string& lookupNewCategoryName(EType folder_type); // default name when creating new category
static LLFolderType::EType lookupTypeFromNewCategoryName(const std::string& name); // default name when creating new category
static U64 lookupValidFolderTypes(const std::string& item_name); // which folders allow an item of this type?
protected:
LLViewerFolderType() {}
~LLViewerFolderType() {}
};
#endif // LL_LLVIEWERFOLDERTYPE_H

112
indra/newview/llviewerinventory.cpp
View File

@ -37,7 +37,7 @@
#include "indra_constants.h"
#include "llagent.h"
#include "llfoldertype.h"
#include "llviewerfoldertype.h"
#include "llfolderview.h"
#include "llviewercontrol.h"
#include "llconsole.h"
@ -48,6 +48,7 @@
#include "llinventorybridge.h"
#include "llfloaterinventory.h"
#include "llviewerassettype.h"
#include "llviewerregion.h"
#include "llviewerobjectlist.h"
#include "llpreviewgesture.h"
@ -359,7 +360,7 @@ void LLViewerInventoryItem::updateParentOnServer(BOOL restamp) const
LLViewerInventoryCategory::LLViewerInventoryCategory(const LLUUID& uuid,
const LLUUID& parent_uuid,
LLAssetType::EType pref,
LLFolderType::EType pref,
const std::string& name,
const LLUUID& owner_id) :
LLInventoryCategory(uuid, parent_uuid, pref, name),
@ -416,7 +417,7 @@ void LLViewerInventoryCategory::updateServer(BOOL is_new) const
{
// communicate that change with the server.
if (LLAssetType::lookupIsProtectedCategoryType(mPreferredType))
if (LLFolderType::lookupIsProtectedType(mPreferredType))
{
LLNotifications::instance().add("CannotModifyProtectedCategories");
return;
@ -440,7 +441,7 @@ void LLViewerInventoryCategory::removeFromServer( void )
llinfos << "Removing inventory category " << mUUID << " from server."
<< llendl;
// communicate that change with the server.
if(LLAssetType::lookupIsProtectedCategoryType(mPreferredType))
if(LLFolderType::lookupIsProtectedType(mPreferredType))
{
LLNotifications::instance().add("CannotRemoveProtectedCategories");
return;
@ -543,7 +544,7 @@ bool LLViewerInventoryCategory::importFileLocal(LLFILE* fp)
}
else if(0 == strcmp("pref_type", keyword))
{
mPreferredType = LLAssetType::lookup(valuestr);
mPreferredType = LLFolderType::lookup(valuestr);
}
else if(0 == strcmp("name", keyword))
{
@ -581,7 +582,7 @@ bool LLViewerInventoryCategory::exportFileLocal(LLFILE* fp) const
mParentUUID.toString(uuid_str);
fprintf(fp, "\t\tparent_id\t%s\n", uuid_str.c_str());
fprintf(fp, "\t\ttype\t%s\n", LLAssetType::lookup(mType));
fprintf(fp, "\t\tpref_type\t%s\n", LLAssetType::lookup(mPreferredType));
fprintf(fp, "\t\tpref_type\t%s\n", LLFolderType::lookup(mPreferredType).c_str());
fprintf(fp, "\t\tname\t%s|\n", mName.c_str());
mOwnerID.toString(uuid_str);
fprintf(fp, "\t\towner_id\t%s\n", uuid_str.c_str());
@ -592,8 +593,8 @@ bool LLViewerInventoryCategory::exportFileLocal(LLFILE* fp) const
void LLViewerInventoryCategory::determineFolderType()
{
LLAssetType::EType original_type = getPreferredType();
if (LLAssetType::lookupIsProtectedCategoryType(original_type))
LLFolderType::EType original_type = getPreferredType();
if (LLFolderType::lookupIsProtectedType(original_type))
return;
U64 folder_valid = 0;
@ -616,28 +617,28 @@ void LLViewerInventoryCategory::determineFolderType()
{
const EWearableType wearable_type = item->getWearableType();
const std::string& wearable_name = LLWearableDictionary::getTypeName(wearable_type);
U64 valid_folder_types = LLFolderType::lookupValidFolderTypes(wearable_name);
U64 valid_folder_types = LLViewerFolderType::lookupValidFolderTypes(wearable_name);
folder_valid |= valid_folder_types;
folder_invalid |= ~valid_folder_types;
}
}
for (U8 i = LLAssetType::AT_FOLDER_ENSEMBLE_START; i <= LLAssetType::AT_FOLDER_ENSEMBLE_END; i++)
for (U8 i = LLFolderType::FT_ENSEMBLE_START; i <= LLFolderType::FT_ENSEMBLE_END; i++)
{
if ((folder_valid & (1LL << i)) &&
!(folder_invalid & (1LL << i)))
{
changeType((LLAssetType::EType)i);
changeType((LLFolderType::EType)i);
return;
}
}
}
if (LLAssetType::lookupIsEnsembleCategoryType(original_type))
if (LLFolderType::lookupIsEnsembleType(original_type))
{
changeType(LLAssetType::AT_NONE);
changeType(LLFolderType::FT_NONE);
}
}
void LLViewerInventoryCategory::changeType(LLAssetType::EType new_folder_type)
void LLViewerInventoryCategory::changeType(LLFolderType::EType new_folder_type)
{
const LLUUID &folder_id = getUUID();
const LLUUID &parent_id = getParentUUID();
@ -948,7 +949,7 @@ void copy_inventory_from_notecard(const LLUUID& object_id, const LLUUID& notecar
body["notecard-id"] = notecard_inv_id;
body["object-id"] = object_id;
body["item-id"] = src->getUUID();
body["folder-id"] = gInventory.findCategoryUUIDForType(src->getType());
body["folder-id"] = gInventory.findCategoryUUIDForType(LLFolderType::assetTypeToFolderType(src->getType()));
body["callback-id"] = (LLSD::Integer)callback_id;
request["message"] = "CopyInventoryFromNotecard";
@ -964,7 +965,7 @@ void create_new_item(const std::string& name,
U32 next_owner_perm)
{
std::string desc;
LLAssetType::generateDescriptionFor(asset_type, desc);
LLViewerAssetType::generateDescriptionFor(asset_type, desc);
next_owner_perm = (next_owner_perm) ? next_owner_perm : PERM_MOVE | PERM_TRANSFER;
@ -989,19 +990,14 @@ const std::string NEW_LSL_NAME = "New Script"; // *TODO:Translate? (probably not
const std::string NEW_NOTECARD_NAME = "New Note"; // *TODO:Translate? (probably not)
const std::string NEW_GESTURE_NAME = "New Gesture"; // *TODO:Translate? (probably not)
// ! REFACTOR ! Really need to refactor this so that it's not a bunch of if-then statements...
void menu_create_inventory_item(LLFolderView* folder, LLFolderBridge *bridge, const LLSD& userdata, const LLUUID& default_parent_uuid)
{
std::string type = userdata.asString();
std::string type_name = userdata.asString();
if (("category" == type) || ("current" == type) || ("outfit" == type) || ("my_otfts" == type) )
if (("category" == type_name) || ("current" == type_name) || ("outfit" == type_name) || ("my_otfts" == type_name))
{
LLAssetType::EType a_type = LLAssetType::AT_NONE;
if ("current" == type)
a_type = LLAssetType::AT_CURRENT_OUTFIT;
if ("outfit" == type)
a_type = LLAssetType::AT_OUTFIT;
if ("my_otfts" == type)
a_type = LLAssetType::AT_MY_OUTFITS;
LLFolderType::EType preferred_type = LLFolderType::lookup(type_name);
LLUUID parent_id;
if (bridge)
@ -1017,100 +1013,100 @@ void menu_create_inventory_item(LLFolderView* folder, LLFolderBridge *bridge, co
parent_id = gInventory.getRootFolderID();
}
LLUUID category = gInventory.createNewCategory(parent_id, a_type, LLStringUtil::null);
LLUUID category = gInventory.createNewCategory(parent_id, preferred_type, LLStringUtil::null);
gInventory.notifyObservers();
folder->setSelectionByID(category, TRUE);
}
else if ("lsl" == type)
else if ("lsl" == type_name)
{
LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLAssetType::AT_LSL_TEXT);
const LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLFolderType::FT_LSL_TEXT);
create_new_item(NEW_LSL_NAME,
parent_id,
LLAssetType::AT_LSL_TEXT,
LLInventoryType::IT_LSL,
PERM_MOVE | PERM_TRANSFER);
}
else if ("notecard" == type)
else if ("notecard" == type_name)
{
LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLAssetType::AT_NOTECARD);
const LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLFolderType::FT_NOTECARD);
create_new_item(NEW_NOTECARD_NAME,
parent_id,
LLAssetType::AT_NOTECARD,
LLInventoryType::IT_NOTECARD,
PERM_ALL);
}
else if ("gesture" == type)
else if ("gesture" == type_name)
{
LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLAssetType::AT_GESTURE);
const LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLFolderType::FT_GESTURE);
create_new_item(NEW_GESTURE_NAME,
parent_id,
LLAssetType::AT_GESTURE,
LLInventoryType::IT_GESTURE,
PERM_ALL);
}
else if ("shirt" == type)
else if ("shirt" == type_name)
{
LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLAssetType::AT_CLOTHING);
const LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLFolderType::FT_CLOTHING);
LLFolderBridge::createWearable(parent_id, WT_SHIRT);
}
else if ("pants" == type)
else if ("pants" == type_name)
{
LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLAssetType::AT_CLOTHING);
const LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLFolderType::FT_CLOTHING);
LLFolderBridge::createWearable(parent_id, WT_PANTS);
}
else if ("shoes" == type)
else if ("shoes" == type_name)
{
LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLAssetType::AT_CLOTHING);
const LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLFolderType::FT_CLOTHING);
LLFolderBridge::createWearable(parent_id, WT_SHOES);
}
else if ("socks" == type)
else if ("socks" == type_name)
{
LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLAssetType::AT_CLOTHING);
const LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLFolderType::FT_CLOTHING);
LLFolderBridge::createWearable(parent_id, WT_SOCKS);
}
else if ("jacket" == type)
else if ("jacket" == type_name)
{
LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLAssetType::AT_CLOTHING);
const LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLFolderType::FT_CLOTHING);
LLFolderBridge::createWearable(parent_id, WT_JACKET);
}
else if ("skirt" == type)
else if ("skirt" == type_name)
{
LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLAssetType::AT_CLOTHING);
const LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLFolderType::FT_CLOTHING);
LLFolderBridge::createWearable(parent_id, WT_SKIRT);
}
else if ("gloves" == type)
else if ("gloves" == type_name)
{
LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLAssetType::AT_CLOTHING);
const LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLFolderType::FT_CLOTHING);
LLFolderBridge::createWearable(parent_id, WT_GLOVES);
}
else if ("undershirt" == type)
else if ("undershirt" == type_name)
{
LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLAssetType::AT_CLOTHING);
const LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLFolderType::FT_CLOTHING);
LLFolderBridge::createWearable(parent_id, WT_UNDERSHIRT);
}
else if ("underpants" == type)
else if ("underpants" == type_name)
{
LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLAssetType::AT_CLOTHING);
const LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLFolderType::FT_CLOTHING);
LLFolderBridge::createWearable(parent_id, WT_UNDERPANTS);
}
else if ("shape" == type)
else if ("shape" == type_name)
{
LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLAssetType::AT_BODYPART);
const LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLFolderType::FT_BODYPART);
LLFolderBridge::createWearable(parent_id, WT_SHAPE);
}
else if ("skin" == type)
else if ("skin" == type_name)
{
LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLAssetType::AT_BODYPART);
const LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLFolderType::FT_BODYPART);
LLFolderBridge::createWearable(parent_id, WT_SKIN);
}
else if ("hair" == type)
else if ("hair" == type_name)
{
LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLAssetType::AT_BODYPART);
const LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLFolderType::FT_BODYPART);
LLFolderBridge::createWearable(parent_id, WT_HAIR);
}
else if ("eyes" == type)
else if ("eyes" == type_name)
{
LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLAssetType::AT_BODYPART);
const LLUUID parent_id = bridge ? bridge->getUUID() : gInventory.findCategoryUUIDForType(LLFolderType::FT_BODYPART);
LLFolderBridge::createWearable(parent_id, WT_EYES);
}

4
indra/newview/llviewerinventory.h
View File

@ -185,7 +185,7 @@ protected:
public:
LLViewerInventoryCategory(const LLUUID& uuid, const LLUUID& parent_uuid,
LLAssetType::EType preferred_type,
LLFolderType::EType preferred_type,
const std::string& name,
const LLUUID& owner_id);
LLViewerInventoryCategory(const LLUUID& owner_id);
@ -221,7 +221,7 @@ public:
bool exportFileLocal(LLFILE* fp) const;
bool importFileLocal(LLFILE* fp);
void determineFolderType();
void changeType(LLAssetType::EType new_folder_type);
void changeType(LLFolderType::EType new_folder_type);
protected:
LLUUID mOwnerID;
S32 mVersion;

13
indra/newview/llviewermenu.cpp
View File

@ -4175,12 +4175,10 @@ void handle_take_copy()
{
if (LLSelectMgr::getInstance()->getSelection()->isEmpty()) return;
LLUUID category_id =
gInventory.findCategoryUUIDForType(LLAssetType::AT_OBJECT);
const LLUUID category_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_OBJECT);
derez_objects(DRD_ACQUIRE_TO_AGENT_INVENTORY, category_id);
}
// You can return an object to its owner if it is on your land.
class LLObjectReturn : public view_listener_t
{
@ -4261,7 +4259,7 @@ class LLObjectEnableReturn : public view_listener_t
void force_take_copy(void*)
{
if (LLSelectMgr::getInstance()->getSelection()->isEmpty()) return;
const LLUUID& category_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_OBJECT);
const LLUUID category_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_OBJECT);
derez_objects(DRD_FORCE_TO_GOD_INVENTORY, category_id);
}
@ -4322,8 +4320,7 @@ void handle_take()
if(category_id.notNull())
{
// check trash
LLUUID trash;
trash = gInventory.findCategoryUUIDForType(LLAssetType::AT_TRASH);
const LLUUID trash = gInventory.findCategoryUUIDForType(LLFolderType::FT_TRASH);
if(category_id == trash || gInventory.isObjectDescendentOf(category_id, trash))
{
category_id.setNull();
@ -4339,7 +4336,7 @@ void handle_take()
}
if(category_id.isNull())
{
category_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_OBJECT);
category_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_OBJECT);
}
LLSD payload;
payload["folder_id"] = category_id;
@ -6918,7 +6915,7 @@ void handle_grab_texture(void* data)
LL_INFOS("texture") << "Adding baked texture " << asset_id << " to inventory." << llendl;
LLAssetType::EType asset_type = LLAssetType::AT_TEXTURE;
LLInventoryType::EType inv_type = LLInventoryType::IT_TEXTURE;
LLUUID folder_id(gInventory.findCategoryUUIDForType(asset_type));
const LLUUID folder_id = gInventory.findCategoryUUIDForType(LLFolderType::assetTypeToFolderType(asset_type));
if(folder_id.notNull())
{
std::string name = "Unknown";

16
indra/newview/llviewermenufile.cpp
View File

@ -319,7 +319,7 @@ class LLFileUploadBulk : public view_listener_t
LLAssetStorage::LLStoreAssetCallback callback = NULL;
S32 expected_upload_cost = LLGlobalEconomy::Singleton::getInstance()->getPriceUpload();
void *userdata = NULL;
upload_new_resource(filename, asset_name, asset_name, 0, LLAssetType::AT_NONE, LLInventoryType::IT_NONE,
upload_new_resource(filename, asset_name, asset_name, 0, LLFolderType::FT_NONE, LLInventoryType::IT_NONE,
LLFloaterPerms::getNextOwnerPerms(), LLFloaterPerms::getGroupPerms(), LLFloaterPerms::getEveryonePerms(),
display_name,
callback, expected_upload_cost, userdata);
@ -493,7 +493,7 @@ void handle_compress_image(void*)
void upload_new_resource(const std::string& src_filename, std::string name,
std::string desc, S32 compression_info,
LLAssetType::EType destination_folder_type,
LLFolderType::EType destination_folder_type,
LLInventoryType::EType inv_type,
U32 next_owner_perms,
U32 group_perms,
@ -810,7 +810,7 @@ void upload_done_callback(const LLUUID& uuid, void* user_data, S32 result, LLExt
if(result >= 0)
{
LLAssetType::EType dest_loc = (data->mPreferredLocation == LLAssetType::AT_NONE) ? data->mAssetInfo.mType : data->mPreferredLocation;
LLFolderType::EType dest_loc = (data->mPreferredLocation == LLFolderType::FT_NONE) ? LLFolderType::assetTypeToFolderType(data->mAssetInfo.mType) : data->mPreferredLocation;
if (LLAssetType::AT_SOUND == data->mAssetInfo.mType ||
LLAssetType::AT_TEXTURE == data->mAssetInfo.mType ||
@ -856,7 +856,7 @@ void upload_done_callback(const LLUUID& uuid, void* user_data, S32 result, LLExt
{
// Actually add the upload to inventory
llinfos << "Adding " << uuid << " to inventory." << llendl;
LLUUID folder_id(gInventory.findCategoryUUIDForType(dest_loc));
const LLUUID folder_id = gInventory.findCategoryUUIDForType(dest_loc);
if(folder_id.notNull())
{
U32 next_owner_perms = data->mNextOwnerPerm;
@ -903,7 +903,7 @@ void upload_done_callback(const LLUUID& uuid, void* user_data, S32 result, LLExt
LLAssetStorage::LLStoreAssetCallback callback = NULL;
void *userdata = NULL;
upload_new_resource(next_file, asset_name, asset_name, // file
0, LLAssetType::AT_NONE, LLInventoryType::IT_NONE,
0, LLFolderType::FT_NONE, LLInventoryType::IT_NONE,
PERM_NONE, PERM_NONE, PERM_NONE,
display_name,
callback,
@ -915,7 +915,7 @@ void upload_done_callback(const LLUUID& uuid, void* user_data, S32 result, LLExt
void upload_new_resource(const LLTransactionID &tid, LLAssetType::EType asset_type,
std::string name,
std::string desc, S32 compression_info,
LLAssetType::EType destination_folder_type,
LLFolderType::EType destination_folder_type,
LLInventoryType::EType inv_type,
U32 next_owner_perms,
U32 group_perms,
@ -973,14 +973,14 @@ void upload_new_resource(const LLTransactionID &tid, LLAssetType::EType asset_ty
llinfos << "Name: " << name << llendl;
llinfos << "Desc: " << desc << llendl;
llinfos << "Expected Upload Cost: " << expected_upload_cost << llendl;
lldebugs << "Folder: " << gInventory.findCategoryUUIDForType((destination_folder_type == LLAssetType::AT_NONE) ? asset_type : destination_folder_type) << llendl;
lldebugs << "Folder: " << gInventory.findCategoryUUIDForType((destination_folder_type == LLFolderType::FT_NONE) ? LLFolderType::assetTypeToFolderType(asset_type) : destination_folder_type) << llendl;
lldebugs << "Asset Type: " << LLAssetType::lookup(asset_type) << llendl;
std::string url = gAgent.getRegion()->getCapability("NewFileAgentInventory");
if (!url.empty())
{
llinfos << "New Agent Inventory via capability" << llendl;
LLSD body;
body["folder_id"] = gInventory.findCategoryUUIDForType((destination_folder_type == LLAssetType::AT_NONE) ? asset_type : destination_folder_type);
body["folder_id"] = gInventory.findCategoryUUIDForType((destination_folder_type == LLFolderType::FT_NONE) ? LLFolderType::assetTypeToFolderType(asset_type) : destination_folder_type);
body["asset_type"] = LLAssetType::lookup(asset_type);
body["inventory_type"] = LLInventoryType::lookup(inv_type);
body["name"] = name;

6
indra/newview/llviewermenufile.h
View File

@ -33,7 +33,7 @@
#ifndef LLVIEWERMENUFILE_H
#define LLVIEWERMENUFILE_H
#include "llassettype.h"
#include "llfoldertype.h"
#include "llinventorytype.h"
class LLTransactionID;
@ -45,7 +45,7 @@ void upload_new_resource(const std::string& src_filename,
std::string name,
std::string desc,
S32 compression_info,
LLAssetType::EType destination_folder_type,
LLFolderType::EType destination_folder_type,
LLInventoryType::EType inv_type,
U32 next_owner_perms,
U32 group_perms,
@ -60,7 +60,7 @@ void upload_new_resource(const LLTransactionID &tid,
std::string name,
std::string desc,
S32 compression_info,
LLAssetType::EType destination_folder_type,
LLFolderType::EType destination_folder_type,
LLInventoryType::EType inv_type,
U32 next_owner_perms,
U32 group_perms,

42
indra/newview/llviewermessage.cpp
View File

@ -140,7 +140,7 @@
#include "llgroupactions.h"
#include "llagentui.h"
#include "llpanelblockedlist.h"
#include "llpanelplaceinfo.h"
#include "llpanelplaceprofile.h"
#include <boost/tokenizer.hpp>
#include <boost/algorithm/string/split.hpp>
@ -209,7 +209,6 @@ const BOOL SCRIPT_QUESTION_IS_CAUTION[SCRIPT_PERMISSION_EOF] =
bool friendship_offer_callback(const LLSD& notification, const LLSD& response)
{
S32 option = LLNotification::getSelectedOption(notification, response);
LLUUID fid;
LLMessageSystem* msg = gMessageSystem;
const LLSD& payload = notification["payload"];
@ -219,10 +218,11 @@ bool friendship_offer_callback(const LLSD& notification, const LLSD& response)
switch(option)
{
case 0:
{
// accept
LLAvatarTracker::formFriendship(payload["from_id"]);
fid = gInventory.findCategoryUUIDForType(LLAssetType::AT_CALLINGCARD);
const LLUUID fid = gInventory.findCategoryUUIDForType(LLFolderType::FT_CALLINGCARD);
// This will also trigger an onlinenotification if the user is online
msg->newMessageFast(_PREHASH_AcceptFriendship);
@ -235,7 +235,9 @@ bool friendship_offer_callback(const LLSD& notification, const LLSD& response)
msg->addUUIDFast(_PREHASH_FolderID, fid);
msg->sendReliable(LLHost(payload["sender"].asString()));
break;
}
case 1:
{
// decline
// We no longer notify other viewers, but we DO still send
// the rejection to the simulator to delete the pending userop.
@ -247,6 +249,7 @@ bool friendship_offer_callback(const LLSD& notification, const LLSD& response)
msg->addUUIDFast(_PREHASH_TransactionID, payload["session_id"]);
msg->sendReliable(LLHost(payload["sender"].asString()));
break;
}
default:
// close button probably, possibly timed out
break;
@ -767,8 +770,7 @@ public:
virtual void done()
{
LL_DEBUGS("Messaging") << "LLDiscardAgentOffer::done()" << LL_ENDL;
LLUUID trash_id;
trash_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_TRASH);
const LLUUID trash_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_TRASH);
bool notify = false;
if(trash_id.notNull() && mObjectID.notNull())
{
@ -875,7 +877,7 @@ void open_offer(const std::vector<LLUUID>& items, const std::string& from_name)
{
std::vector<LLUUID>::const_iterator it = items.begin();
std::vector<LLUUID>::const_iterator end = items.end();
LLUUID trash_id(gInventory.findCategoryUUIDForType(LLAssetType::AT_TRASH));
const LLUUID trash_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_TRASH);
LLInventoryItem* item;
for(; it != end; ++it)
{
@ -946,13 +948,12 @@ void open_offer(const std::vector<LLUUID>& items, const std::string& from_name)
}
//Trash Check
LLUUID trash_id;
trash_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_TRASH);
const LLUUID trash_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_TRASH);
if(gInventory.isObjectDescendentOf(item->getUUID(), trash_id))
{
return;
}
LLUUID lost_and_found_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_LOST_AND_FOUND);
const LLUUID lost_and_found_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_LOST_AND_FOUND);
//BOOL inventory_has_focus = gFocusMgr.childHasKeyboardFocus(view);
BOOL user_is_away = gAwayTimer.getStarted();
@ -1716,7 +1717,7 @@ void process_improved_im(LLMessageSystem *msg, void **user_data)
info->mFromGroup = from_group;
info->mTransactionID = session_id;
info->mType = (LLAssetType::EType) asset_type;
info->mFolderID = gInventory.findCategoryUUIDForType(info->mType);
info->mFolderID = gInventory.findCategoryUUIDForType(LLFolderType::assetTypeToFolderType(info->mType));
std::string from_name;
from_name += "A group member named ";
@ -1850,7 +1851,7 @@ void process_improved_im(LLMessageSystem *msg, void **user_data)
info->mFromID = from_id;
info->mFromGroup = from_group;
info->mTransactionID = session_id;
info->mFolderID = gInventory.findCategoryUUIDForType(info->mType);
info->mFolderID = gInventory.findCategoryUUIDForType(LLFolderType::assetTypeToFolderType(info->mType));
if (dialog == IM_TASK_INVENTORY_OFFERED)
{
@ -2144,7 +2145,7 @@ bool callingcard_offer_callback(const LLSD& notification, const LLSD& response)
msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
msg->nextBlockFast(_PREHASH_TransactionBlock);
msg->addUUIDFast(_PREHASH_TransactionID, notification["payload"]["transaction_id"].asUUID());
fid = gInventory.findCategoryUUIDForType(LLAssetType::AT_CALLINGCARD);
fid = gInventory.findCategoryUUIDForType(LLFolderType::FT_CALLINGCARD);
msg->nextBlockFast(_PREHASH_FolderData);
msg->addUUIDFast(_PREHASH_FolderID, fid);
msg->sendReliable(LLHost(notification["payload"]["sender"].asString()));
@ -2597,11 +2598,10 @@ BOOL LLPostTeleportNotifiers::tick()
{
// get callingcards and landmarks available to the user arriving.
LLInventoryFetchDescendentsObserver::folder_ref_t folders;
LLUUID folder_id;
folder_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_CALLINGCARD);
if(folder_id.notNull())
folders.push_back(folder_id);
folder_id = gInventory.findCategoryUUIDForType(LLAssetType::AT_LANDMARK);
const LLUUID callingcard_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_CALLINGCARD);
if(callingcard_id.notNull())
folders.push_back(callingcard_id);
const LLUUID folder_id = gInventory.findCategoryUUIDForType(LLFolderType::FT_LANDMARK);
if(folder_id.notNull())
folders.push_back(folder_id);
if(!folders.empty())
@ -4819,7 +4819,7 @@ void container_inventory_arrived(LLViewerObject* object,
// create a new inventory category to put this in
LLUUID cat_id;
cat_id = gInventory.createNewCategory(gInventory.getRootFolderID(),
LLAssetType::AT_NONE,
LLFolderType::FT_NONE,
LLTrans::getString("AcquiredItems"));
InventoryObjectList::const_iterator it = inventory->begin();
@ -4869,7 +4869,7 @@ void container_inventory_arrived(LLViewerObject* object,
}
LLInventoryItem* item = (LLInventoryItem*)((LLInventoryObject*)(*it));
LLUUID category = gInventory.findCategoryUUIDForType(item->getType());
const LLUUID category = gInventory.findCategoryUUIDForType(LLFolderType::assetTypeToFolderType(item->getType()));
LLUUID item_id;
item_id.generate();
@ -5549,7 +5549,7 @@ void process_covenant_reply(LLMessageSystem* msg, void**)
LLPanelLandCovenant::updateEstateOwnerName(owner_name);
LLFloaterBuyLand::updateEstateOwnerName(owner_name);
LLPanelPlaceInfo* panel = LLSideTray::getInstance()->findChild<LLPanelPlaceInfo>("panel_place_info");
LLPanelPlaceProfile* panel = LLSideTray::getInstance()->findChild<LLPanelPlaceProfile>("panel_place_profile");
if (panel)
{
panel->updateEstateName(estate_name);
@ -5683,7 +5683,7 @@ void onCovenantLoadComplete(LLVFS *vfs,
LLPanelLandCovenant::updateCovenantText(covenant_text);
LLFloaterBuyLand::updateCovenantText(covenant_text, asset_uuid);
LLPanelPlaceInfo* panel = LLSideTray::getInstance()->findChild<LLPanelPlaceInfo>("panel_place_info");
LLPanelPlaceProfile* panel = LLSideTray::getInstance()->findChild<LLPanelPlaceProfile>("panel_place_profile");
if (panel)
{
panel->updateCovenantText(covenant_text);

20
indra/newview/llviewertexteditor.cpp
View File

@ -62,6 +62,7 @@
#include "lltooltip.h"
#include "lltrans.h"
#include "lluictrlfactory.h"
#include "llviewerassettype.h"
#include "llviewercontrol.h"
#include "llviewerinventory.h"
#include "llviewertexturelist.h"
@ -505,19 +506,17 @@ LLUIImagePtr LLEmbeddedItems::getItemImage(llwchar ext_char) const
}
break;
case LLAssetType::AT_SOUND: img_name = "Inv_Sound"; break;
case LLAssetType::AT_SOUND: img_name = "Inv_Sound"; break;
case LLAssetType::AT_CLOTHING: img_name = "Inv_Clothing"; break;
case LLAssetType::AT_OBJECT: img_name = "Inv_Object"; break;
case LLAssetType::AT_OBJECT: img_name = "Inv_Object"; break;
case LLAssetType::AT_CALLINGCARD: img_name = "Inv_CallingCard"; break;
case LLAssetType::AT_LANDMARK: img_name = "Inv_Landmark"; break;
case LLAssetType::AT_LANDMARK: img_name = "Inv_Landmark"; break;
case LLAssetType::AT_NOTECARD: img_name = "Inv_Notecard"; break;
case LLAssetType::AT_LSL_TEXT: img_name = "Inv_Script"; break;
case LLAssetType::AT_BODYPART: img_name = "Inv_Skin"; break;
case LLAssetType::AT_ANIMATION: img_name = "Inv_Animation";break;
case LLAssetType::AT_GESTURE: img_name = "Inv_Gesture"; break;
//TODO need img_name
case LLAssetType::AT_FAVORITE: img_name = "Inv_Landmark"; break;
default: llassert(0);
case LLAssetType::AT_BODYPART: img_name = "Inv_Skin"; break;
case LLAssetType::AT_ANIMATION: img_name = "Inv_Animation"; break;
case LLAssetType::AT_GESTURE: img_name = "Inv_Gesture"; break;
default: llassert(0);
}
return LLUI::getUIImage(img_name);
@ -732,11 +731,10 @@ BOOL LLViewerTextEditor::handleHover(S32 x, S32 y, MASK mask)
if( LLToolDragAndDrop::getInstance()->isOverThreshold( screen_x, screen_y ) )
{
LLToolDragAndDrop::getInstance()->beginDrag(
LLAssetType::lookupDragAndDropType( mDragItem->getType() ),
LLViewerAssetType::lookupDragAndDropType( mDragItem->getType() ),
mDragItem->getUUID(),
LLToolDragAndDrop::SOURCE_NOTECARD,
mPreviewID, mObjectID);
return LLToolDragAndDrop::getInstance()->handleHover( x, y, mask );
}
getWindow()->setCursor(UI_CURSOR_HAND);

Some files were not shown because too many files have changed in this diff Show More