Singularity-Viewer/SingularityViewer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Clean up and updates

Browse Source 
Cleaned up header bloatyness in linden_common
Moved around things to be in line with Linden Lab
Updated llinitparam and imported its new dependencies
Removed dohexeditor and related files
Removed unused legacy files

             /\_..._/\
             |/ \_/ \|
             | o.-.o |
             \ ( O ) /
             /'--U--'\
             |  .:.  | /\
             | /:;:\ |` /
   Drake     | |:;:| |-'
  Arconis   /  |'-'|  \
            `""`   `""`
This commit is contained in:
Drake Arconis
2012-07-20 08:13:07 -04:00
parent 7843f51110
commit 1e81966b89
29 changed files with 304 additions and 2269 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
indra/newview/CMakeLists.txt
View File

@@ -37,7 +37,6 @@ include(LLUI)
include(LLVFS)
include(LLWindow)
include(LLXML)
include(LLXUIXML)
include(LScript)
include(Linking)
include(NDOF)
@@ -72,7 +71,6 @@ include_directories(
${LLVFS_INCLUDE_DIRS}
${LLWINDOW_INCLUDE_DIRS}
${LLXML_INCLUDE_DIRS}
${LLXUIXML_INCLUDE_DIRS}
${LSCRIPT_INCLUDE_DIRS}
${LSCRIPT_INCLUDE_DIRS}/lscript_compile
)
@@ -98,11 +96,7 @@ set(viewer_SOURCE_FILES
ascentprefschat.cpp
ascentprefssys.cpp
ascentprefsvan.cpp
#dhparam.cpp
#dsaparam.cpp
emeraldboobutils.cpp
dofloaterhex.cpp
dohexeditor.cpp
floatersculptpreview.cpp
hbfloatergrouptitles.cpp
hgfloatertexteditor.cpp
@@ -593,8 +587,6 @@ set(viewer_HEADER_FILES
ascentprefssys.h
ascentprefsvan.h
emeraldboobutils.h
dofloaterhex.h
dohexeditor.h
floatersculptpreview.h
hbfloatergrouptitles.h
hgfloatertexteditor.h
@@ -1548,7 +1540,6 @@ target_link_libraries(${VIEWER_BINARY_NAME}
${LLVFS_LIBRARIES}
${LLWINDOW_LIBRARIES}
${LLXML_LIBRARIES}
${LLXUIXML_LIBRARIES}
${LSCRIPT_LIBRARIES}
${LLMATH_LIBRARIES}
${LLCOMMON_LIBRARIES}

42
indra/newview/dhparam.cpp
View File

@@ -1,42 +0,0 @@
/* Generated using openssl */
#include "llviewerprecompiledheaders.h"
#include <openssl/dh.h>
DH *get_dh2048()
{
static unsigned char dh2048_p[]={
0xAC,0x31,0xAA,0xFD,0x76,0x1B,0x47,0x24,0x99,0x6D,0xF8,0xD5,
0x5B,0x4B,0xD1,0x7E,0xF9,0x1A,0x41,0xF6,0x29,0xCC,0xA9,0x02,
0x6B,0xED,0xFD,0xC9,0x37,0xCE,0xF6,0x11,0x78,0x6F,0x37,0x38,
0x7D,0x49,0x3F,0x78,0x36,0x83,0x0A,0x6F,0xBA,0x6F,0x74,0xD9,
0xB1,0xC1,0xC4,0x5A,0x7D,0x84,0x26,0x56,0x8B,0x53,0xF4,0xFE,
0xD1,0x34,0xF1,0xE0,0x08,0x65,0xA6,0xFD,0xDB,0x5D,0xAC,0x14,
0xCD,0xC9,0x7E,0x79,0xE9,0x3B,0xAF,0x92,0xC7,0x4D,0x91,0x15,
0x0B,0x1E,0x2F,0x0A,0x56,0x4E,0x0D,0x3A,0x4D,0x9E,0xB0,0xB5,
0xFC,0x0D,0xB1,0x55,0x40,0xC6,0x30,0x99,0xCD,0xE8,0x7E,0x72,
0x08,0x93,0x9C,0x7F,0x55,0x23,0x27,0x09,0xF4,0x50,0xF2,0x96,
0xB5,0x30,0x35,0x6A,0x99,0x4C,0xD6,0x85,0x72,0x8D,0x9C,0x19,
0x70,0x9A,0x77,0x52,0xE8,0x33,0x03,0x7A,0x00,0xDA,0xFE,0xD7,
0x98,0xD0,0x7B,0x26,0xBA,0xD7,0xFF,0xD1,0x49,0x61,0x27,0x3E,
0xFC,0x12,0x81,0xC9,0xB0,0xAF,0x34,0x14,0x97,0x66,0xFB,0xEF,
0xD3,0xFE,0xC9,0x01,0x25,0xEC,0xF4,0xE8,0xA8,0xD8,0x21,0x45,
0x20,0x6F,0xFC,0xA8,0xB3,0xCE,0xCF,0x0D,0xA1,0x14,0xCC,0x38,
0x81,0x74,0x6A,0x5E,0x36,0x09,0x1D,0xBE,0x4C,0x08,0x52,0x5E,
0xC2,0x5F,0xA4,0x48,0x3A,0x71,0x85,0xF2,0x97,0x32,0xEC,0x3B,
0xFB,0x1B,0x9A,0x8A,0x4B,0x20,0x32,0xFE,0x6A,0x94,0x4C,0x02,
0xB2,0xD7,0xC3,0x1B,0xF8,0x90,0x54,0x76,0x70,0x49,0x81,0x86,
0x30,0x12,0xD2,0x91,0xF0,0xFD,0x1B,0x53,0x2E,0x60,0x13,0x78,
0x8B,0x3F,0x1B,0x13,
};
static unsigned char dh2048_g[]={
0x05,
};
DH *dh;
if ((dh=DH_new()) == NULL) return(NULL);
dh->p=BN_bin2bn(dh2048_p,sizeof(dh2048_p),NULL);
dh->g=BN_bin2bn(dh2048_g,sizeof(dh2048_g),NULL);
if ((dh->p == NULL) || (dh->g == NULL))
{ DH_free(dh); return(NULL); }
return(dh);
}

503
indra/newview/dofloaterhex.cpp
View File

@@ -1,503 +0,0 @@
/**
* @file dofloaterhex.h
* @brief Hex Editor Floater made by Day
* @author Day Oh
*
* $LicenseInfo:firstyear=2009&license=WTFPLV2$
*
*/
// <edit>
#include "llviewerprecompiledheaders.h"
#include "dofloaterhex.h"
#include "lluictrlfactory.h"
#include "llinventorybackup.h" // for downloading
#include "llviewercontrol.h" // gSavedSettings
#include "llviewerwindow.h" // alertXML
#include "llagent.h" // gAgent getID
#include "llviewermenufile.h"
#include "llviewerregion.h" // getCapability
#include "llassetuploadresponders.h" // LLUpdateAgentInventoryResponder
#include "llinventorymodel.h" // gInventory.updateItem
#include "llappviewer.h" // System Folders
#include "llfloaterperms.h" //get default perms
#include "llnotificationsutil.h"
std::list<DOFloaterHex*> DOFloaterHex::sInstances;
S32 DOFloaterHex::sUploadAmount = 10;
DOFloaterHex::DOFloaterHex(LLUUID item_id, BOOL vfs, LLAssetType::EType asset_type)
: LLFloater()
{
sInstances.push_back(this);
mVFS = vfs;
//we are editing an asset directly from the VFS
if(vfs)
{
mAssetId = item_id;
mAssetType = asset_type;
//we are editing an inventory item
} else {
mItem = (LLInventoryItem*)gInventory.getItem(item_id);
mAssetId = mItem->getAssetUUID();
mAssetType = mItem->getType();
}
LLUICtrlFactory::getInstance()->buildFloater(this, "floater_hex.xml");
}
//this bit should be rewritten entirely
void DOFloaterHex::show(LLUUID item_id, BOOL vfs, LLAssetType::EType asset_type)
{
if(!vfs)
{
LLInventoryItem* item = (LLInventoryItem*)gInventory.getItem(item_id);
if(item)
{
S32 left, top;
gFloaterView->getNewFloaterPosition(&left, &top);
LLRect rect = gSavedSettings.getRect("FloaterHexRect");
rect.translate(left - rect.mLeft, top - rect.mTop);
DOFloaterHex* floaterp = new DOFloaterHex(item_id);
floaterp->setRect(rect);
gFloaterView->adjustToFitScreen(floaterp, FALSE);
}
} else if (item_id.notNull() && asset_type != LLAssetType::AT_NONE) {
S32 left, top;
gFloaterView->getNewFloaterPosition(&left, &top);
LLRect rect = gSavedSettings.getRect("FloaterHexRect");
rect.translate(left - rect.mLeft, top - rect.mTop);
DOFloaterHex* floaterp = new DOFloaterHex(item_id, true, asset_type);
floaterp->setRect(rect);
llinfos << "Asset ID: " << item_id.asString() << llendl;
gFloaterView->adjustToFitScreen(floaterp, FALSE);
}
}
DOFloaterHex::~DOFloaterHex()
{
sInstances.remove(this);
}
void DOFloaterHex::close(bool app_quitting)
{
LLFloater::close(app_quitting);
}
BOOL DOFloaterHex::postBuild(void)
{
DOHexEditor* editor = getChild<DOHexEditor>("hex");
mEditor = editor;
#ifndef COLUMN_SPAN
// Set number of columns
U8 columns = U8(gSavedSettings.getU32("HexEditorColumns"));
editor->setColumns(columns);
// Reflect clamped U8ness in settings
gSavedSettings.setU32("HexEditorColumns", U32(columns));
#endif
handleSizing();
childSetEnabled("upload_btn", false);
childSetLabelArg("upload_btn", "[UPLOAD]", std::string("Upload"));
childSetAction("upload_btn", onClickUpload, this);
childSetEnabled("save_btn", false);
childSetAction("save_btn", onClickSave, this);
if(!mVFS && mItem)
{
std::string title = "Hex editor: " + mItem->getName();
const char* asset_type_name = LLAssetType::lookup(mItem->getType());
if(asset_type_name)
{
title.append(" (" + std::string(asset_type_name) + ")");
}
setTitle(title);
}
if(!mVFS)
{
// Load the asset
editor->setVisible(FALSE);
childSetText("status_text", std::string("Loading..."));
LLInventoryBackup::download(mItem, this, imageCallback, assetCallback);
}
else if (mVFS) //the asset already exists in the VFS, we don't need to fetch it
//and we don't want to associate it with an item
{
setTitle(mAssetId.asString());
readVFile();
} else {
this->close(false);
}
return TRUE;
}
// static
void DOFloaterHex::imageCallback(BOOL success,
LLViewerFetchedTexture *src_vi,
LLImageRaw* src,
LLImageRaw* aux_src,
S32 discard_level,
BOOL final,
void* userdata)
{
if(final)
{
LLInventoryBackup::callbackdata* data = static_cast<LLInventoryBackup::callbackdata*>(userdata);
DOFloaterHex* floater = (DOFloaterHex*)(data->floater);
if(!floater) return;
if(std::find(sInstances.begin(), sInstances.end(), floater) == sInstances.end()) return; // no more crash
//LLInventoryItem* item = data->item;
if(!success)
{
floater->childSetText("status_text", std::string("Unable to download asset."));
return;
}
U8* src_data = src->getData();
S32 size = src->getDataSize();
std::vector<U8> new_data;
for(S32 i = 0; i < size; i++)
new_data.push_back(src_data[i]);
floater->mEditor->setValue(new_data);
floater->mEditor->setVisible(TRUE);
floater->childSetText("status_text", std::string("Note: Image data shown isn't the actual asset data, yet"));
floater->childSetEnabled("save_btn", false);
floater->childSetEnabled("upload_btn", true);
floater->childSetLabelArg("upload_btn", "[UPLOAD]", std::string("Upload (L$10)"));
}
else
{
src_vi->setBoostLevel(LLViewerTexture::BOOST_UI);
}
}
// static
void DOFloaterHex::assetCallback(LLVFS *vfs,
const LLUUID& asset_uuid,
LLAssetType::EType type,
void* user_data, S32 status, LLExtStat ext_status)
{
LLInventoryBackup::callbackdata* data = static_cast<LLInventoryBackup::callbackdata*>(user_data);
DOFloaterHex* floater = (DOFloaterHex*)(data->floater);
if(!floater) return;
if(std::find(sInstances.begin(), sInstances.end(), floater) == sInstances.end()) return; // no more crash
LLInventoryItem* item = data->item;
if(status != 0 && item->getType() != LLAssetType::AT_NOTECARD)
{
floater->childSetText("status_text", std::string("Unable to download asset."));
return;
}
// Todo: this doesn't work for static vfs shit
LLVFile file(vfs, asset_uuid, type, LLVFile::READ);
S32 size = file.getSize();
char* buffer = new char[size];
if (buffer == NULL)
{
llerrs << "Memory Allocation Failed" << llendl;
return;
}
file.read((U8*)buffer, size);
std::vector<U8> new_data;
for(S32 i = 0; i < size; i++)
new_data.push_back(buffer[i]);
delete[] buffer;
floater->mEditor->setValue(new_data);
floater->mEditor->setVisible(TRUE);
floater->childSetText("status_text", std::string(""));
floater->childSetEnabled("upload_btn", true);
floater->childSetEnabled("save_btn", false);
if(item->getPermissions().allowModifyBy(gAgent.getID()))
{
switch(item->getType())
{
case LLAssetType::AT_TEXTURE:
case LLAssetType::AT_ANIMATION:
case LLAssetType::AT_SOUND:
floater->childSetLabelArg("upload_btn", "[UPLOAD]", std::string("Upload (L$10)"));
break;
case LLAssetType::AT_LANDMARK:
case LLAssetType::AT_CALLINGCARD:
floater->childSetEnabled("upload_btn", false);
floater->childSetEnabled("save_btn", false);
break;
default:
floater->childSetEnabled("save_btn", true);
break;
}
}
else
{
switch(item->getType())
{
case LLAssetType::AT_TEXTURE:
case LLAssetType::AT_ANIMATION:
case LLAssetType::AT_SOUND:
floater->childSetLabelArg("upload_btn", "[UPLOAD]", std::string("Upload (L$10)"));
break;
default:
break;
}
}
// Never enable save if it's a pretend item
if(gInventory.isObjectDescendentOf(item->getUUID(), gSystemFolderRoot))
{
floater->childSetEnabled("save_btn", false);
}
}
// static
void DOFloaterHex::onClickUpload(void* user_data)
{
DOFloaterHex* floater = (DOFloaterHex*)user_data;
LLInventoryItem* item = floater->mItem;
LLTransactionID transaction_id;
transaction_id.generate();
LLUUID fake_asset_id = transaction_id.makeAssetID(gAgent.getSecureSessionID());
std::vector<U8> value = floater->mEditor->getValue();
int size = value.size();
U8* buffer = new U8[size];
for(int i = 0; i < size; i++)
buffer[i] = value[i];
value.clear();
LLVFile file(gVFS, fake_asset_id, item->getType(), LLVFile::APPEND);
file.setMaxSize(size);
if (!file.write(buffer, size))
{
LLSD args;
args["ERROR_MESSAGE"] = "Couldn't write data to file";
LLNotificationsUtil::add("ErrorMessage", args);
return;
}
delete[] buffer;
LLAssetStorage::LLStoreAssetCallback callback = NULL;
void *fake_user_data = NULL;
if(item->getType() != LLAssetType::AT_GESTURE && item->getType() != LLAssetType::AT_LSL_TEXT
&& item->getType() != LLAssetType::AT_NOTECARD)
{
upload_new_resource(transaction_id,
item->getType(),
item->getName(),
item->getDescription(),
0,
LLFolderType::assetTypeToFolderType(item->getType()),
item->getInventoryType(),
LLFloaterPerms::getNextOwnerPerms(), LLFloaterPerms::getGroupPerms(), LLFloaterPerms::getEveryonePerms(),
item->getName(),
callback,
sUploadAmount,
fake_user_data);
}
else // gestures and scripts, create an item first
{ // AND notecards
//if(item->getType() == LLAssetType::AT_NOTECARD) gDontOpenNextNotecard = true;
create_inventory_item( gAgent.getID(),
gAgent.getSessionID(),
item->getParentUUID(), //gInventory.findCategoryUUIDForType(item->getType()),
LLTransactionID::tnull,
item->getName(),
fake_asset_id.asString(),
item->getType(),
item->getInventoryType(),
(LLWearableType::EType)item->getFlags(),
PERM_ITEM_UNRESTRICTED,
new NewResourceItemCallback);
}
}
struct LLSaveInfo
{
LLSaveInfo(DOFloaterHex* floater, LLTransactionID transaction_id)
: mFloater(floater), mTransactionID(transaction_id)
{
}
DOFloaterHex* mFloater;
LLTransactionID mTransactionID;
};
// static
void DOFloaterHex::onClickSave(void* user_data)
{
DOFloaterHex* floater = (DOFloaterHex*)user_data;
LLInventoryItem* item = floater->mItem;
LLTransactionID transaction_id;
transaction_id.generate();
LLUUID fake_asset_id = transaction_id.makeAssetID(gAgent.getSecureSessionID());
std::vector<U8> value = floater->mEditor->getValue();
int size = value.size();
U8* buffer = new U8[size];
for(int i = 0; i < size; i++)
buffer[i] = value[i];
value.clear();
LLVFile file(gVFS, fake_asset_id, item->getType(), LLVFile::APPEND);
file.setMaxSize(size);
if (!file.write(buffer, size))
{
LLSD args;
args["ERROR_MESSAGE"] = "Couldn't write data to file";
LLNotificationsUtil::add("ErrorMessage", args);
return;
}
delete[] buffer;
bool caps = false;
std::string url;
LLSD body;
body["item_id"] = item->getUUID();
switch(item->getType())
{
case LLAssetType::AT_GESTURE:
url = gAgent.getRegion()->getCapability("UpdateGestureAgentInventory");
caps = true;
break;
case LLAssetType::AT_LSL_TEXT:
url = gAgent.getRegion()->getCapability("UpdateScriptAgent");
body["target"] = "mono";
caps = true;
break;
case LLAssetType::AT_NOTECARD:
url = gAgent.getRegion()->getCapability("UpdateNotecardAgentInventory");
caps = true;
break;
default: // wearables & notecards, Oct 12 2009
// ONLY WEARABLES, Oct 15 2009
floater->childSetText("status_text", std::string("Saving..."));
LLSaveInfo* info = new LLSaveInfo(floater, transaction_id);
gAssetStorage->storeAssetData(transaction_id, item->getType(), onSaveComplete, info);
caps = false;
break;
}
if(caps)
{
LLHTTPClient::post(url, body,
new LLUpdateAgentInventoryResponder(body, fake_asset_id, item->getType()));
}
}
void DOFloaterHex::onSaveComplete(const LLUUID& asset_uuid, void* user_data, S32 status, LLExtStat ext_status)
{
LLSaveInfo* info = (LLSaveInfo*)user_data;
DOFloaterHex* floater = info->mFloater;
if(std::find(sInstances.begin(), sInstances.end(), floater) == sInstances.end()) return; // no more crash
LLInventoryItem* item = floater->mItem;
floater->childSetText("status_text", std::string(""));
if(item && (status == 0))
{
LLPointer<LLViewerInventoryItem> new_item = new LLViewerInventoryItem(item);
new_item->setDescription(item->getDescription());
new_item->setTransactionID(info->mTransactionID);
new_item->setAssetUUID(asset_uuid);
new_item->updateServer(FALSE);
gInventory.updateItem(new_item);
gInventory.notifyObservers();
}
else
{
LLSD args;
args["ERROR_MESSAGE"] = llformat("Upload failed with status %d, also %d", status, ext_status);
LLNotificationsUtil::add("ErrorMessage", args);
}
}
void DOFloaterHex::onCommitColumnCount(LLUICtrl *control, void *user_data)
{
if(control && user_data)
{
DOFloaterHex *instance = (DOFloaterHex *)user_data;
U8 columns = llclamp<U8>((U8)llfloor(control->getValue().asReal()), 0x00, 0xFF);
instance->mEditor->setColumns(columns);
gSavedSettings.setU32("HexEditorColumns", (U32)instance->mEditor->getColumns());
instance->handleSizing();
}
}
void DOFloaterHex::handleSizing()
{
// Reshape a little based on columns
S32 min_width = S32(mEditor->getSuggestedWidth(MIN_COLS)) + 20;
setResizeLimits(min_width, getMinHeight());
if(getRect().getWidth() < min_width)
{
//LLRect rect = getRect();
//rect.setOriginAndSize(rect.mLeft, rect.mBottom, min_width, rect.getHeight());
//setRect(rect);
reshape(min_width, getRect().getHeight(), FALSE);
mEditor->reshape(mEditor->getRect().getWidth(), mEditor->getRect().getHeight(), TRUE);
}
}
void DOFloaterHex::readVFile()
{
if(!mVFS) return;
// quick cut paste job
// Todo: this doesn't work for static vfs shit
LLVFile file(gVFS, mAssetId, mAssetType, LLVFile::READ);
if(file.getVFSThread())
{
S32 size = file.getSize();
char* buffer = new char[size];
if (buffer == NULL)
{
llerrs << "Memory Allocation Failed" << llendl;
return;
}
file.read((U8*)buffer, size);
std::vector<U8> new_data;
for(S32 i = 0; i < size; i++)
new_data.push_back(buffer[i]);
delete[] buffer;
mEditor->setValue(new_data);
mEditor->setVisible(TRUE);
}
childSetText("status_text", std::string("Editing VFile"));
childSetEnabled("upload_btn", false);
childSetEnabled("save_btn", false);
}
// </edit>

51
indra/newview/dofloaterhex.h
View File

@@ -1,51 +0,0 @@
// <edit>
#ifndef LL_LLFLOATERHEX_H
#define LL_LLFLOATERHEX_H
#include "llfloater.h"
#include "dohexeditor.h"
#include "llinventory.h"
#include "llviewertexture.h"
#include "llassettype.h"
class DOFloaterHex
: public LLFloater
{
public:
DOFloaterHex(LLUUID item_id, BOOL vfs=false, LLAssetType::EType asset_type = LLAssetType::AT_NONE);
static void show(LLUUID item_id, BOOL vfs=false, LLAssetType::EType asset_type = LLAssetType::AT_NONE);
BOOL postBuild(void);
void close(bool app_quitting);
static void imageCallback(BOOL success,
LLViewerFetchedTexture *src_vi,
LLImageRaw* src,
LLImageRaw* aux_src,
S32 discard_level,
BOOL final,
void* userdata);
static void assetCallback(LLVFS *vfs,
const LLUUID& asset_uuid,
LLAssetType::EType type,
void* user_data, S32 status, LLExtStat ext_status);
static void onClickSave(void* user_data);
static void onClickUpload(void* user_data);
static void onSaveComplete(const LLUUID& asset_uuid, void* user_data, S32 status, LLExtStat ext_status);
static void onCommitColumnCount(LLUICtrl *control, void *user_data);
void handleSizing();
void readVFile();
LLInventoryItem* mItem;
LLUUID mAssetId;
LLAssetType::EType mAssetType;
BOOL mVFS;
DOHexEditor* mEditor;
static std::list<DOFloaterHex*> sInstances;
private:
virtual ~DOFloaterHex();
protected:
static S32 sUploadAmount;
};
#endif
// </edit>

1243
indra/newview/dohexeditor.cpp
View File

File diff suppressed because it is too large Load Diff

159
indra/newview/dohexeditor.h
View File

@@ -1,159 +0,0 @@
/**
* @file dohexeditor.h
* @brief DOHexEditor Widget
* @author Day Oh
*
* $LicenseInfo:firstyear=2009&license=WTFPLV2$
*
*/
// <edit>
#ifndef DO_DOHEXEDITOR_H
#define DO_DOHEXEDITOR_H
#define MIN_COLS 8
#define MAX_COLS 48
#ifndef COLUMN_SPAN
#define COLUMN_SPAN
#endif
#include "lluictrl.h"
#include "llscrollbar.h"
#include "llviewborder.h"
#include "llundo.h"
#include "lleditmenuhandler.h"
class DOHexEditor : public LLUICtrl, public LLEditMenuHandler
{
public:
DOHexEditor(const std::string& name, const LLRect& rect);
~DOHexEditor();
static LLView* fromXML(LLXMLNodePtr node, LLView *parent, class LLUICtrlFactory *factory);
void setValue(const LLSD& value);
LLSD getValue() const;
void setColumns(U8 columns);
U8 getColumns() { return mColumns; };
U32 getLineCount();
F32 getSuggestedWidth(U8 cols = -1);
U32 getProperSelectionStart();
U32 getProperSelectionEnd();
void reshape(S32 width, S32 height, BOOL called_from_parent);
void setFocus(BOOL b);
BOOL handleScrollWheel(S32 x, S32 y, S32 clicks);
BOOL handleMouseDown(S32 x, S32 y, MASK mask);
BOOL handleHover(S32 x, S32 y, MASK mask);
BOOL handleMouseUp(S32 x, S32 y, MASK mask);
BOOL handleKeyHere(KEY key, MASK mask);
BOOL handleKey(KEY key, MASK mask, BOOL called_from_parent);
BOOL handleUnicodeChar(llwchar uni_char, BOOL called_from_parent);
BOOL handleUnicodeCharHere(llwchar uni_char);
void draw();
void moveCursor(U32 pos, BOOL second_nibble);
void insert(U32 pos, std::vector<U8> new_data, BOOL undoable);
void overwrite(U32 first_pos, U32 last_pos, std::vector<U8> new_data, BOOL undoable);
void del(U32 first_pos, U32 last_pos, BOOL undoable);
virtual void cut();
virtual BOOL canCut() const;
virtual void copy();
virtual BOOL canCopy() const;
virtual void paste();
virtual BOOL canPaste() const;
virtual void doDelete();
virtual BOOL canDoDelete() const;
virtual void selectAll();
virtual BOOL canSelectAll() const;
virtual void deselect();
virtual BOOL canDeselect() const;
virtual void undo();
virtual BOOL canUndo() const;
virtual void redo();
virtual BOOL canRedo() const;
private:
std::vector<U8> mValue;
U8 mColumns;
U32 mCursorPos;
BOOL mSecondNibble;
BOOL mInData;
BOOL mSelecting;
BOOL mHasSelection;
U32 mSelectionStart;
U32 mSelectionEnd;
LLFontGL* mGLFont;
LLRect mTextRect;
LLScrollbar* mScrollbar;
LLViewBorder* mBorder;
LLUndoBuffer* mUndoBuffer;
void changedLength();
void getPosAndContext(S32 x, S32 y, BOOL force_context, U32& pos, BOOL& in_data, BOOL& second_nibble);
};
class DOUndoHex : public LLUndoBuffer::LLUndoAction
{
protected:
DOUndoHex() { }
DOHexEditor* mHexEditor;
U32 mFirstPos;
U32 mLastPos;
std::vector<U8> mOldData;
std::vector<U8> mNewData;
public:
static LLUndoAction* create() { return new DOUndoHex(); }
virtual void set(DOHexEditor* hex_editor,
void (*undo_action)(DOUndoHex*),
void (*redo_action)(DOUndoHex*),
U32 first_pos,
U32 last_pos,
std::vector<U8> old_data,
std::vector<U8> new_data);
void (*mUndoAction)(DOUndoHex*);
void (*mRedoAction)(DOUndoHex*);
virtual void undo();
virtual void redo();
static void undoInsert(DOUndoHex* action);
static void redoInsert(DOUndoHex* action);
static void undoOverwrite(DOUndoHex* action);
static void redoOverwrite(DOUndoHex* action);
static void undoDel(DOUndoHex* action);
static void redoDel(DOUndoHex* action);
};
class DOHexInsert : public DOUndoHex
{
virtual void undo();
virtual void redo();
};
class DOHexOverwrite : public DOUndoHex
{
virtual void undo();
virtual void redo();
};
class DOHexDel : public DOUndoHex
{
virtual void undo();
virtual void redo();
};
#endif
// </edit>

69
indra/newview/dsaparam.cpp
View File

@@ -1,69 +0,0 @@
/* Generated using openssl */
#include "llviewerprecompiledheaders.h"
#include <openssl/dsa.h>
static unsigned char dsa2048_p[]={
0xD4,0x63,0x93,0xFA,0x69,0x87,0xDB,0x60,0x68,0xFB,0xCC,0x8F,
0x55,0x85,0x7A,0xAC,0xAD,0x1F,0x8E,0xF0,0x2C,0x62,0x2F,0xE6,
0xA6,0xA4,0xF3,0x57,0x42,0xDC,0xF0,0xE0,0x0E,0xC6,0x67,0x01,
0x95,0x22,0x6F,0x03,0x00,0x2A,0xB4,0xBF,0x62,0x6D,0xA1,0xBD,
0xB7,0x10,0x81,0xB4,0x20,0x1C,0x7D,0x41,0x75,0xCE,0x0F,0xCF,
0x9D,0x03,0xEC,0xE6,0x7E,0xBC,0x76,0x97,0xBC,0x5C,0x70,0xFE,
0xD5,0x64,0x15,0x20,0xD8,0xA8,0x25,0x73,0xD4,0xA2,0x77,0x99,
0xC7,0x3B,0xF7,0x4E,0x20,0x40,0x43,0xD7,0x7C,0xFD,0xBC,0x2F,
0x75,0xB5,0x18,0xA3,0x8C,0x85,0x79,0x86,0x53,0x62,0x73,0xBA,
0x66,0x73,0xE2,0x48,0x15,0xAF,0x04,0x65,0xE2,0x4D,0x15,0x47,
0x74,0x33,0x79,0xAE,0xBF,0x90,0xC0,0xF7,0x2F,0x04,0xFB,0xEE,
0x29,0xEC,0x42,0xC7,0x36,0x14,0xAC,0xB2,0xBC,0xE1,0x71,0x13,
0x65,0xBA,0x0D,0x61,0x11,0x89,0x49,0x41,0x5D,0xCC,0xE2,0x72,
0x7B,0x93,0xF2,0x2E,0xD1,0x23,0x37,0xF9,0xFF,0x55,0x59,0xF6,
0x41,0x78,0x87,0xC9,0xCD,0x95,0xD2,0xE5,0x1B,0x3A,0x25,0x7A,
0xD8,0x16,0x2F,0x58,0xFE,0x3B,0xD5,0xB1,0x59,0x63,0x3C,0x90,
0xA0,0xBF,0xA0,0x21,0x54,0xB0,0xB0,0x3F,0x9D,0xC6,0xB5,0x31,
0xBA,0x86,0xDC,0x86,0x41,0xB7,0xBA,0xCE,0x58,0x09,0x8B,0xD9,
0xD4,0xF1,0xD2,0x3B,0x5F,0x87,0xEE,0x66,0xFD,0x77,0x8C,0x2C,
0x66,0x3E,0xC9,0xDA,0x3E,0x2A,0x38,0x03,0x23,0x71,0xC9,0x04,
0x3E,0x9D,0x18,0x7F,0xBB,0x82,0x21,0x8E,0x5F,0xF0,0xAF,0xC8,
0x08,0x2D,0xA6,0x3F,
};
static unsigned char dsa2048_q[]={
0xAE,0xCA,0x67,0x69,0x21,0x7A,0xE1,0x9B,0x64,0x74,0xED,0x58,
0xF0,0x28,0xE0,0x45,0x2B,0x39,0xBC,0x79,
};
static unsigned char dsa2048_g[]={
0x51,0x1D,0xB0,0xF6,0x4E,0x8B,0xAF,0x1C,0x59,0x71,0x62,0x3C,
0xC3,0xE2,0x44,0x35,0xCE,0x11,0xB4,0x49,0x04,0x41,0xA1,0x1C,
0x22,0x59,0x47,0x8C,0x70,0x1D,0xA1,0x0C,0x51,0xFE,0x86,0x43,
0x7B,0x75,0x5C,0xB7,0x68,0xA5,0xBE,0x81,0x9C,0x6F,0x6D,0x32,
0x03,0xB0,0x28,0xA4,0x6B,0x5B,0x37,0xC3,0x35,0xCF,0xBD,0x92,
0xC3,0x66,0x2E,0xAB,0xB4,0x13,0xEC,0x23,0xA3,0xE3,0x09,0x4E,
0x47,0x7D,0xA5,0x90,0x33,0x80,0x5D,0x68,0xD6,0x39,0x54,0xBE,
0x35,0xB0,0x61,0x5B,0x96,0x63,0x05,0x67,0xB7,0x3C,0x21,0x17,
0x37,0x50,0x17,0x78,0xEA,0xC0,0x10,0x73,0xDF,0xE2,0x70,0x19,
0x17,0xF7,0x11,0x82,0x73,0xDB,0xFF,0x3E,0x8D,0x98,0x2F,0x2F,
0xA2,0x12,0xC3,0xB4,0x08,0xB2,0x2C,0x5B,0xA3,0x51,0xAA,0x7F,
0x3D,0xE0,0x74,0x39,0xE5,0xAF,0x81,0x32,0xF8,0x45,0x75,0x11,
0x35,0xD9,0x90,0xA1,0xA3,0x91,0x1A,0xEE,0xE9,0xAC,0x97,0x30,
0x4C,0xD5,0x5B,0x38,0x49,0x12,0x3B,0xCC,0x0C,0x84,0xA2,0x59,
0x78,0xB4,0xFD,0x46,0xAC,0x49,0x43,0x08,0xDB,0xF4,0x23,0xFF,
0x23,0xF8,0x9A,0xFD,0x15,0xAF,0x6B,0x81,0xCE,0x15,0x22,0xEF,
0x09,0x64,0x0A,0x1F,0x4D,0x6B,0xF1,0x9F,0x16,0x00,0x3E,0xE8,
0xFC,0x9A,0x24,0x58,0x1C,0xB4,0x5F,0x56,0x3E,0x83,0x8C,0x0C,
0x51,0x43,0x72,0x25,0xA8,0x1D,0x08,0x30,0x7E,0x17,0xC8,0xD6,
0x66,0x57,0x0C,0x59,0x76,0xE4,0xA6,0x0C,0x05,0xA8,0x60,0x1D,
0xA4,0x8F,0xBC,0xC4,0x67,0x55,0x0E,0x81,0x8F,0x66,0xED,0x1B,
0x84,0xCD,0x02,0x9F,
};
DSA *get_dsa2048()
{
DSA *dsa;
if ((dsa=DSA_new()) == NULL) return(NULL);
dsa->p=BN_bin2bn(dsa2048_p,sizeof(dsa2048_p),NULL);
dsa->q=BN_bin2bn(dsa2048_q,sizeof(dsa2048_q),NULL);
dsa->g=BN_bin2bn(dsa2048_g,sizeof(dsa2048_g),NULL);
if ((dsa->p == NULL) || (dsa->q == NULL) || (dsa->g == NULL))
{ DSA_free(dsa); return(NULL); }
return(dsa);
}

9
indra/newview/llfloatervfsexplorer.cpp
View File

@@ -9,7 +9,6 @@
#include "lllocalinventory.h"
#include "llviewerwindow.h"
#include "llassetconverter.h"
#include "dofloaterhex.h"
LLFloaterVFSExplorer* LLFloaterVFSExplorer::sInstance;
std::map<LLVFSFileSpecifier, LLVFSFileBlock*> LLFloaterVFSExplorer::sVFSFileMap;
@@ -41,7 +40,6 @@ BOOL LLFloaterVFSExplorer::postBuild()
childSetAction("remove_btn", onClickRemove, this);
childSetAction("reload_all_btn", onClickReload, this);
childSetAction("copy_uuid_btn", onClickCopyUUID, this);
childSetAction("edit_data_btn", onClickEditData, this);
childSetAction("item_btn", onClickItem, this);
refresh();
return TRUE;
@@ -175,13 +173,6 @@ void LLFloaterVFSExplorer::onClickReload(void* user_data)
floaterp->reloadAll();
}
// static
void LLFloaterVFSExplorer::onClickEditData(void* user_data)
{
LLFloaterVFSExplorer* floaterp = (LLFloaterVFSExplorer*)user_data;
LLVFSFileSpecifier file = floaterp->getEditEntry();
DOFloaterHex::show(file.mFileID, true, file.mFileType);
}
// static
void LLFloaterVFSExplorer::onClickItem(void* user_data)
{
LLFloaterVFSExplorer* floaterp = (LLFloaterVFSExplorer*)user_data;

1
indra/newview/llinventorybridge.cpp
View File

@@ -113,7 +113,6 @@
#include "llfloateranimpreview.h" // for reuploads
#include "llfloaterimagepreview.h" // for reuploads
//#include "llcheats.h"
#include "dofloaterhex.h"
#include "hgfloatertexteditor.h"
#include "statemachine/aifilepicker.h"
// </edit>

4
indra/newview/lllocalinventory.cpp
View File

@@ -11,7 +11,6 @@
#include "llpreviewtexture.h"
#include "llpreviewgesture.h"
#include "llpreviewlandmark.h"
#include "dofloaterhex.h"
#include "hgfloatertexteditor.h"
#include "llappviewer.h"
@@ -151,8 +150,7 @@ void LLLocalInventory::open(LLUUID item_id)
}
else
{
llwarns << "Dunno how to open type " << type << ", falling back to hex editor" << llendl;
DOFloaterHex::show(item_id);
llwarns << "Dunno how to open type " << type << llendl;
}
}

7
indra/newview/llviewermenu.cpp
View File

@@ -245,7 +245,6 @@
#include "lltexlayer.h"
// <edit>
#include "dofloaterhex.h"
#include "hgfloatertexteditor.h"
#include "llfloatervfs.h"
#include "llfloatervfsexplorer.h"
@@ -473,7 +472,6 @@ void handle_force_ground_sit(void*);
void handle_phantom_avatar(void*);
void handle_hide_typing_notification(void*);
void handle_close_all_notifications(void*);
void handle_reopen_with_hex_editor(void*);
//void handle_open_message_log(void*);
void handle_edit_ao(void*);
void handle_local_assets(void*);
@@ -3638,11 +3636,6 @@ void process_grant_godlike_powers(LLMessageSystem* msg, void**)
// <edit>
void handle_reopen_with_hex_editor(void*)
{
}
/*void handle_open_message_log(void*)
{
LLFloaterMessageLog::show();

14
indra/newview/skins/default/xui/en-us/floater_hex.xml
View File

@@ -1,14 +0,0 @@
<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
<floater can_close="true" can_drag_on_left="false" can_minimize="true"
can_resize="true" height="200" width="580" min_width="580" min_height="128"
name="floater_hex" title="Hex Editor" rect_control="FloaterHexRect">
<text name="status_text" follows="left|top" left="120" top="-25" height="20">Loading...</text>
<slider can_edit_text="false" top="-25" control_name="column_count"
decimal_digits="3" follows="left|top" height="16" increment="1"
initial_val="16" label="Columns" left="10" max_val="48" min_val="8"
mouse_opaque="true" name="column_count" show_text="false" value="16"
width="100" />
<button name="upload_btn" follows="right|top" top="-25" right="-120" width="100" bottom="155" label="[UPLOAD]" enabled="false"/>
<button name="save_btn" follows="right|top" top="-25" right="-10" width="100" bottom="155" label="Save" enabled="false"/>
<hex_editor name="hex" follows="left|top|right|bottom" left="10" top="-50" right="-10" bottom="10" visible="false"/>
</floater>

2
indra/newview/statemachine/CMakeLists.txt
View File

@@ -9,7 +9,6 @@ include(LLMessage) # This is needed by LLPlugin.
include(LLMath)
include(LLVFS)
include(LLXML)
include(LLXUIXML)
include(LLWindow)
include(LLUI)
include(LLRender)
@@ -26,7 +25,6 @@ include_directories(
${LLMATH_INCLUDE_DIRS}
${LLVFS_INCLUDE_DIRS}
${LLXML_INCLUDE_DIRS}
${LLXUIXML_INCLUDE_DIRS}
${LLWINDOW_INCLUDE_DIRS}
${LLUI_INCLUDE_DIRS}
${LLRENDER_INCLUDE_DIRS}