added message logger / builder floaters
This commit is contained in:
Hazim Gazov
@@ -48,6 +48,7 @@ set(llmessage_SOURCE_FILES
|
||||
llmail.cpp
|
||||
llmessagebuilder.cpp
|
||||
llmessageconfig.cpp
|
||||
llmessagelog.cpp
|
||||
llmessagereader.cpp
|
||||
llmessagetemplate.cpp
|
||||
llmessagetemplateparser.cpp
|
||||
@@ -138,6 +139,7 @@ set(llmessage_HEADER_FILES
|
||||
llmail.h
|
||||
llmessagebuilder.h
|
||||
llmessageconfig.h
|
||||
llmessagelog.h
|
||||
llmessagereader.h
|
||||
llmessagetemplate.h
|
||||
llmessagetemplateparser.h
|
||||
|
||||
@@ -1231,6 +1231,17 @@ void LLCircuit::getCircuitRange(
|
||||
first = mCircuitData.upper_bound(key);
|
||||
}
|
||||
|
||||
// <edit>
|
||||
std::vector<LLCircuitData*> LLCircuit::getCircuitDataList()
|
||||
{
|
||||
std::vector<LLCircuitData*> list;
|
||||
circuit_data_map::iterator end = mCircuitData.end();
|
||||
for(circuit_data_map::iterator iter = mCircuitData.begin(); iter != end; ++iter)
|
||||
list.push_back((*iter).second);
|
||||
return list;
|
||||
}
|
||||
// </edit>
|
||||
|
||||
TPACKETID LLCircuitData::nextPacketOutID()
|
||||
{
|
||||
mPacketsOut++;
|
||||
|
||||
@@ -331,6 +331,10 @@ public:
|
||||
const LLHost& key,
|
||||
circuit_data_map::iterator& first,
|
||||
circuit_data_map::iterator& end);
|
||||
|
||||
// <edit>
|
||||
std::vector<LLCircuitData*> getCircuitDataList();
|
||||
// </edit>
|
||||
|
||||
// Lists that optimize how many circuits we need to traverse a frame
|
||||
// HACK - this should become protected eventually, but stupid !@$@# message system/circuit classes are jumbling things up.
|
||||
|
||||
51
indra/llmessage/llmessagelog.cpp
Normal file
51
indra/llmessage/llmessagelog.cpp
Normal file
@@ -0,0 +1,51 @@
|
||||
// <edit>
|
||||
#include "llmessagelog.h"
|
||||
|
||||
LLMessageLogEntry::LLMessageLogEntry(EType type, LLHost from_host, LLHost to_host, U8* data, S32 data_size)
|
||||
: mType(type),
|
||||
mFromHost(from_host),
|
||||
mToHost(to_host),
|
||||
mDataSize(data_size)
|
||||
{
|
||||
if(data)
|
||||
{
|
||||
mData = new U8[data_size];
|
||||
memcpy(mData, data, data_size);
|
||||
}
|
||||
else
|
||||
{
|
||||
mData = NULL;
|
||||
}
|
||||
}
|
||||
LLMessageLogEntry::~LLMessageLogEntry()
|
||||
{
|
||||
// wtf, I'm not supposed to do this?
|
||||
//if(mData && mDataSize) delete[] mData;
|
||||
}
|
||||
U32 LLMessageLog::sMaxSize = 4096; // testzone fixme todo boom
|
||||
std::deque<LLMessageLogEntry> LLMessageLog::sDeque;
|
||||
void (*(LLMessageLog::sCallback))(LLMessageLogEntry);
|
||||
void LLMessageLog::setMaxSize(U32 size)
|
||||
{
|
||||
sMaxSize = size;
|
||||
while(sDeque.size() > sMaxSize)
|
||||
sDeque.pop_front();
|
||||
}
|
||||
void LLMessageLog::setCallback(void (*callback)(LLMessageLogEntry))
|
||||
{
|
||||
sCallback = callback;
|
||||
}
|
||||
void LLMessageLog::log(LLHost from_host, LLHost to_host, U8* data, S32 data_size)
|
||||
{
|
||||
LLMessageLogEntry entry = LLMessageLogEntry(LLMessageLogEntry::TEMPLATE, from_host, to_host, data, data_size);
|
||||
if(sCallback) sCallback(entry);
|
||||
if(!sMaxSize) return;
|
||||
sDeque.push_back(entry);
|
||||
if(sDeque.size() > sMaxSize)
|
||||
sDeque.pop_front();
|
||||
}
|
||||
std::deque<LLMessageLogEntry> LLMessageLog::getDeque()
|
||||
{
|
||||
return sDeque;
|
||||
}
|
||||
// </edit>
|
||||
40
indra/llmessage/llmessagelog.h
Normal file
40
indra/llmessage/llmessagelog.h
Normal file
@@ -0,0 +1,40 @@
|
||||
// <edit>
|
||||
#ifndef LL_LLMESSAGELOG_H
|
||||
#define LL_LLMESSAGELOG_H
|
||||
#include "stdtypes.h"
|
||||
#include "llhost.h"
|
||||
#include <queue>
|
||||
#include <string.h>
|
||||
|
||||
class LLMessageSystem;
|
||||
class LLMessageLogEntry
|
||||
{
|
||||
public:
|
||||
enum EType
|
||||
{
|
||||
TEMPLATE,
|
||||
HTTP_REQUEST,
|
||||
HTTP_RESPONSE
|
||||
};
|
||||
LLMessageLogEntry(EType type, LLHost from_host, LLHost to_host, U8* data, S32 data_size);
|
||||
~LLMessageLogEntry();
|
||||
EType mType;
|
||||
LLHost mFromHost;
|
||||
LLHost mToHost;
|
||||
S32 mDataSize;
|
||||
U8* mData;
|
||||
};
|
||||
class LLMessageLog
|
||||
{
|
||||
public:
|
||||
static void setMaxSize(U32 size);
|
||||
static void setCallback(void (*callback)(LLMessageLogEntry));
|
||||
static void log(LLHost from_host, LLHost to_host, U8* data, S32 data_size);
|
||||
static std::deque<LLMessageLogEntry> getDeque();
|
||||
private:
|
||||
static U32 sMaxSize;
|
||||
static void (*sCallback)(LLMessageLogEntry);
|
||||
static std::deque<LLMessageLogEntry> sDeque;
|
||||
};
|
||||
#endif
|
||||
// </edit>
|
||||
@@ -449,7 +449,10 @@ S32 LLTemplateMessageReader::getMessageSize() const
|
||||
// Returns template for the message contained in buffer
|
||||
BOOL LLTemplateMessageReader::decodeTemplate(
|
||||
const U8* buffer, S32 buffer_size, // inputs
|
||||
LLMessageTemplate** msg_template ) // outputs
|
||||
// <edit>
|
||||
//LLMessageTemplate** msg_template ) // outputs
|
||||
LLMessageTemplate** msg_template, BOOL custom)
|
||||
// </edit>
|
||||
{
|
||||
const U8* header = buffer + LL_PACKET_ID_SIZE;
|
||||
|
||||
@@ -491,6 +494,9 @@ BOOL LLTemplateMessageReader::decodeTemplate(
|
||||
}
|
||||
else // bogus packet received (too short)
|
||||
{
|
||||
// <edit>
|
||||
if(!custom)
|
||||
// </edit>
|
||||
llwarns << "Packet with unusable length received (too short): "
|
||||
<< buffer_size << llendl;
|
||||
return(FALSE);
|
||||
@@ -503,9 +509,16 @@ BOOL LLTemplateMessageReader::decodeTemplate(
|
||||
}
|
||||
else
|
||||
{
|
||||
// <edit>
|
||||
if(!custom)
|
||||
{
|
||||
// </edit>
|
||||
llwarns << "Message #" << std::hex << num << std::dec
|
||||
<< " received but not registered!" << llendl;
|
||||
gMessageSystem->callExceptionFunc(MX_UNREGISTERED_MESSAGE);
|
||||
// <edit>
|
||||
}
|
||||
// </edit>
|
||||
return(FALSE);
|
||||
}
|
||||
|
||||
@@ -532,7 +545,9 @@ void LLTemplateMessageReader::logRanOffEndOfPacket( const LLHost& host, const S3
|
||||
}
|
||||
|
||||
// decode a given message
|
||||
BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender )
|
||||
//BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender )
|
||||
BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender, BOOL custom)
|
||||
// </edit>
|
||||
{
|
||||
llassert( mReceiveSize >= 0 );
|
||||
llassert( mCurrentRMessageTemplate);
|
||||
@@ -590,6 +605,9 @@ BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender
|
||||
}
|
||||
else
|
||||
{
|
||||
// <edit>
|
||||
if(!custom)
|
||||
// </edit>
|
||||
llerrs << "Unknown block type" << llendl;
|
||||
return FALSE;
|
||||
}
|
||||
@@ -636,6 +654,9 @@ BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender
|
||||
|
||||
if ((decode_pos + data_size) > mReceiveSize)
|
||||
{
|
||||
// <edit>
|
||||
if(!custom)
|
||||
// </edit>
|
||||
logRanOffEndOfPacket(sender, decode_pos, data_size);
|
||||
|
||||
// default to 0 length variable blocks
|
||||
@@ -672,6 +693,9 @@ BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender
|
||||
// so, copy data pointer and set data size to fixed size
|
||||
if ((decode_pos + mvci.getSize()) > mReceiveSize)
|
||||
{
|
||||
// <edit>
|
||||
if(!custom)
|
||||
// </edit>
|
||||
logRanOffEndOfPacket(sender, decode_pos, mvci.getSize());
|
||||
|
||||
// default to 0s.
|
||||
@@ -699,7 +723,10 @@ BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender
|
||||
lldebugs << "Empty message '" << mCurrentRMessageTemplate->mName << "' (no blocks)" << llendl;
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
|
||||
// <edit>
|
||||
if(!custom)
|
||||
// </edit>
|
||||
{
|
||||
static LLTimer decode_timer;
|
||||
|
||||
@@ -755,11 +782,18 @@ BOOL LLTemplateMessageReader::decodeData(const U8* buffer, const LLHost& sender
|
||||
BOOL LLTemplateMessageReader::validateMessage(const U8* buffer,
|
||||
S32 buffer_size,
|
||||
const LLHost& sender,
|
||||
bool trusted)
|
||||
bool trusted,
|
||||
// <edit>
|
||||
BOOL custom)
|
||||
// </edit>)
|
||||
{
|
||||
mReceiveSize = buffer_size;
|
||||
BOOL valid = decodeTemplate(buffer, buffer_size, &mCurrentRMessageTemplate );
|
||||
if(valid)
|
||||
// <edit>
|
||||
//BOOL valid = decodeTemplate(buffer, buffer_size, &mCurrentRMessageTemplate );
|
||||
BOOL valid = decodeTemplate(buffer, buffer_size, &mCurrentRMessageTemplate, custom );
|
||||
//if(result)
|
||||
if(valid && !custom)
|
||||
// </edit>
|
||||
{
|
||||
mCurrentRMessageTemplate->mReceiveCount++;
|
||||
//lldebugs << "MessageRecvd:"
|
||||
@@ -799,12 +833,21 @@ const char* LLTemplateMessageReader::getMessageName() const
|
||||
{
|
||||
if (!mCurrentRMessageTemplate)
|
||||
{
|
||||
llwarns << "no mCurrentRMessageTemplate" << llendl;
|
||||
// <edit>
|
||||
//llwarns << "no mCurrentRMessageTemplate" << llendl;
|
||||
// </edit>
|
||||
return "";
|
||||
}
|
||||
return mCurrentRMessageTemplate->mName;
|
||||
}
|
||||
|
||||
// <edit>
|
||||
LLMessageTemplate* LLTemplateMessageReader::getTemplate()
|
||||
{
|
||||
return mCurrentRMessageTemplate;
|
||||
}
|
||||
// </edit>
|
||||
|
||||
//virtual
|
||||
bool LLTemplateMessageReader::isTrusted() const
|
||||
{
|
||||
|
||||
@@ -101,11 +101,18 @@ public:
|
||||
|
||||
virtual const char* getMessageName() const;
|
||||
virtual S32 getMessageSize() const;
|
||||
|
||||
// <edit>
|
||||
LLMessageTemplate* getTemplate();
|
||||
// </edit>
|
||||
|
||||
virtual void copyToBuilder(LLMessageBuilder&) const;
|
||||
|
||||
BOOL validateMessage(const U8* buffer, S32 buffer_size,
|
||||
const LLHost& sender, bool trusted = false);
|
||||
BOOL validateMessage(const U8* buffer, S32 buffer_size,
|
||||
// <edit>
|
||||
// const LLHost& sender);
|
||||
const LLHost& sender, bool trusted = false, BOOL custom = FALSE);
|
||||
// </edit>
|
||||
BOOL readMessage(const U8* buffer, const LLHost& sender);
|
||||
|
||||
bool isTrusted() const;
|
||||
@@ -118,11 +125,19 @@ private:
|
||||
S32 size = 0, S32 blocknum = 0, S32 max_size = S32_MAX);
|
||||
|
||||
BOOL decodeTemplate(const U8* buffer, S32 buffer_size, // inputs
|
||||
LLMessageTemplate** msg_template ); // outputs
|
||||
// <edit>
|
||||
// LLMessageTemplate** msg_template ); // outputs
|
||||
LLMessageTemplate** msg_template, BOOL custom = FALSE);
|
||||
// </edit>
|
||||
|
||||
void logRanOffEndOfPacket( const LLHost& host, const S32 where, const S32 wanted );
|
||||
|
||||
BOOL decodeData(const U8* buffer, const LLHost& sender );
|
||||
// <edit>
|
||||
//BOOL decodeData(const U8* buffer, const LLHost& sender );
|
||||
public:
|
||||
BOOL decodeData(const U8* buffer, const LLHost& sender, BOOL custom = FALSE);
|
||||
private:
|
||||
// </edit>
|
||||
|
||||
S32 mReceiveSize;
|
||||
LLMessageTemplate* mCurrentRMessageTemplate;
|
||||
|
||||
@@ -87,6 +87,11 @@
|
||||
#include "v4math.h"
|
||||
#include "lltransfertargetvfile.h"
|
||||
|
||||
// <edit>
|
||||
#include "llrand.h"
|
||||
#include "llmessagelog.h"
|
||||
// </edit>
|
||||
|
||||
// Constants
|
||||
//const char* MESSAGE_LOG_FILENAME = "message.log";
|
||||
static const F32 CIRCUIT_DUMP_TIMEOUT = 30.f;
|
||||
@@ -562,6 +567,14 @@ BOOL LLMessageSystem::checkMessages( S64 frame_count )
|
||||
// If you want to dump all received packets into SecondLife.log, uncomment this
|
||||
//dumpPacketToLog();
|
||||
|
||||
// <edit>
|
||||
if(mTrueReceiveSize)
|
||||
{
|
||||
LLMessageLog::log(mLastSender, LLHost(16777343, mPort), buffer, mTrueReceiveSize);
|
||||
}
|
||||
// </edit>
|
||||
|
||||
|
||||
if (receive_size < (S32) LL_MINIMUM_VALID_PACKET_SIZE)
|
||||
{
|
||||
// A receive size of zero is OK, that means that there are no more packets available.
|
||||
@@ -1554,6 +1567,13 @@ void LLMessageSystem::getCircuitInfo(LLSD& info) const
|
||||
mCircuitInfo.getInfo(info);
|
||||
}
|
||||
|
||||
// <edit>
|
||||
LLCircuit* LLMessageSystem::getCircuit()
|
||||
{
|
||||
return &mCircuitInfo;
|
||||
}
|
||||
// </edit>
|
||||
|
||||
// returns whether the given host is on a trusted circuit
|
||||
BOOL LLMessageSystem::getCircuitTrust(const LLHost &host)
|
||||
{
|
||||
|
||||
@@ -231,11 +231,15 @@ class LLMessageSystem : public LLMessageSenderInterface
|
||||
typedef std::map<const char *, LLMessageTemplate*> message_template_name_map_t;
|
||||
typedef std::map<U32, LLMessageTemplate*> message_template_number_map_t;
|
||||
|
||||
private:
|
||||
// <edit>
|
||||
//private:
|
||||
// </edit>
|
||||
message_template_name_map_t mMessageTemplates;
|
||||
message_template_number_map_t mMessageNumbers;
|
||||
|
||||
public:
|
||||
// <edit>
|
||||
//public:
|
||||
// </edit>
|
||||
S32 mSystemVersionMajor;
|
||||
S32 mSystemVersionMinor;
|
||||
S32 mSystemVersionPatch;
|
||||
@@ -569,6 +573,9 @@ public:
|
||||
|
||||
void showCircuitInfo();
|
||||
void getCircuitInfo(LLSD& info) const;
|
||||
// <edit>
|
||||
LLCircuit* getCircuit();
|
||||
// </edit>
|
||||
|
||||
U32 getOurCircuitCode();
|
||||
|
||||
|
||||
@@ -55,6 +55,11 @@
|
||||
#include "llhost.h"
|
||||
#include "lltimer.h"
|
||||
#include "indra_constants.h"
|
||||
// <edit>
|
||||
#include "llmessagelog.h"
|
||||
#include "message.h"
|
||||
// </edit>
|
||||
|
||||
|
||||
#include "llsocks5.h"
|
||||
|
||||
@@ -421,6 +426,10 @@ S32 receive_packet(int hSocket, char * receiveBuffer)
|
||||
// Returns TRUE on success.
|
||||
BOOL send_packet(int hSocket, const char *sendBuffer, int size, U32 recipient, int nPort)
|
||||
{
|
||||
// <edit>
|
||||
LLMessageLog::log(LLHost(16777343, gMessageSystem->getListenPort()), LLHost(recipient, nPort), (U8*)sendBuffer, size);
|
||||
// </edit>
|
||||
|
||||
// Sends a packet to the address set in initNet
|
||||
//
|
||||
int nRet = 0;
|
||||
|
||||
@@ -53,6 +53,9 @@
|
||||
#include "llcontrol.h"
|
||||
#include "llkeyboard.h"
|
||||
#include "llresizebar.h"
|
||||
// <edit>
|
||||
#include "lllineeditor.h"
|
||||
// </edit>
|
||||
|
||||
const S32 MIN_COLUMN_WIDTH = 20;
|
||||
const S32 LIST_SNAP_PADDING = 5;
|
||||
@@ -103,6 +106,10 @@ struct SortScrollListItem
|
||||
LLScrollListIcon::LLScrollListIcon(LLUIImagePtr icon, S32 width)
|
||||
: LLScrollListCell(width),
|
||||
mIcon(icon),
|
||||
// <edit>
|
||||
mCallback(NULL),
|
||||
mUserData(NULL),
|
||||
// </edit>
|
||||
mColor(LLColor4::white)
|
||||
{
|
||||
}
|
||||
@@ -161,6 +168,19 @@ S32 LLScrollListIcon::getWidth() const
|
||||
return LLScrollListCell::getWidth();
|
||||
}
|
||||
|
||||
// <edit>
|
||||
void LLScrollListIcon::setClickCallback(BOOL (*callback)(void*), void* user_data)
|
||||
{
|
||||
mCallback = callback;
|
||||
mUserData = user_data;
|
||||
}
|
||||
|
||||
BOOL LLScrollListIcon::handleClick()
|
||||
{
|
||||
if(mCallback) return mCallback(mUserData);
|
||||
return FALSE;
|
||||
}
|
||||
// </edit>
|
||||
|
||||
void LLScrollListIcon::draw(const LLColor4& color, const LLColor4& highlight_color) const
|
||||
{
|
||||
@@ -210,6 +230,59 @@ BOOL LLScrollListCheck::handleClick()
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
// <edit>
|
||||
//
|
||||
// LLScrollListLineEditor
|
||||
//
|
||||
LLScrollListLineEditor::LLScrollListLineEditor(LLLineEditor* line_editor, S32 width)
|
||||
{
|
||||
mLineEditor = line_editor;
|
||||
LLRect rect(mLineEditor->getRect());
|
||||
if (width)
|
||||
{
|
||||
|
||||
rect.mRight = rect.mLeft + width;
|
||||
mLineEditor->setRect(rect);
|
||||
setWidth(width);
|
||||
}
|
||||
else
|
||||
{
|
||||
setWidth(rect.getWidth()); //line_editor->getWidth();
|
||||
}
|
||||
}
|
||||
|
||||
LLScrollListLineEditor::~LLScrollListLineEditor()
|
||||
{
|
||||
delete mLineEditor;
|
||||
}
|
||||
|
||||
void LLScrollListLineEditor::draw(const LLColor4& color, const LLColor4& highlight_color) const
|
||||
{
|
||||
mLineEditor->draw();
|
||||
}
|
||||
|
||||
BOOL LLScrollListLineEditor::handleClick()
|
||||
{
|
||||
if (mLineEditor->getEnabled())
|
||||
{
|
||||
mLineEditor->setFocus(TRUE);
|
||||
mLineEditor->selectAll();
|
||||
}
|
||||
// return value changes selection?
|
||||
return FALSE; //TRUE;
|
||||
}
|
||||
|
||||
BOOL LLScrollListLineEditor::handleUnicodeChar(llwchar uni_char, BOOL called_from_parent)
|
||||
{
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
BOOL LLScrollListLineEditor::handleUnicodeCharHere(llwchar uni_char )
|
||||
{
|
||||
return TRUE;
|
||||
}
|
||||
// </edit>
|
||||
|
||||
//
|
||||
// LLScrollListSeparator
|
||||
//
|
||||
@@ -3410,6 +3483,21 @@ LLScrollListItem* LLScrollListCtrl::addElement(const LLSD& value, EAddPosition p
|
||||
columnp->mHeader->setHasResizableElement(TRUE);
|
||||
}
|
||||
}
|
||||
// <edit>
|
||||
else if(type == "line_editor")
|
||||
{
|
||||
LLLineEditor* ctrl = new LLLineEditor(std::string("line_editor"),
|
||||
LLRect(0, width, width, 0), std::string(""));
|
||||
ctrl->setEnabled(enabled);
|
||||
ctrl->setValue(value);
|
||||
LLScrollListLineEditor* cell = new LLScrollListLineEditor(ctrl,width);
|
||||
if (has_color)
|
||||
{
|
||||
cell->setColor(color);
|
||||
}
|
||||
new_item->setColumn(index, cell);
|
||||
}
|
||||
// </edit>
|
||||
else
|
||||
{
|
||||
LLScrollListText* cell = new LLScrollListText(value.asString(), font, width, font_style, font_alignment, fcolor, TRUE);
|
||||
|
||||
@@ -49,6 +49,9 @@
|
||||
#include "llscrollbar.h"
|
||||
#include "llresizebar.h"
|
||||
#include "lldate.h"
|
||||
// <edit>
|
||||
#include "lllineeditor.h"
|
||||
// </edit>
|
||||
|
||||
/*
|
||||
* Represents a cell in a scrollable table.
|
||||
@@ -163,10 +166,18 @@ public:
|
||||
virtual void setColor(const LLColor4&);
|
||||
virtual BOOL isText()const { return FALSE; }
|
||||
virtual void setValue(const LLSD& value);
|
||||
// <edit>
|
||||
void setClickCallback(BOOL (*callback)(void*), void* user_data);
|
||||
virtual BOOL handleClick();
|
||||
// </edit>
|
||||
|
||||
private:
|
||||
LLUIImagePtr mIcon;
|
||||
LLColor4 mColor;
|
||||
// <edit>
|
||||
BOOL (*mCallback)(void*);
|
||||
void* mUserData;
|
||||
// </edit>
|
||||
};
|
||||
|
||||
/*
|
||||
@@ -193,6 +204,30 @@ private:
|
||||
LLCheckBoxCtrl* mCheckBox;
|
||||
};
|
||||
|
||||
// <edit>
|
||||
class LLScrollListLineEditor : public LLScrollListCell
|
||||
{
|
||||
public:
|
||||
LLScrollListLineEditor( LLLineEditor* line_editor, S32 width = 0);
|
||||
/*virtual*/ ~LLScrollListLineEditor();
|
||||
virtual void draw(const LLColor4& color, const LLColor4& highlight_color) const;
|
||||
virtual S32 getHeight() const { return 0; }
|
||||
virtual const LLSD getValue() const { return mLineEditor->getValue(); }
|
||||
virtual void setValue(const LLSD& value) { mLineEditor->setValue(value); }
|
||||
virtual void onCommit() { mLineEditor->onCommit(); }
|
||||
virtual BOOL handleClick();
|
||||
virtual BOOL handleUnicodeChar(llwchar uni_char, BOOL called_from_parent);
|
||||
virtual BOOL handleUnicodeCharHere(llwchar uni_char );
|
||||
virtual void setEnabled(BOOL enable) { mLineEditor->setEnabled(enable); }
|
||||
|
||||
LLLineEditor* getLineEditor() { return mLineEditor; }
|
||||
virtual BOOL isText() const { return FALSE; }
|
||||
|
||||
private:
|
||||
LLLineEditor* mLineEditor;
|
||||
};
|
||||
// </edit>
|
||||
|
||||
/*
|
||||
* A simple data class describing a column within a scroll list.
|
||||
*/
|
||||
@@ -497,6 +532,11 @@ public:
|
||||
|
||||
virtual S32 getScrollPos() const;
|
||||
virtual void setScrollPos( S32 pos );
|
||||
|
||||
// <edit>
|
||||
S32 getPageLines() { return mPageLines; }
|
||||
// </edit>
|
||||
|
||||
S32 getSearchColumn();
|
||||
void setSearchColumn(S32 column) { mSearchColumn = column; }
|
||||
S32 getColumnIndexFromOffset(S32 x);
|
||||
|
||||
@@ -301,7 +301,13 @@ protected:
|
||||
BOOL handleControlKey(const KEY key, const MASK mask);
|
||||
BOOL handleEditKey(const KEY key, const MASK mask);
|
||||
|
||||
// <edit>
|
||||
public:
|
||||
// </edit>
|
||||
BOOL hasSelection() const { return (mSelectionStart !=mSelectionEnd); }
|
||||
// <edit>
|
||||
protected:
|
||||
// </edit>
|
||||
BOOL selectionContainsLineBreaks();
|
||||
void startSelection();
|
||||
void endSelection();
|
||||
|
||||
@@ -182,6 +182,8 @@ set(viewer_SOURCE_FILES
|
||||
llfloaterlandmark.cpp
|
||||
llfloatermap.cpp
|
||||
llfloatermemleak.cpp
|
||||
llfloatermessagebuilder.cpp
|
||||
llfloatermessagelog.cpp
|
||||
llfloatermute.cpp
|
||||
llfloaternamedesc.cpp
|
||||
llfloaternewim.cpp
|
||||
@@ -616,6 +618,8 @@ set(viewer_HEADER_FILES
|
||||
llfloaterlandmark.h
|
||||
llfloatermap.h
|
||||
llfloatermemleak.h
|
||||
llfloatermessagebuilder.h
|
||||
llfloatermessagelog.h
|
||||
llfloatermute.h
|
||||
llfloaternamedesc.h
|
||||
llfloaternewim.h
|
||||
|
||||
810
indra/newview/llfloatermessagebuilder.cpp
Normal file
810
indra/newview/llfloatermessagebuilder.cpp
Normal file
@@ -0,0 +1,810 @@
|
||||
// <edit>
|
||||
#include "llviewerprecompiledheaders.h"
|
||||
#include "llfloatermessagebuilder.h"
|
||||
#include "lluictrlfactory.h"
|
||||
#include "llmessagetemplate.h"
|
||||
#include "llagent.h"
|
||||
#include "llchat.h"
|
||||
#include "llfloaterchat.h"
|
||||
#include "llviewerregion.h" // getHandle
|
||||
#include "llcombobox.h"
|
||||
#include "llselectmgr.h" // fill in stuff about selected object
|
||||
#include "llparcel.h"
|
||||
#include "llviewerparcelmgr.h" // same for parcel
|
||||
LLFloaterMessageBuilder::LLFloaterMessageBuilder(std::string initial_text)
|
||||
: LLFloater(),
|
||||
mInitialText(initial_text)
|
||||
{
|
||||
LLUICtrlFactory::getInstance()->buildFloater(this, "floater_message_builder.xml");
|
||||
}
|
||||
LLFloaterMessageBuilder::~LLFloaterMessageBuilder()
|
||||
{
|
||||
}
|
||||
void LLFloaterMessageBuilder::show(std::string initial_text)
|
||||
{
|
||||
(new LLFloaterMessageBuilder(initial_text))->open();
|
||||
}
|
||||
BOOL LLFloaterMessageBuilder::postBuild()
|
||||
{
|
||||
childSetText("message_edit", mInitialText);
|
||||
childSetAction("send_btn", onClickSend, this);
|
||||
std::vector<std::string> names;
|
||||
LLComboBox* combo;
|
||||
LLMessageSystem::message_template_name_map_t::iterator temp_end = gMessageSystem->mMessageTemplates.end();
|
||||
LLMessageSystem::message_template_name_map_t::iterator temp_iter;
|
||||
std::vector<std::string>::iterator names_end;
|
||||
std::vector<std::string>::iterator names_iter;
|
||||
for(temp_iter = gMessageSystem->mMessageTemplates.begin(); temp_iter != temp_end; ++temp_iter)
|
||||
if((*temp_iter).second->getTrust() == MT_NOTRUST)
|
||||
names.push_back((*temp_iter).second->mName);
|
||||
std::sort(names.begin(), names.end());
|
||||
combo = getChild<LLComboBox>("untrusted_message_combo");
|
||||
names_end = names.end();
|
||||
for(names_iter = names.begin(); names_iter != names_end; ++names_iter)
|
||||
combo->add((*names_iter));
|
||||
names.clear();
|
||||
for(temp_iter = gMessageSystem->mMessageTemplates.begin(); temp_iter != temp_end; ++temp_iter)
|
||||
if((*temp_iter).second->getTrust() == MT_TRUST)
|
||||
names.push_back((*temp_iter).second->mName);
|
||||
std::sort(names.begin(), names.end());
|
||||
combo = getChild<LLComboBox>("trusted_message_combo");
|
||||
names_end = names.end();
|
||||
for(names_iter = names.begin(); names_iter != names_end; ++names_iter)
|
||||
combo->add((*names_iter));
|
||||
childSetCommitCallback("untrusted_message_combo", onCommitPacketCombo, this);
|
||||
childSetCommitCallback("trusted_message_combo", onCommitPacketCombo, this);
|
||||
return TRUE;
|
||||
}
|
||||
inline std::vector<std::string> split(std::string input, std::string separator)
|
||||
{
|
||||
S32 size = input.length();
|
||||
char* buffer = new char[size + 1];
|
||||
strncpy(buffer, input.c_str(), size);
|
||||
buffer[size] = '\0';
|
||||
std::vector<std::string> lines;
|
||||
char* result = strtok(buffer, separator.c_str());
|
||||
while(result)
|
||||
{
|
||||
lines.push_back(result);
|
||||
result = strtok(NULL, separator.c_str());
|
||||
}
|
||||
delete[] buffer;
|
||||
return lines;
|
||||
}
|
||||
std::string mvtstr(e_message_variable_type var_type)
|
||||
{
|
||||
switch(var_type)
|
||||
{
|
||||
case MVT_U8:
|
||||
return "U8";
|
||||
break;
|
||||
case MVT_U16:
|
||||
return "U16";
|
||||
break;
|
||||
case MVT_U32:
|
||||
return "U32";
|
||||
break;
|
||||
case MVT_U64:
|
||||
return "U64";
|
||||
break;
|
||||
case MVT_S8:
|
||||
return "S8";
|
||||
break;
|
||||
case MVT_S16:
|
||||
return "S16";
|
||||
break;
|
||||
case MVT_S32:
|
||||
return "S32";
|
||||
break;
|
||||
case MVT_S64:
|
||||
return "S64";
|
||||
break;
|
||||
case MVT_F32:
|
||||
return "F32";
|
||||
break;
|
||||
case MVT_F64:
|
||||
return "F64";
|
||||
break;
|
||||
case MVT_LLVector3:
|
||||
return "LLVector3";
|
||||
break;
|
||||
case MVT_LLVector3d:
|
||||
return "LLVector3d";
|
||||
break;
|
||||
case MVT_LLVector4:
|
||||
return "LLVector4";
|
||||
break;
|
||||
case MVT_LLQuaternion:
|
||||
return "LLQuaternion";
|
||||
break;
|
||||
case MVT_LLUUID:
|
||||
return "LLUUID";
|
||||
break;
|
||||
case MVT_BOOL:
|
||||
return "BOOL";
|
||||
break;
|
||||
case MVT_IP_ADDR:
|
||||
return "IPADDR";
|
||||
break;
|
||||
case MVT_IP_PORT:
|
||||
return "IPPORT";
|
||||
break;
|
||||
case MVT_VARIABLE:
|
||||
return "Variable";
|
||||
break;
|
||||
case MVT_FIXED:
|
||||
return "Fixed";
|
||||
break;
|
||||
default:
|
||||
return "Missingno.";
|
||||
break;
|
||||
}
|
||||
}
|
||||
// static
|
||||
BOOL LLFloaterMessageBuilder::addField(e_message_variable_type var_type, const char* var_name, std::string input, BOOL hex)
|
||||
{
|
||||
LLStringUtil::trim(input);
|
||||
if(input.length() < 1 && var_type != MVT_VARIABLE)
|
||||
return FALSE;
|
||||
U8 valueU8;
|
||||
U16 valueU16;
|
||||
U32 valueU32;
|
||||
U64 valueU64;
|
||||
S8 valueS8;
|
||||
S16 valueS16;
|
||||
S32 valueS32;
|
||||
// S64 valueS64;
|
||||
F32 valueF32;
|
||||
F64 valueF64;
|
||||
LLVector3 valueVector3;
|
||||
LLVector3d valueVector3d;
|
||||
LLVector4 valueVector4;
|
||||
LLQuaternion valueQuaternion;
|
||||
LLUUID valueLLUUID;
|
||||
BOOL valueBOOL;
|
||||
std::string input_lower = input;
|
||||
LLStringUtil::toLower(input_lower);
|
||||
if(input_lower == "$agentid")
|
||||
input = gAgent.getID().asString();
|
||||
else if(input_lower == "$sessionid")
|
||||
input = gAgent.getSessionID().asString();
|
||||
else if(input_lower == "$uuid")
|
||||
{
|
||||
LLUUID id;
|
||||
id.generate();
|
||||
input = id.asString();
|
||||
}
|
||||
else if(input_lower == "$circuitcode")
|
||||
{
|
||||
std::stringstream temp_stream;
|
||||
temp_stream << gMessageSystem->mOurCircuitCode;
|
||||
input = temp_stream.str();
|
||||
}
|
||||
else if(input_lower == "$regionhandle")
|
||||
{
|
||||
std::stringstream temp_stream;
|
||||
temp_stream << (gAgent.getRegion() ? gAgent.getRegion()->getHandle() : 0);
|
||||
input = temp_stream.str();
|
||||
}
|
||||
else if(input_lower == "$position" || input_lower == "$pos")
|
||||
{
|
||||
std::stringstream temp_stream;
|
||||
valueVector3 = gAgent.getPositionAgent();
|
||||
temp_stream << "<" << valueVector3[0] << ", " << valueVector3[1] << ", " << valueVector3[2] << ">";
|
||||
input = temp_stream.str();
|
||||
}
|
||||
if(hex)
|
||||
{
|
||||
if(var_type != MVT_VARIABLE && var_type != MVT_FIXED)
|
||||
return FALSE;
|
||||
int len = input_lower.length();
|
||||
const char* cstr = input_lower.c_str();
|
||||
std::string new_input("");
|
||||
BOOL nibble = FALSE;
|
||||
char byte = 0;
|
||||
for(int i = 0; i < len; i++)
|
||||
{
|
||||
char c = cstr[i];
|
||||
if(c >= 0x30 && c <= 0x39)
|
||||
c -= 0x30;
|
||||
else if(c >= 0x61 && c <= 0x66)
|
||||
c -= 0x57;
|
||||
else if(c != 0x20)
|
||||
return FALSE;
|
||||
else
|
||||
continue;
|
||||
if(!nibble)
|
||||
byte = c << 4;
|
||||
else
|
||||
new_input.push_back(byte | c);
|
||||
nibble = !nibble;
|
||||
}
|
||||
if(nibble)
|
||||
return FALSE;
|
||||
input = new_input;
|
||||
}
|
||||
std::stringstream stream(input);
|
||||
std::vector<std::string> tokens;
|
||||
switch(var_type)
|
||||
{
|
||||
case MVT_U8:
|
||||
if(input.substr(0, 1) == "-")
|
||||
return FALSE;
|
||||
if((stream >> valueU32).fail())
|
||||
return FALSE;
|
||||
valueU8 = (U8)valueU32;
|
||||
gMessageSystem->addU8(var_name, valueU8);
|
||||
return TRUE;
|
||||
break;
|
||||
case MVT_U16:
|
||||
if(input.substr(0, 1) == "-")
|
||||
return FALSE;
|
||||
if((stream >> valueU16).fail())
|
||||
return FALSE;
|
||||
gMessageSystem->addU16(var_name, valueU16);
|
||||
return TRUE;
|
||||
break;
|
||||
case MVT_U32:
|
||||
if(input.substr(0, 1) == "-")
|
||||
return FALSE;
|
||||
if((stream >> valueU32).fail())
|
||||
return FALSE;
|
||||
gMessageSystem->addU32(var_name, valueU32);
|
||||
return TRUE;
|
||||
break;
|
||||
case MVT_U64:
|
||||
if(input.substr(0, 1) == "-")
|
||||
return FALSE;
|
||||
if((stream >> valueU64).fail())
|
||||
return FALSE;
|
||||
gMessageSystem->addU64(var_name, valueU64);
|
||||
return TRUE;
|
||||
break;
|
||||
case MVT_S8:
|
||||
if((stream >> valueS8).fail())
|
||||
return FALSE;
|
||||
gMessageSystem->addS8(var_name, valueS8);
|
||||
return TRUE;
|
||||
break;
|
||||
case MVT_S16:
|
||||
if((stream >> valueS16).fail())
|
||||
return FALSE;
|
||||
gMessageSystem->addS16(var_name, valueS16);
|
||||
return TRUE;
|
||||
break;
|
||||
case MVT_S32:
|
||||
if((stream >> valueS32).fail())
|
||||
return FALSE;
|
||||
gMessageSystem->addS32(var_name, valueS32);
|
||||
return TRUE;
|
||||
break;
|
||||
/*
|
||||
case MVT_S64:
|
||||
if((stream >> valueS64).fail())
|
||||
return FALSE;
|
||||
gMessageSystem->addS64(var_name, valueS64);
|
||||
return TRUE;
|
||||
break;
|
||||
*/
|
||||
case MVT_F32:
|
||||
if((stream >> valueF32).fail())
|
||||
return FALSE;
|
||||
gMessageSystem->addF32(var_name, valueF32);
|
||||
return TRUE;
|
||||
break;
|
||||
case MVT_F64:
|
||||
if((stream >> valueF64).fail())
|
||||
return FALSE;
|
||||
gMessageSystem->addF64(var_name, valueF64);
|
||||
return TRUE;
|
||||
break;
|
||||
case MVT_LLVector3:
|
||||
LLStringUtil::trim(input);
|
||||
if(input.substr(0, 1) != "<" || input.substr(input.length() - 1, 1) != ">")
|
||||
return FALSE;
|
||||
tokens = split(input.substr(1, input.length() - 2), ",");
|
||||
if(tokens.size() != 3)
|
||||
return FALSE;
|
||||
for(int i = 0; i < 3; i++)
|
||||
{
|
||||
stream.clear();
|
||||
stream.str(tokens[i]);
|
||||
if((stream >> valueF32).fail())
|
||||
return FALSE;
|
||||
valueVector3.mV[i] = valueF32;
|
||||
}
|
||||
gMessageSystem->addVector3(var_name, valueVector3);
|
||||
return TRUE;
|
||||
break;
|
||||
case MVT_LLVector3d:
|
||||
LLStringUtil::trim(input);
|
||||
if(input.substr(0, 1) != "<" || input.substr(input.length() - 1, 1) != ">")
|
||||
return FALSE;
|
||||
tokens = split(input.substr(1, input.length() - 2), ",");
|
||||
if(tokens.size() != 3)
|
||||
return FALSE;
|
||||
for(int i = 0; i < 3; i++)
|
||||
{
|
||||
stream.clear();
|
||||
stream.str(tokens[i]);
|
||||
if((stream >> valueF64).fail())
|
||||
return FALSE;
|
||||
valueVector3d.mdV[i] = valueF64;
|
||||
}
|
||||
gMessageSystem->addVector3d(var_name, valueVector3d);
|
||||
return TRUE;
|
||||
break;
|
||||
case MVT_LLVector4:
|
||||
LLStringUtil::trim(input);
|
||||
if(input.substr(0, 1) != "<" || input.substr(input.length() - 1, 1) != ">")
|
||||
return FALSE;
|
||||
tokens = split(input.substr(1, input.length() - 2), ",");
|
||||
if(tokens.size() != 4)
|
||||
return FALSE;
|
||||
for(int i = 0; i < 4; i++)
|
||||
{
|
||||
stream.clear();
|
||||
stream.str(tokens[i]);
|
||||
if((stream >> valueF32).fail())
|
||||
return FALSE;
|
||||
valueVector4.mV[i] = valueF32;
|
||||
}
|
||||
gMessageSystem->addVector4(var_name, valueVector4);
|
||||
return TRUE;
|
||||
break;
|
||||
case MVT_LLQuaternion:
|
||||
LLStringUtil::trim(input);
|
||||
if(input.substr(0, 1) != "<" || input.substr(input.length() - 1, 1) != ">")
|
||||
return FALSE;
|
||||
tokens = split(input.substr(1, input.length() - 2), ",");
|
||||
if(tokens.size() != 3)
|
||||
return FALSE;
|
||||
for(int i = 0; i < 3; i++)
|
||||
{
|
||||
stream.clear();
|
||||
stream.str(tokens[i]);
|
||||
if((stream >> valueF32).fail())
|
||||
return FALSE;
|
||||
valueVector3.mV[i] = valueF32;
|
||||
}
|
||||
valueQuaternion.unpackFromVector3(valueVector3);
|
||||
gMessageSystem->addQuat(var_name, valueQuaternion);
|
||||
return TRUE;
|
||||
break;
|
||||
case MVT_LLUUID:
|
||||
if((stream >> valueLLUUID).fail())
|
||||
return FALSE;
|
||||
gMessageSystem->addUUID(var_name, valueLLUUID);
|
||||
return TRUE;
|
||||
break;
|
||||
case MVT_BOOL:
|
||||
if(input_lower == "true")
|
||||
valueBOOL = TRUE;
|
||||
else if(input_lower == "false")
|
||||
valueBOOL = FALSE;
|
||||
else if((stream >> valueBOOL).fail())
|
||||
return FALSE;
|
||||
//gMessageSystem->addBOOL(var_name, valueBOOL);
|
||||
gMessageSystem->addU8(var_name, (U8)valueBOOL);
|
||||
return TRUE;
|
||||
break;
|
||||
case MVT_IP_ADDR:
|
||||
if((stream >> valueU32).fail())
|
||||
return FALSE;
|
||||
gMessageSystem->addIPAddr(var_name, valueU32);
|
||||
return TRUE;
|
||||
break;
|
||||
case MVT_IP_PORT:
|
||||
if((stream >> valueU16).fail())
|
||||
return FALSE;
|
||||
gMessageSystem->addIPPort(var_name, valueU16);
|
||||
return TRUE;
|
||||
break;
|
||||
case MVT_VARIABLE:
|
||||
if(!hex)
|
||||
{
|
||||
char* buffer = new char[input.size() + 1];
|
||||
strncpy(buffer, input.c_str(), input.size());
|
||||
buffer[input.size()] = '\0';
|
||||
gMessageSystem->addBinaryData(var_name, buffer, input.size() + 1);
|
||||
delete[] buffer;
|
||||
}
|
||||
else
|
||||
gMessageSystem->addBinaryData(var_name, input.c_str(), input.size());
|
||||
return TRUE;
|
||||
break;
|
||||
case MVT_FIXED:
|
||||
if(!hex)
|
||||
{
|
||||
char* buffer = new char[input.size() + 1];
|
||||
strncpy(buffer, input.c_str(), input.size());
|
||||
buffer[input.size()] = '\0';
|
||||
gMessageSystem->addBinaryData(var_name, buffer, input.size());
|
||||
delete[] buffer;
|
||||
}
|
||||
else
|
||||
gMessageSystem->addBinaryData(var_name, input.c_str(), input.size());
|
||||
return TRUE;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
// static
|
||||
void LLFloaterMessageBuilder::onCommitPacketCombo(LLUICtrl* ctrl, void* user_data)
|
||||
{
|
||||
LLFloaterMessageBuilder* floaterp = (LLFloaterMessageBuilder*)user_data;
|
||||
LLViewerObject* selected_objectp = LLSelectMgr::getInstance()->getSelection()->getPrimaryObject();
|
||||
LLParcel* agent_parcelp = LLViewerParcelMgr::getInstance()->getAgentParcel();
|
||||
std::string message = ctrl->getValue();
|
||||
std::map<const char *, LLMessageTemplate*>::iterator template_iter;
|
||||
template_iter = gMessageSystem->mMessageTemplates.find( LLMessageStringTable::getInstance()->getString(message.c_str()) );
|
||||
if(template_iter == gMessageSystem->mMessageTemplates.end())
|
||||
{
|
||||
floaterp->childSetText("message_edit", std::string(""));
|
||||
return;
|
||||
}
|
||||
std::string text(llformat((*template_iter).second->getTrust() == MT_NOTRUST ? "out %s\n" : "in %s\n", message.c_str()));
|
||||
LLMessageTemplate* temp = (*template_iter).second;
|
||||
LLMessageTemplate::message_block_map_t::iterator blocks_end = temp->mMemberBlocks.end();
|
||||
for (LLMessageTemplate::message_block_map_t::iterator blocks_iter = temp->mMemberBlocks.begin();
|
||||
blocks_iter != blocks_end; ++blocks_iter)
|
||||
{
|
||||
LLMessageBlock* block = (*blocks_iter);
|
||||
const char* block_name = block->mName;
|
||||
std::string block_name_string = std::string(block_name);
|
||||
S32 num_blocks = 1;
|
||||
if(block->mType == MBT_MULTIPLE)
|
||||
num_blocks = block->mNumber;
|
||||
else if(("ObjectLink" == message && "ObjectData" == block_name_string))
|
||||
num_blocks = 2;
|
||||
for(S32 i = 0; i < num_blocks; i++)
|
||||
{
|
||||
text.append(llformat("[%s]\n", block_name));
|
||||
LLMessageBlock::message_variable_map_t::iterator var_end = block->mMemberVariables.end();
|
||||
for (LLMessageBlock::message_variable_map_t::iterator var_iter = block->mMemberVariables.begin();
|
||||
var_iter != var_end; ++var_iter)
|
||||
{
|
||||
LLMessageVariable* variable = (*var_iter);
|
||||
const char* var_name = variable->getName();
|
||||
std::string var_name_string = std::string(var_name);
|
||||
text.append(llformat("%s = ", var_name));
|
||||
std::string value("");
|
||||
S32 size = variable->getSize();
|
||||
switch(variable->getType())
|
||||
{
|
||||
case MVT_U8:
|
||||
case MVT_U16:
|
||||
case MVT_U32:
|
||||
case MVT_U64:
|
||||
case MVT_S8:
|
||||
case MVT_S16:
|
||||
case MVT_S32:
|
||||
case MVT_IP_ADDR:
|
||||
case MVT_IP_PORT:
|
||||
if("RegionHandle" == var_name_string || "Handle" == var_name_string)
|
||||
value = "$RegionHandle";
|
||||
else if("CircuitCode" == var_name_string || "ViewerCircuitCode" == var_name_string
|
||||
|| ("Code" == var_name_string && "CircuitCode" == block_name_string) )
|
||||
{
|
||||
value = "$CircuitCode";
|
||||
}
|
||||
else if(selected_objectp &&
|
||||
(
|
||||
"ObjectLocalID" == var_name_string
|
||||
|| "TaskLocalID" == var_name_string
|
||||
|| ("LocalID" == var_name_string &&
|
||||
(
|
||||
"ObjectData" == block_name_string
|
||||
|| "UpdateData" == block_name_string
|
||||
|| "InventoryData" == block_name_string
|
||||
)
|
||||
)
|
||||
)
|
||||
)
|
||||
{
|
||||
std::stringstream temp_stream;
|
||||
temp_stream << selected_objectp->getLocalID();
|
||||
value = temp_stream.str();
|
||||
}
|
||||
else if( agent_parcelp &&
|
||||
"LocalID" == var_name_string &&
|
||||
(
|
||||
"ParcelData" == block_name_string
|
||||
|| message.find("Parcel") != message.npos
|
||||
)
|
||||
)
|
||||
{
|
||||
std::stringstream temp_stream;
|
||||
temp_stream << agent_parcelp->getLocalID();
|
||||
value = temp_stream.str();
|
||||
}
|
||||
else if("PCode" == var_name_string)
|
||||
value = "9";
|
||||
else if("PathCurve" == var_name_string)
|
||||
value = "16";
|
||||
else if("ProfileCurve" == var_name_string)
|
||||
value = "1";
|
||||
else if("PathScaleX" == var_name_string || "PathScaleY" == var_name_string)
|
||||
value = "100";
|
||||
else if("BypassRaycast" == var_name_string)
|
||||
value = "1";
|
||||
else
|
||||
value = "0";
|
||||
break;
|
||||
case MVT_F32:
|
||||
case MVT_F64:
|
||||
value = "0.0";
|
||||
break;
|
||||
case MVT_LLVector3:
|
||||
case MVT_LLVector3d:
|
||||
case MVT_LLQuaternion:
|
||||
if("Position" == var_name_string || "RayStart" == var_name_string || "RayEnd" == var_name_string)
|
||||
value = "$Position";
|
||||
else if("Scale" == var_name_string)
|
||||
value = "<0.5, 0.5, 0.5>";
|
||||
else
|
||||
value = "<0, 0, 0>";
|
||||
break;
|
||||
case MVT_LLVector4:
|
||||
value = "<0, 0, 0, 0>";
|
||||
break;
|
||||
case MVT_LLUUID:
|
||||
if("AgentID" == var_name_string)
|
||||
value = "$AgentID";
|
||||
else if("SessionID" == var_name_string)
|
||||
value = "$SessionID";
|
||||
else if("ObjectID" == var_name_string && selected_objectp)
|
||||
value = selected_objectp->getID().asString();
|
||||
else if("ParcelID" == var_name_string && agent_parcelp)
|
||||
value = agent_parcelp->getID().asString();
|
||||
else
|
||||
value = "00000000-0000-0000-0000-000000000000";
|
||||
break;
|
||||
case MVT_BOOL:
|
||||
value = "false";
|
||||
break;
|
||||
case MVT_VARIABLE:
|
||||
value = "Hello, world!";
|
||||
break;
|
||||
case MVT_FIXED:
|
||||
for(S32 si = 0; si < size; si++)
|
||||
//value.append(std::string("0123456789abcdef").substr(si & 0xf, 1));
|
||||
value.append("a");
|
||||
break;
|
||||
default:
|
||||
value = "";
|
||||
break;
|
||||
}
|
||||
text.append(llformat("%s\n", value.c_str()));
|
||||
}
|
||||
}
|
||||
}
|
||||
text = text.substr(0, text.length() - 1);
|
||||
floaterp->childSetText("message_edit", text);
|
||||
}
|
||||
// static
|
||||
void LLFloaterMessageBuilder::onClickSend(void* user_data)
|
||||
{
|
||||
LLFloaterMessageBuilder* floaterp = (LLFloaterMessageBuilder*)user_data;
|
||||
std::vector<std::string> lines = split(floaterp->childGetText("message_edit"), "\n");
|
||||
if(!lines.size())
|
||||
{
|
||||
LLFloaterChat::addChat(LLChat("Not enough information :O"));
|
||||
return;
|
||||
}
|
||||
std::vector<std::string> tokens = split(lines[0], " ");
|
||||
if(!tokens.size())
|
||||
{
|
||||
LLFloaterChat::addChat(LLChat("Not enough information :O"));
|
||||
return;
|
||||
}
|
||||
std::string dir_str = tokens[0];
|
||||
LLStringUtil::toLower(dir_str);
|
||||
// Direction
|
||||
BOOL outgoing;
|
||||
if(dir_str == "out")
|
||||
outgoing = TRUE;
|
||||
else if(dir_str == "in")
|
||||
outgoing = FALSE;
|
||||
else
|
||||
{
|
||||
LLFloaterChat::addChat(LLChat("Expected direction 'in' or 'out'"));
|
||||
return;
|
||||
}
|
||||
// Message
|
||||
std::string message = "Invalid";
|
||||
if(tokens.size() > 1)
|
||||
{
|
||||
if(tokens.size() > 2)
|
||||
{
|
||||
LLFloaterChat::addChat(LLChat("Unexpected extra stuff at the top"));
|
||||
return;
|
||||
}
|
||||
message = tokens[1];
|
||||
LLStringUtil::trim(message);
|
||||
}
|
||||
// Body
|
||||
std::vector<parts_block> parts;
|
||||
if(lines.size() > 1)
|
||||
{
|
||||
std::vector<std::string>::iterator line_end = lines.end();
|
||||
std::vector<std::string>::iterator line_iter = lines.begin();
|
||||
++line_iter;
|
||||
std::string current_block("");
|
||||
int current_block_index = -1;
|
||||
for( ; line_iter != line_end; ++line_iter)
|
||||
{
|
||||
std::string line = (*line_iter);
|
||||
LLStringUtil::trim(line);
|
||||
if(!line.length())
|
||||
continue;
|
||||
if(line.substr(0, 1) == "[" && line.substr(line.size() - 1, 1) == "]")
|
||||
{
|
||||
current_block = line.substr(1, line.length() - 2);
|
||||
LLStringUtil::trim(current_block);
|
||||
++current_block_index;
|
||||
parts_block pb;
|
||||
pb.name = current_block;
|
||||
parts.push_back(pb);
|
||||
}
|
||||
else
|
||||
{
|
||||
if(current_block.empty())
|
||||
{
|
||||
LLFloaterChat::addChat(LLChat("Unexpected field when no block yet"));
|
||||
return;
|
||||
}
|
||||
int eqpos = line.find("=");
|
||||
if(eqpos == line.npos)
|
||||
{
|
||||
LLFloaterChat::addChat(LLChat("Missing an equal sign"));
|
||||
return;
|
||||
}
|
||||
std::string field = line.substr(0, eqpos);
|
||||
LLStringUtil::trim(field);
|
||||
if(!field.length())
|
||||
{
|
||||
LLFloaterChat::addChat(LLChat("Missing name of field"));
|
||||
return;
|
||||
}
|
||||
std::string value = line.substr(eqpos + 1);
|
||||
LLStringUtil::trim(value);
|
||||
parts_var pv;
|
||||
if(value.substr(0, 1) == "|")
|
||||
{
|
||||
pv.hex = TRUE;
|
||||
value = value.substr(1);
|
||||
LLStringUtil::trim(value);
|
||||
}
|
||||
else
|
||||
pv.hex = FALSE;
|
||||
pv.name = field;
|
||||
pv.value = value;
|
||||
parts[current_block_index].vars.push_back(pv);
|
||||
}
|
||||
}
|
||||
}
|
||||
// Verification
|
||||
std::map<const char *, LLMessageTemplate*>::iterator template_iter;
|
||||
template_iter = gMessageSystem->mMessageTemplates.find( LLMessageStringTable::getInstance()->getString(message.c_str()) );
|
||||
if(template_iter == gMessageSystem->mMessageTemplates.end())
|
||||
{
|
||||
LLFloaterChat::addChat(LLChat(llformat("Don't know how to build a '%s' message", message.c_str())));
|
||||
return;
|
||||
}
|
||||
LLMessageTemplate* temp = (*template_iter).second;
|
||||
std::vector<parts_block>::iterator parts_end = parts.end();
|
||||
std::vector<parts_block>::iterator parts_iter = parts.begin();
|
||||
LLMessageTemplate::message_block_map_t::iterator blocks_end = temp->mMemberBlocks.end();
|
||||
for (LLMessageTemplate::message_block_map_t::iterator blocks_iter = temp->mMemberBlocks.begin();
|
||||
blocks_iter != blocks_end; )
|
||||
{
|
||||
LLMessageBlock* block = (*blocks_iter);
|
||||
const char* block_name = block->mName;
|
||||
if(parts_iter == parts_end)
|
||||
{
|
||||
if(block->mType != MBT_VARIABLE)
|
||||
LLFloaterChat::addChat(LLChat(llformat("Expected '%s' block", block_name)));
|
||||
else
|
||||
{
|
||||
++blocks_iter;
|
||||
continue;
|
||||
}
|
||||
return;
|
||||
}
|
||||
else if((*parts_iter).name != block_name)
|
||||
{
|
||||
if(block->mType != MBT_VARIABLE)
|
||||
LLFloaterChat::addChat(LLChat(llformat("Expected '%s' block", block_name)));
|
||||
else
|
||||
{
|
||||
++blocks_iter;
|
||||
continue;
|
||||
}
|
||||
return;
|
||||
}
|
||||
std::vector<parts_var>::iterator part_var_end = (*parts_iter).vars.end();
|
||||
std::vector<parts_var>::iterator part_var_iter = (*parts_iter).vars.begin();
|
||||
LLMessageBlock::message_variable_map_t::iterator var_end = block->mMemberVariables.end();
|
||||
for (LLMessageBlock::message_variable_map_t::iterator var_iter = block->mMemberVariables.begin();
|
||||
var_iter != var_end; ++var_iter)
|
||||
{
|
||||
LLMessageVariable* variable = (*var_iter);
|
||||
const char* var_name = variable->getName();
|
||||
if(part_var_iter == part_var_end)
|
||||
{
|
||||
LLFloaterChat::addChat(LLChat(llformat("Expected '%s' field under '%s' block", var_name, block_name)));
|
||||
return;
|
||||
}
|
||||
else if((*part_var_iter).name != var_name)
|
||||
{
|
||||
LLFloaterChat::addChat(LLChat(llformat("Expected '%s' field under '%s' block", var_name, block_name)));
|
||||
return;
|
||||
}
|
||||
(*part_var_iter).var_type = variable->getType();
|
||||
++part_var_iter;
|
||||
}
|
||||
if(part_var_iter != part_var_end)
|
||||
{
|
||||
LLFloaterChat::addChat(LLChat(llformat("Unexpected field(s) at end of '%s' block", block_name)));
|
||||
return;
|
||||
}
|
||||
++parts_iter;
|
||||
// test
|
||||
if((block->mType != MBT_SINGLE) && (parts_iter != parts_end) && ((*parts_iter).name == block_name))
|
||||
{
|
||||
// block will repeat
|
||||
}
|
||||
else ++blocks_iter;
|
||||
}
|
||||
if(parts_iter != parts_end)
|
||||
{
|
||||
LLFloaterChat::addChat(LLChat("Unexpected block(s) at end"));
|
||||
return;
|
||||
}
|
||||
// Build and send
|
||||
if(outgoing)
|
||||
{
|
||||
gMessageSystem->newMessage( message.c_str() );
|
||||
for(parts_iter = parts.begin(); parts_iter != parts_end; ++parts_iter)
|
||||
{
|
||||
const char* block_name = (*parts_iter).name.c_str();
|
||||
gMessageSystem->nextBlock(block_name);
|
||||
std::vector<parts_var>::iterator part_var_end = (*parts_iter).vars.end();
|
||||
for(std::vector<parts_var>::iterator part_var_iter = (*parts_iter).vars.begin();
|
||||
part_var_iter != part_var_end; ++part_var_iter)
|
||||
{
|
||||
parts_var pv = (*part_var_iter);
|
||||
if(!addField(pv.var_type, pv.name.c_str(), pv.value, pv.hex))
|
||||
{
|
||||
LLFloaterChat::addChat(LLChat(llformat("Error adding the provided data for %s '%s' to '%s' block", mvtstr(pv.var_type).c_str(), pv.name.c_str(), block_name)));
|
||||
gMessageSystem->clearMessage();
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
gMessageSystem->sendMessage(gAgent.getRegionHost());
|
||||
}
|
||||
else
|
||||
{
|
||||
LLFloaterChat::addChat(LLChat("Incoming message isn't supported yet :("));
|
||||
return;
|
||||
}
|
||||
}
|
||||
BOOL LLFloaterMessageBuilder::handleKeyHere(KEY key, MASK mask)
|
||||
{
|
||||
if(key == KEY_RETURN && (mask & MASK_CONTROL))
|
||||
{
|
||||
onClickSend(this);
|
||||
return TRUE;
|
||||
}
|
||||
if(key == KEY_ESCAPE)
|
||||
{
|
||||
releaseFocus();
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
// </edit>
|
||||
32
indra/newview/llfloatermessagebuilder.h
Normal file
32
indra/newview/llfloatermessagebuilder.h
Normal file
@@ -0,0 +1,32 @@
|
||||
// <edit>]
|
||||
#ifndef LL_LLFLOATERMESSAGEBUILDER_H
|
||||
#define LL_LLFLOATERMESSAGEBUILDER_H
|
||||
#include "llfloater.h"
|
||||
class LLFloaterMessageBuilder : public LLFloater
|
||||
{
|
||||
public:
|
||||
LLFloaterMessageBuilder(std::string initial_text);
|
||||
~LLFloaterMessageBuilder();
|
||||
static void show(std::string initial_text);
|
||||
BOOL postBuild();
|
||||
static BOOL addField(e_message_variable_type var_type, const char* var_name, std::string input, BOOL hex);
|
||||
static void onClickSend(void* user_data);
|
||||
static void onCommitPacketCombo(LLUICtrl* ctrl, void* user_data);
|
||||
static LLFloaterMessageBuilder* sInstance;
|
||||
BOOL handleKeyHere(KEY key, MASK mask);
|
||||
std::string mInitialText;
|
||||
struct parts_var
|
||||
{
|
||||
std::string name;
|
||||
std::string value;
|
||||
BOOL hex;
|
||||
e_message_variable_type var_type;
|
||||
};
|
||||
struct parts_block
|
||||
{
|
||||
std::string name;
|
||||
std::vector<parts_var> vars;
|
||||
};
|
||||
};
|
||||
#endif
|
||||
// </edit>
|
||||
940
indra/newview/llfloatermessagelog.cpp
Normal file
940
indra/newview/llfloatermessagelog.cpp
Normal file
@@ -0,0 +1,940 @@
|
||||
// <edit>
|
||||
#include "llviewerprecompiledheaders.h"
|
||||
#include "llfloatermessagelog.h"
|
||||
#include "lluictrlfactory.h"
|
||||
#include "llworld.h"
|
||||
#include "llviewerregion.h"
|
||||
#include "llscrolllistctrl.h"
|
||||
#include "lltexteditor.h"
|
||||
#include "llviewerwindow.h" // alertXml
|
||||
#include "llmessagetemplate.h"
|
||||
#include <boost/tokenizer.hpp>
|
||||
#include "llmenugl.h"
|
||||
#include "llfloatermessagebuilder.h"
|
||||
#include "llagent.h"
|
||||
////////////////////////////////
|
||||
// LLNetListItem
|
||||
////////////////////////////////
|
||||
LLNetListItem::LLNetListItem(LLUUID id)
|
||||
: mID(id),
|
||||
mAutoName(TRUE),
|
||||
mName("No name"),
|
||||
mPreviousRegionName(""),
|
||||
mCircuitData(NULL)
|
||||
{
|
||||
}
|
||||
////////////////////////////////
|
||||
// LLFloaterMessageLogItem
|
||||
////////////////////////////////
|
||||
U8 LLFloaterMessageLogItem::sDecodeBuffer[8192];
|
||||
LLTemplateMessageReader* LLFloaterMessageLogItem::sTemplateMessageReader = NULL;
|
||||
LLFloaterMessageLogItem::LLFloaterMessageLogItem(LLMessageLogEntry entry)
|
||||
: LLMessageLogEntry(entry.mType, entry.mFromHost, entry.mToHost, entry.mData, entry.mDataSize)
|
||||
{
|
||||
if(!sTemplateMessageReader)
|
||||
{
|
||||
sTemplateMessageReader = new LLTemplateMessageReader(gMessageSystem->mMessageNumbers);
|
||||
}
|
||||
mID.generate();
|
||||
mSequenceID = 0;
|
||||
if(mType == TEMPLATE)
|
||||
{
|
||||
BOOL decode_invalid = FALSE;
|
||||
S32 decode_len = mDataSize;
|
||||
memcpy(sDecodeBuffer, mData, decode_len);
|
||||
mFlags = sDecodeBuffer[0];
|
||||
U8* decodep = &(sDecodeBuffer[0]);
|
||||
gMessageSystem->zeroCodeExpand(&decodep, &decode_len);
|
||||
if(decode_len < 7)
|
||||
decode_invalid = TRUE;
|
||||
else
|
||||
{
|
||||
mSequenceID = ntohl(*((U32*)(&decodep[1])));
|
||||
sTemplateMessageReader->clearMessage();
|
||||
if(!sTemplateMessageReader->validateMessage(decodep, decode_len, mFromHost, TRUE))
|
||||
decode_invalid = TRUE;
|
||||
else
|
||||
{
|
||||
if(!sTemplateMessageReader->decodeData(decodep, mFromHost, TRUE))
|
||||
decode_invalid = TRUE;
|
||||
else
|
||||
{
|
||||
LLMessageTemplate* temp = sTemplateMessageReader->getTemplate();
|
||||
mName = temp->mName;
|
||||
mSummary = "";
|
||||
|
||||
if(mFlags)
|
||||
{
|
||||
mSummary.append(" [ ");
|
||||
if(mFlags & LL_ZERO_CODE_FLAG)
|
||||
mSummary.append(" Zer ");
|
||||
if(mFlags & LL_RELIABLE_FLAG)
|
||||
mSummary.append(" Rel ");
|
||||
if(mFlags & LL_RESENT_FLAG)
|
||||
mSummary.append(" Rsd ");
|
||||
if(mFlags & LL_ACK_FLAG)
|
||||
mSummary.append(" Ack ");
|
||||
mSummary.append(" ] ");
|
||||
}
|
||||
|
||||
LLMessageTemplate::message_block_map_t::iterator blocks_end = temp->mMemberBlocks.end();
|
||||
for (LLMessageTemplate::message_block_map_t::iterator blocks_iter = temp->mMemberBlocks.begin();
|
||||
blocks_iter != blocks_end; ++blocks_iter)
|
||||
{
|
||||
LLMessageBlock* block = (*blocks_iter);
|
||||
const char* block_name = block->mName;
|
||||
S32 num_blocks = sTemplateMessageReader->getNumberOfBlocks(block_name);
|
||||
if(!num_blocks)
|
||||
mSummary.append(" { } ");
|
||||
else if(num_blocks > 1)
|
||||
mSummary.append(llformat(" %s [ %d ] { ... } ", block_name, num_blocks));
|
||||
else for(S32 i = 0; i < 1; i++)
|
||||
{
|
||||
mSummary.append(" { ");
|
||||
LLMessageBlock::message_variable_map_t::iterator var_end = block->mMemberVariables.end();
|
||||
for (LLMessageBlock::message_variable_map_t::iterator var_iter = block->mMemberVariables.begin();
|
||||
var_iter != var_end; ++var_iter)
|
||||
{
|
||||
LLMessageVariable* variable = (*var_iter);
|
||||
const char* var_name = variable->getName();
|
||||
BOOL returned_hex;
|
||||
std::string value = getString(sTemplateMessageReader, block_name, i, var_name, variable->getType(), returned_hex, TRUE);
|
||||
mSummary.append(llformat(" %s=%s ", var_name, value.c_str()));
|
||||
}
|
||||
mSummary.append(" } ");
|
||||
if(mSummary.length() > 255) break;
|
||||
}
|
||||
if(mSummary.length() > 255)
|
||||
{
|
||||
mSummary.append(" ... ");
|
||||
break;
|
||||
}
|
||||
} // blocks_iter
|
||||
} // decode_valid
|
||||
}
|
||||
}
|
||||
if(decode_invalid)
|
||||
{
|
||||
mName = "Invalid";
|
||||
mSummary = "";
|
||||
for(S32 i = 0; i < mDataSize; i++)
|
||||
mSummary.append(llformat("%02X ", mData[i]));
|
||||
}
|
||||
}
|
||||
else // not template
|
||||
{
|
||||
mName = "SOMETHING ELSE";
|
||||
mSummary = "TODO: SOMETHING ELSE";
|
||||
}
|
||||
}
|
||||
LLFloaterMessageLogItem::~LLFloaterMessageLogItem()
|
||||
{
|
||||
}
|
||||
BOOL LLFloaterMessageLogItem::isOutgoing()
|
||||
{
|
||||
LLHost local_host = LLHost(16777343, gMessageSystem->getListenPort());
|
||||
return mFromHost == local_host;
|
||||
}
|
||||
std::string LLFloaterMessageLogItem::getFull(BOOL show_header)
|
||||
{
|
||||
std::string full("");
|
||||
if(mType == TEMPLATE)
|
||||
{
|
||||
BOOL decode_invalid = FALSE;
|
||||
S32 decode_len = mDataSize;
|
||||
memcpy(sDecodeBuffer, mData, decode_len);
|
||||
U8* decodep = &(sDecodeBuffer[0]);
|
||||
gMessageSystem->zeroCodeExpand(&decodep, &decode_len);
|
||||
if(decode_len < 7)
|
||||
decode_invalid = TRUE;
|
||||
else
|
||||
{
|
||||
sTemplateMessageReader->clearMessage();
|
||||
if(!sTemplateMessageReader->validateMessage(decodep, decode_len, mFromHost, TRUE))
|
||||
decode_invalid = TRUE;
|
||||
else
|
||||
{
|
||||
if(!sTemplateMessageReader->decodeData(decodep, mFromHost, TRUE))
|
||||
decode_invalid = TRUE;
|
||||
else
|
||||
{
|
||||
LLMessageTemplate* temp = sTemplateMessageReader->getTemplate();
|
||||
full.append(isOutgoing() ? "out " : "in ");
|
||||
full.append(llformat("%s\n", temp->mName));
|
||||
if(show_header)
|
||||
{
|
||||
full.append("[Header]\n");
|
||||
full.append(llformat("SequenceID = %u\n", mSequenceID));
|
||||
full.append(llformat("LL_ZERO_CODE_FLAG = %s\n", (mFlags & LL_ZERO_CODE_FLAG) ? "True" : "False"));
|
||||
full.append(llformat("LL_RELIABLE_FLAG = %s\n", (mFlags & LL_RELIABLE_FLAG) ? "True" : "False"));
|
||||
full.append(llformat("LL_RESENT_FLAG = %s\n", (mFlags & LL_RESENT_FLAG) ? "True" : "False"));
|
||||
full.append(llformat("LL_ACK_FLAG = %s\n", (mFlags & LL_ACK_FLAG) ? "True" : "False"));
|
||||
}
|
||||
LLMessageTemplate::message_block_map_t::iterator blocks_end = temp->mMemberBlocks.end();
|
||||
for (LLMessageTemplate::message_block_map_t::iterator blocks_iter = temp->mMemberBlocks.begin();
|
||||
blocks_iter != blocks_end; ++blocks_iter)
|
||||
{
|
||||
LLMessageBlock* block = (*blocks_iter);
|
||||
const char* block_name = block->mName;
|
||||
S32 num_blocks = sTemplateMessageReader->getNumberOfBlocks(block_name);
|
||||
for(S32 i = 0; i < num_blocks; i++)
|
||||
{
|
||||
full.append(llformat("[%s]\n", block->mName));
|
||||
LLMessageBlock::message_variable_map_t::iterator var_end = block->mMemberVariables.end();
|
||||
for (LLMessageBlock::message_variable_map_t::iterator var_iter = block->mMemberVariables.begin();
|
||||
var_iter != var_end; ++var_iter)
|
||||
{
|
||||
LLMessageVariable* variable = (*var_iter);
|
||||
const char* var_name = variable->getName();
|
||||
BOOL returned_hex;
|
||||
std::string value = getString(sTemplateMessageReader, block_name, i, var_name, variable->getType(), returned_hex);
|
||||
if(returned_hex)
|
||||
full.append(llformat("%s =| ", var_name));
|
||||
else
|
||||
full.append(llformat("%s = ", var_name));
|
||||
// llformat has a 1024 char limit!?
|
||||
full.append(value);
|
||||
full.append("\n");
|
||||
}
|
||||
}
|
||||
} // blocks_iter
|
||||
} // decode_valid
|
||||
}
|
||||
}
|
||||
if(decode_invalid)
|
||||
{
|
||||
full = isOutgoing() ? "out" : "in";
|
||||
full.append("\n");
|
||||
for(S32 i = 0; i < mDataSize; i++)
|
||||
full.append(llformat("%02X ", mData[i]));
|
||||
}
|
||||
}
|
||||
else // not template
|
||||
{
|
||||
full = "FIXME";
|
||||
}
|
||||
return full;
|
||||
}
|
||||
// static
|
||||
std::string LLFloaterMessageLogItem::getString(LLTemplateMessageReader* readerp, const char* block_name, S32 block_num, const char* var_name, e_message_variable_type var_type, BOOL &returned_hex, BOOL summary_mode)
|
||||
{
|
||||
returned_hex = FALSE;
|
||||
std::stringstream stream;
|
||||
char* value;
|
||||
U32 valueU32;
|
||||
U16 valueU16;
|
||||
LLVector3 valueVector3;
|
||||
LLVector3d valueVector3d;
|
||||
LLVector4 valueVector4;
|
||||
LLQuaternion valueQuaternion;
|
||||
LLUUID valueLLUUID;
|
||||
switch(var_type)
|
||||
{
|
||||
case MVT_U8:
|
||||
U8 valueU8;
|
||||
readerp->getU8(block_name, var_name, valueU8, block_num);
|
||||
stream << U32(valueU8);
|
||||
break;
|
||||
case MVT_U16:
|
||||
readerp->getU16(block_name, var_name, valueU16, block_num);
|
||||
stream << valueU16;
|
||||
break;
|
||||
case MVT_U32:
|
||||
readerp->getU32(block_name, var_name, valueU32, block_num);
|
||||
stream << valueU32;
|
||||
break;
|
||||
case MVT_U64:
|
||||
U64 valueU64;
|
||||
readerp->getU64(block_name, var_name, valueU64, block_num);
|
||||
stream << valueU64;
|
||||
break;
|
||||
case MVT_S8:
|
||||
S8 valueS8;
|
||||
readerp->getS8(block_name, var_name, valueS8, block_num);
|
||||
stream << S32(valueS8);
|
||||
break;
|
||||
case MVT_S16:
|
||||
S16 valueS16;
|
||||
readerp->getS16(block_name, var_name, valueS16, block_num);
|
||||
stream << valueS16;
|
||||
break;
|
||||
case MVT_S32:
|
||||
S32 valueS32;
|
||||
readerp->getS32(block_name, var_name, valueS32, block_num);
|
||||
stream << valueS32;
|
||||
break;
|
||||
/*
|
||||
case MVT_S64:
|
||||
S64 valueS64;
|
||||
readerp->getS64(block_name, var_name, valueS64, block_num);
|
||||
stream << valueS64;
|
||||
break;
|
||||
*/
|
||||
case MVT_F32:
|
||||
F32 valueF32;
|
||||
readerp->getF32(block_name, var_name, valueF32, block_num);
|
||||
stream << valueF32;
|
||||
break;
|
||||
case MVT_F64:
|
||||
F64 valueF64;
|
||||
readerp->getF64(block_name, var_name, valueF64, block_num);
|
||||
stream << valueF64;
|
||||
break;
|
||||
case MVT_LLVector3:
|
||||
readerp->getVector3(block_name, var_name, valueVector3, block_num);
|
||||
//stream << valueVector3;
|
||||
stream << "<" << valueVector3.mV[0] << ", " << valueVector3.mV[1] << ", " << valueVector3.mV[2] << ">";
|
||||
break;
|
||||
case MVT_LLVector3d:
|
||||
readerp->getVector3d(block_name, var_name, valueVector3d, block_num);
|
||||
//stream << valueVector3d;
|
||||
stream << "<" << valueVector3d.mdV[0] << ", " << valueVector3d.mdV[1] << ", " << valueVector3d.mdV[2] << ">";
|
||||
break;
|
||||
case MVT_LLVector4:
|
||||
readerp->getVector4(block_name, var_name, valueVector4, block_num);
|
||||
//stream << valueVector4;
|
||||
stream << "<" << valueVector4.mV[0] << ", " << valueVector4.mV[1] << ", " << valueVector4.mV[2] << ", " << valueVector4.mV[3] << ">";
|
||||
break;
|
||||
case MVT_LLQuaternion:
|
||||
readerp->getQuat(block_name, var_name, valueQuaternion, block_num);
|
||||
//stream << valueQuaternion;
|
||||
stream << "<" << valueQuaternion.mQ[0] << ", " << valueQuaternion.mQ[1] << ", " << valueQuaternion.mQ[2] << ", " << valueQuaternion.mQ[3] << ">";
|
||||
break;
|
||||
case MVT_LLUUID:
|
||||
readerp->getUUID(block_name, var_name, valueLLUUID, block_num);
|
||||
stream << valueLLUUID;
|
||||
break;
|
||||
case MVT_BOOL:
|
||||
BOOL valueBOOL;
|
||||
readerp->getBOOL(block_name, var_name, valueBOOL, block_num);
|
||||
stream << valueBOOL;
|
||||
break;
|
||||
case MVT_IP_ADDR:
|
||||
readerp->getIPAddr(block_name, var_name, valueU32, block_num);
|
||||
stream << LLHost(valueU32, 0).getIPString();
|
||||
break;
|
||||
case MVT_IP_PORT:
|
||||
readerp->getIPPort(block_name, var_name, valueU16, block_num);
|
||||
stream << valueU16;
|
||||
case MVT_VARIABLE:
|
||||
case MVT_FIXED:
|
||||
default:
|
||||
S32 size = readerp->getSize(block_name, block_num, var_name);
|
||||
if(size)
|
||||
{
|
||||
value = new char[size + 1];
|
||||
readerp->getBinaryData(block_name, var_name, value, size, block_num);
|
||||
value[size] = '\0';
|
||||
S32 readable = 0;
|
||||
S32 unreadable = 0;
|
||||
S32 end = (summary_mode && (size > 64)) ? 64 : size;
|
||||
for(S32 i = 0; i < end; i++)
|
||||
{
|
||||
if(!value[i])
|
||||
{
|
||||
if(i != (end - 1))
|
||||
{ // don't want null terminator hiding data
|
||||
unreadable = S32_MAX;
|
||||
break;
|
||||
}
|
||||
}
|
||||
else if(value[i] < 0x20 || value[i] >= 0x7F)
|
||||
{
|
||||
if(summary_mode)
|
||||
unreadable++;
|
||||
else
|
||||
{ // never want any wrong characters outside of summary mode
|
||||
unreadable = S32_MAX;
|
||||
break;
|
||||
}
|
||||
}
|
||||
else readable++;
|
||||
}
|
||||
if(readable >= unreadable)
|
||||
{
|
||||
if(summary_mode && (size > 64))
|
||||
{
|
||||
for(S32 i = 60; i < 63; i++)
|
||||
value[i] = '.';
|
||||
value[63] = '\0';
|
||||
}
|
||||
stream << value;
|
||||
}
|
||||
else
|
||||
{
|
||||
returned_hex = TRUE;
|
||||
S32 end = (summary_mode && (size > 8)) ? 8 : size;
|
||||
for(S32 i = 0; i < end; i++)
|
||||
//stream << std::uppercase << std::hex << U32(value[i]) << " ";
|
||||
stream << llformat("%02X ", (U8)value[i]);
|
||||
if(summary_mode && (size > 8))
|
||||
stream << " ... ";
|
||||
}
|
||||
}
|
||||
break;
|
||||
}
|
||||
return stream.str();
|
||||
}
|
||||
LLMessageLogFilter::LLMessageLogFilter()
|
||||
{
|
||||
}
|
||||
LLMessageLogFilter::~LLMessageLogFilter()
|
||||
{
|
||||
}
|
||||
BOOL LLMessageLogFilter::set(std::string filter)
|
||||
{
|
||||
mPositiveNames.clear();
|
||||
mNegativeNames.clear();
|
||||
typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
|
||||
boost::char_separator<char> sep(" ","",boost::keep_empty_tokens);
|
||||
boost::tokenizer<boost::char_separator<char> > tokens(filter, sep);
|
||||
boost::tokenizer<boost::char_separator<char> >::iterator end = tokens.end();
|
||||
for(boost::tokenizer<boost::char_separator<char> >::iterator iter = tokens.begin(); iter != end; ++iter)
|
||||
{
|
||||
std::string token = (*iter);
|
||||
LLStringUtil::trim(token);
|
||||
LLStringUtil::toLower(token);
|
||||
BOOL negative = token.find("!") == 0;
|
||||
if(negative)
|
||||
{
|
||||
token = token.substr(1);
|
||||
mNegativeNames.push_back(token);
|
||||
}
|
||||
else
|
||||
mPositiveNames.push_back(token);
|
||||
}
|
||||
return TRUE;
|
||||
}
|
||||
////////////////////////////////
|
||||
// LLMessageLogFilterApply
|
||||
////////////////////////////////
|
||||
LLMessageLogFilterApply::LLMessageLogFilterApply()
|
||||
: LLEventTimer(0.1f),
|
||||
mFinished(FALSE),
|
||||
mProgress(0)
|
||||
{
|
||||
mIter = LLFloaterMessageLog::sMessageLogEntries.begin();
|
||||
}
|
||||
void LLMessageLogFilterApply::cancel()
|
||||
{
|
||||
mFinished = TRUE;
|
||||
}
|
||||
BOOL LLMessageLogFilterApply::tick()
|
||||
{
|
||||
std::deque<LLMessageLogEntry>::iterator end = LLFloaterMessageLog::sMessageLogEntries.end();
|
||||
if(mIter == end || !LLFloaterMessageLog::sInstance)
|
||||
mFinished = TRUE;
|
||||
if(mFinished)
|
||||
{
|
||||
if(LLFloaterMessageLog::sInstance)
|
||||
if(LLFloaterMessageLog::sInstance->mMessageLogFilterApply == this)
|
||||
LLFloaterMessageLog::sInstance->stopApplyingFilter();
|
||||
return TRUE;
|
||||
}
|
||||
for(S32 i = 0; i < 256; i++)
|
||||
{
|
||||
if(mIter == end)
|
||||
{
|
||||
mFinished = TRUE;
|
||||
if(LLFloaterMessageLog::sInstance)
|
||||
if(LLFloaterMessageLog::sInstance->mMessageLogFilterApply == this)
|
||||
LLFloaterMessageLog::sInstance->stopApplyingFilter();
|
||||
return TRUE;
|
||||
}
|
||||
LLFloaterMessageLog::sInstance->conditionalLog(LLFloaterMessageLogItem((*mIter)));
|
||||
mIter++;
|
||||
mProgress++;
|
||||
}
|
||||
LLFloaterMessageLog::sInstance->updateFilterStatus();
|
||||
return FALSE;
|
||||
}
|
||||
////////////////////////////////
|
||||
// LLFloaterMessageLog
|
||||
////////////////////////////////
|
||||
LLFloaterMessageLog* LLFloaterMessageLog::sInstance;
|
||||
std::list<LLNetListItem*> LLFloaterMessageLog::sNetListItems;
|
||||
std::deque<LLMessageLogEntry> LLFloaterMessageLog::sMessageLogEntries;
|
||||
std::vector<LLFloaterMessageLogItem> LLFloaterMessageLog::sFloaterMessageLogItems;
|
||||
LLMessageLogFilter LLFloaterMessageLog::sMessageLogFilter = LLMessageLogFilter();
|
||||
std::string LLFloaterMessageLog::sMessageLogFilterString("!StartPingCheck !CompletePingCheck !PacketAck !SimulatorViewerTimeMessage !SimStats !AgentUpdate !AgentAnimation !AvatarAnimation !ViewerEffect !CoarseLocationUpdate !LayerData !CameraConstraint !ObjectUpdateCached !RequestMultipleObjects !ObjectUpdate !ObjectUpdateCompressed !ImprovedTerseObjectUpdate !KillObject !ImagePacket !SendXferPacket !ConfirmXferPacket !TransferPacket");
|
||||
BOOL LLFloaterMessageLog::sBusyApplyingFilter = FALSE;
|
||||
LLFloaterMessageLog::LLFloaterMessageLog()
|
||||
: LLFloater(),
|
||||
LLEventTimer(1.0f),
|
||||
mNetInfoMode(NI_NET),
|
||||
mMessageLogFilterApply(NULL)
|
||||
{
|
||||
sInstance = this;
|
||||
LLMessageLog::setCallback(onLog);
|
||||
sMessageLogEntries = LLMessageLog::getDeque();
|
||||
LLUICtrlFactory::getInstance()->buildFloater(this, "floater_message_log.xml");
|
||||
}
|
||||
LLFloaterMessageLog::~LLFloaterMessageLog()
|
||||
{
|
||||
LLMessageLog::setCallback(NULL);
|
||||
stopApplyingFilter();
|
||||
sInstance = NULL;
|
||||
sNetListItems.clear();
|
||||
sMessageLogEntries.clear();
|
||||
sFloaterMessageLogItems.clear();
|
||||
}
|
||||
// static
|
||||
void LLFloaterMessageLog::show()
|
||||
{
|
||||
if(!sInstance) sInstance = new LLFloaterMessageLog();
|
||||
sInstance->open();
|
||||
}
|
||||
BOOL LLFloaterMessageLog::postBuild()
|
||||
{
|
||||
childSetCommitCallback("net_list", onCommitNetList, this);
|
||||
childSetCommitCallback("message_log", onCommitMessageLog, this);
|
||||
childSetAction("filter_choice_btn", onClickFilterChoice, this);
|
||||
childSetAction("filter_apply_btn", onClickFilterApply, this);
|
||||
childSetCommitCallback("filter_edit", onCommitFilter, this);
|
||||
childSetAction("clear_log_btn", onClickClearLog, this);
|
||||
childSetAction("send_to_message_builder_btn", onClickSendToMessageBuilder, this);
|
||||
childSetText("filter_edit", sMessageLogFilterString);
|
||||
refreshNetList();
|
||||
refreshNetInfo(TRUE);
|
||||
startApplyingFilter(sMessageLogFilterString, TRUE);
|
||||
return TRUE;
|
||||
}
|
||||
BOOL LLFloaterMessageLog::tick()
|
||||
{
|
||||
refreshNetList();
|
||||
refreshNetInfo(FALSE);
|
||||
return FALSE;
|
||||
}
|
||||
LLNetListItem* LLFloaterMessageLog::findNetListItem(LLHost host)
|
||||
{
|
||||
std::list<LLNetListItem*>::iterator end = sNetListItems.end();
|
||||
for(std::list<LLNetListItem*>::iterator iter = sNetListItems.begin(); iter != end; ++iter)
|
||||
if((*iter)->mCircuitData && (*iter)->mCircuitData->getHost() == host)
|
||||
return (*iter);
|
||||
return NULL;
|
||||
}
|
||||
LLNetListItem* LLFloaterMessageLog::findNetListItem(LLUUID id)
|
||||
{
|
||||
std::list<LLNetListItem*>::iterator end = sNetListItems.end();
|
||||
for(std::list<LLNetListItem*>::iterator iter = sNetListItems.begin(); iter != end; ++iter)
|
||||
if((*iter)->mID == id)
|
||||
return (*iter);
|
||||
return NULL;
|
||||
}
|
||||
void LLFloaterMessageLog::refreshNetList()
|
||||
{
|
||||
LLScrollListCtrl* scrollp = getChild<LLScrollListCtrl>("net_list");
|
||||
// Update circuit data of net list items
|
||||
std::vector<LLCircuitData*> circuits = gMessageSystem->getCircuit()->getCircuitDataList();
|
||||
std::vector<LLCircuitData*>::iterator circuits_end = circuits.end();
|
||||
for(std::vector<LLCircuitData*>::iterator iter = circuits.begin(); iter != circuits_end; ++iter)
|
||||
{
|
||||
LLNetListItem* itemp = findNetListItem((*iter)->getHost());
|
||||
if(!itemp)
|
||||
{
|
||||
LLUUID id; id.generate();
|
||||
itemp = new LLNetListItem(id);
|
||||
sNetListItems.push_back(itemp);
|
||||
}
|
||||
itemp->mCircuitData = (*iter);
|
||||
}
|
||||
// Clear circuit data of items whose circuits are gone
|
||||
std::list<LLNetListItem*>::iterator items_end = sNetListItems.end();
|
||||
for(std::list<LLNetListItem*>::iterator iter = sNetListItems.begin(); iter != items_end; ++iter)
|
||||
{
|
||||
if(std::find(circuits.begin(), circuits.end(), (*iter)->mCircuitData) == circuits.end())
|
||||
(*iter)->mCircuitData = NULL;
|
||||
}
|
||||
// Remove net list items that are totally useless now
|
||||
for(std::list<LLNetListItem*>::iterator iter = sNetListItems.begin(); iter != sNetListItems.end();)
|
||||
{
|
||||
if((*iter)->mCircuitData == NULL)
|
||||
iter = sNetListItems.erase(iter);
|
||||
else ++iter;
|
||||
}
|
||||
// Update names of net list items
|
||||
items_end = sNetListItems.end();
|
||||
for(std::list<LLNetListItem*>::iterator iter = sNetListItems.begin(); iter != items_end; ++iter)
|
||||
{
|
||||
LLNetListItem* itemp = (*iter);
|
||||
if(itemp->mAutoName)
|
||||
{
|
||||
if(itemp->mCircuitData)
|
||||
{
|
||||
LLViewerRegion* regionp = LLWorld::getInstance()->getRegion(itemp->mCircuitData->getHost());
|
||||
if(regionp)
|
||||
{
|
||||
std::string name = regionp->getName();
|
||||
if(name == "") name = llformat("%s (awaiting region name)", itemp->mCircuitData->getHost().getString().c_str());
|
||||
itemp->mName = name;
|
||||
itemp->mPreviousRegionName = name;
|
||||
}
|
||||
else
|
||||
{
|
||||
itemp->mName = itemp->mCircuitData->getHost().getString();
|
||||
if(itemp->mPreviousRegionName != "")
|
||||
itemp->mName.append(llformat(" (was %s)", itemp->mPreviousRegionName.c_str()));
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// an item just for an event queue, not handled yet
|
||||
itemp->mName = "Something else";
|
||||
}
|
||||
}
|
||||
}
|
||||
// Rebuild scroll list from scratch
|
||||
LLUUID selected_id = scrollp->getFirstSelected() ? scrollp->getFirstSelected()->getUUID() : LLUUID::null;
|
||||
S32 scroll_pos = scrollp->getScrollPos();
|
||||
scrollp->clearRows();
|
||||
for(std::list<LLNetListItem*>::iterator iter = sNetListItems.begin(); iter != items_end; ++iter)
|
||||
{
|
||||
LLNetListItem* itemp = (*iter);
|
||||
LLSD element;
|
||||
element["id"] = itemp->mID;
|
||||
LLSD& text_column = element["columns"][0];
|
||||
text_column["column"] = "text";
|
||||
text_column["value"] = itemp->mName + (itemp->mCircuitData->getHost() == gAgent.getRegionHost() ? " (main)" : "");
|
||||
for(int i = 0; i < 3; i++)
|
||||
{
|
||||
LLSD& icon_column = element["columns"][i + 1];
|
||||
icon_column["column"] = llformat("icon%d", i);
|
||||
icon_column["type"] = "icon";
|
||||
icon_column["value"] = "";
|
||||
}
|
||||
LLScrollListItem* scroll_itemp = scrollp->addElement(element);
|
||||
BOOL has_live_circuit = itemp->mCircuitData && itemp->mCircuitData->isAlive();
|
||||
if(has_live_circuit)
|
||||
{
|
||||
LLScrollListIcon* icon = (LLScrollListIcon*)scroll_itemp->getColumn(2);
|
||||
icon->setValue("icon_net_close_circuit.tga");
|
||||
icon->setClickCallback(onClickCloseCircuit, itemp);
|
||||
}
|
||||
else
|
||||
{
|
||||
LLScrollListIcon* icon = (LLScrollListIcon*)scroll_itemp->getColumn(2);
|
||||
icon->setValue("icon_net_close_circuit_gray.tga");
|
||||
icon->setClickCallback(NULL, NULL);
|
||||
}
|
||||
// Event queue isn't even supported yet... FIXME
|
||||
LLScrollListIcon* icon = (LLScrollListIcon*)scroll_itemp->getColumn(3);
|
||||
icon->setValue("icon_net_close_eventpoll_gray.tga");
|
||||
}
|
||||
if(selected_id.notNull()) scrollp->selectByID(selected_id);
|
||||
if(scroll_pos < scrollp->getItemCount()) scrollp->setScrollPos(scroll_pos);
|
||||
}
|
||||
void LLFloaterMessageLog::refreshNetInfo(BOOL force)
|
||||
{
|
||||
if(mNetInfoMode != NI_NET) return;
|
||||
LLScrollListCtrl* scrollp = getChild<LLScrollListCtrl>("net_list");
|
||||
LLScrollListItem* selected_itemp = scrollp->getFirstSelected();
|
||||
if(selected_itemp)
|
||||
{
|
||||
if(!force) if(getChild<LLTextEditor>("net_info")->hasSelection()) return;
|
||||
LLNetListItem* itemp = findNetListItem(selected_itemp->getUUID());
|
||||
if(itemp)
|
||||
{
|
||||
std::string info(llformat("%s\n--------------------------------\n\n", itemp->mName.c_str()));
|
||||
if(itemp->mCircuitData)
|
||||
{
|
||||
LLCircuitData* cdp = itemp->mCircuitData;
|
||||
info.append("Circuit\n--------------------------------\n");
|
||||
info.append(llformat(" * Host: %s\n", cdp->getHost().getString().c_str()));
|
||||
S32 seconds = (S32)cdp->getAgeInSeconds();
|
||||
S32 minutes = seconds / 60;
|
||||
seconds = seconds % 60;
|
||||
S32 hours = minutes / 60;
|
||||
minutes = minutes % 60;
|
||||
info.append(llformat(" * Age: %dh %dm %ds\n", hours, minutes, seconds));
|
||||
info.append(llformat(" * Alive: %s\n", cdp->isAlive() ? "yes" : "no"));
|
||||
info.append(llformat(" * Blocked: %s\n", cdp->isBlocked() ? "yes" : "no"));
|
||||
info.append(llformat(" * Allow timeout: %s\n", cdp->getAllowTimeout() ? "yes" : "no"));
|
||||
info.append(llformat(" * Trusted: %s\n", cdp->getTrusted() ? "yes" : "no"));
|
||||
info.append(llformat(" * Ping delay: %d\n", cdp->getPingDelay()));
|
||||
info.append(llformat(" * Packets out: %d\n", cdp->getPacketsOut()));
|
||||
info.append(llformat(" * Bytes out: %d\n", cdp->getBytesOut()));
|
||||
info.append(llformat(" * Packets in: %d\n", cdp->getPacketsIn()));
|
||||
info.append(llformat(" * Bytes in: %d\n", cdp->getBytesIn()));
|
||||
info.append(llformat(" * Endpoint ID: %s\n", cdp->getLocalEndPointID().asString().c_str()));
|
||||
info.append(llformat(" * Remote ID: %s\n", cdp->getRemoteID().asString().c_str()));
|
||||
info.append(llformat(" * Remote session ID: %s\n", cdp->getRemoteSessionID().asString().c_str()));
|
||||
}
|
||||
childSetText("net_info", info);
|
||||
}
|
||||
else childSetText("net_info", std::string(""));
|
||||
}
|
||||
else childSetText("net_info", std::string(""));
|
||||
}
|
||||
void LLFloaterMessageLog::setNetInfoMode(ENetInfoMode mode)
|
||||
{
|
||||
mNetInfoMode = mode;
|
||||
if(mNetInfoMode == NI_NET)
|
||||
refreshNetInfo(TRUE);
|
||||
childSetEnabled("send_to_message_builder_btn", mNetInfoMode == NI_LOG);
|
||||
}
|
||||
// static
|
||||
void LLFloaterMessageLog::onLog(LLMessageLogEntry entry)
|
||||
{
|
||||
sMessageLogEntries.push_back(entry);
|
||||
if(!sBusyApplyingFilter)
|
||||
conditionalLog(LLFloaterMessageLogItem(entry));
|
||||
}
|
||||
// static
|
||||
void LLFloaterMessageLog::conditionalLog(LLFloaterMessageLogItem item)
|
||||
{
|
||||
if(!sBusyApplyingFilter)
|
||||
sInstance->childSetText("log_status_text", llformat("Showing %d messages from %d", sFloaterMessageLogItems.size(), sMessageLogEntries.size()));
|
||||
std::string find_name = item.mName;
|
||||
LLStringUtil::toLower(find_name);
|
||||
if(sMessageLogFilter.mPositiveNames.size())
|
||||
if(std::find(sMessageLogFilter.mPositiveNames.begin(), sMessageLogFilter.mPositiveNames.end(), find_name) == sMessageLogFilter.mPositiveNames.end())
|
||||
return;
|
||||
if(std::find(sMessageLogFilter.mNegativeNames.begin(), sMessageLogFilter.mNegativeNames.end(), find_name) != sMessageLogFilter.mNegativeNames.end())
|
||||
return;
|
||||
sFloaterMessageLogItems.push_back(item); // moved from beginning...
|
||||
LLHost local_host = LLHost(16777343, gMessageSystem->getListenPort());
|
||||
BOOL outgoing = item.isOutgoing();
|
||||
std::string net_name("\?\?\?");
|
||||
if(item.mType == LLFloaterMessageLogItem::TEMPLATE)
|
||||
{
|
||||
LLHost find_host = outgoing ? item.mToHost : item.mFromHost;
|
||||
net_name = find_host.getIPandPort();
|
||||
std::list<LLNetListItem*>::iterator end = sNetListItems.end();
|
||||
for(std::list<LLNetListItem*>::iterator iter = sNetListItems.begin(); iter != end; ++iter)
|
||||
{
|
||||
if((*iter)->mCircuitData->getHost() == find_host)
|
||||
{
|
||||
net_name = (*iter)->mName;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
LLSD element;
|
||||
element["id"] = item.mID;
|
||||
LLSD& sequence_column = element["columns"][0];
|
||||
sequence_column["column"] = "sequence";
|
||||
sequence_column["value"] = llformat("%u", item.mSequenceID);
|
||||
LLSD& type_column = element["columns"][1];
|
||||
type_column["column"] = "type";
|
||||
type_column["value"] = item.mType == LLFloaterMessageLogItem::TEMPLATE ? "UDP" : "\?\?\?";
|
||||
LLSD& direction_column = element["columns"][2];
|
||||
direction_column["column"] = "direction";
|
||||
direction_column["value"] = outgoing ? "to" : "from";
|
||||
LLSD& net_column = element["columns"][3];
|
||||
net_column["column"] = "net";
|
||||
net_column["value"] = net_name;
|
||||
LLSD& name_column = element["columns"][4];
|
||||
name_column["column"] = "name";
|
||||
name_column["value"] = item.mName;
|
||||
/*
|
||||
LLSD& zer_column = element["columns"][5];
|
||||
zer_column["column"] = "flag_zer";
|
||||
zer_column["type"] = "icon";
|
||||
zer_column["value"] = (item.mFlags & LL_ZERO_CODE_FLAG) ? "flag_zer.tga" : "";
|
||||
LLSD& rel_column = element["columns"][6];
|
||||
rel_column["column"] = "flag_rel";
|
||||
rel_column["type"] = "icon";
|
||||
rel_column["value"] = (item.mFlags & LL_RELIABLE_FLAG) ? "flag_rel.tga" : "";
|
||||
LLSD& rsd_column = element["columns"][7];
|
||||
rsd_column["column"] = "flag_rsd";
|
||||
rsd_column["type"] = "icon";
|
||||
rsd_column["value"] = (item.mFlags & LL_RESENT_FLAG) ? "flag_rsd.tga" : "";
|
||||
LLSD& ack_column = element["columns"][8];
|
||||
ack_column["column"] = "flag_ack";
|
||||
ack_column["type"] = "icon";
|
||||
ack_column["value"] = (item.mFlags & LL_ACK_FLAG) ? "flag_ack.tga" : "";
|
||||
*/
|
||||
LLSD& summary_column = element["columns"][5];
|
||||
summary_column["column"] = "summary";
|
||||
summary_column["value"] = item.mSummary;
|
||||
LLScrollListCtrl* scrollp = sInstance->getChild<LLScrollListCtrl>("message_log");
|
||||
S32 scroll_pos = scrollp->getScrollPos();
|
||||
scrollp->addElement(element);
|
||||
if(scroll_pos > scrollp->getItemCount() - scrollp->getPageLines() - 4)
|
||||
scrollp->setScrollPos(scrollp->getItemCount());
|
||||
}
|
||||
// static
|
||||
void LLFloaterMessageLog::onCommitNetList(LLUICtrl* ctrl, void* user_data)
|
||||
{
|
||||
LLFloaterMessageLog* floaterp = (LLFloaterMessageLog*)user_data;
|
||||
floaterp->setNetInfoMode(NI_NET);
|
||||
floaterp->refreshNetInfo(TRUE);
|
||||
}
|
||||
// static
|
||||
void LLFloaterMessageLog::onCommitMessageLog(LLUICtrl* ctrl, void* user_data)
|
||||
{
|
||||
LLFloaterMessageLog* floaterp = (LLFloaterMessageLog*)user_data;
|
||||
LLScrollListCtrl* scrollp = floaterp->getChild<LLScrollListCtrl>("message_log");
|
||||
LLScrollListItem* selected_itemp = scrollp->getFirstSelected();
|
||||
if(!selected_itemp) return;
|
||||
LLUUID id = selected_itemp->getUUID();
|
||||
std::vector<LLFloaterMessageLogItem>::iterator end = sFloaterMessageLogItems.end();
|
||||
for(std::vector<LLFloaterMessageLogItem>::iterator iter = sFloaterMessageLogItems.begin(); iter != end; ++iter)
|
||||
{
|
||||
if(iter->mID == id)
|
||||
{
|
||||
floaterp->setNetInfoMode(NI_LOG);
|
||||
floaterp->childSetText("net_info", iter->getFull(FALSE));
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
// static
|
||||
BOOL LLFloaterMessageLog::onClickCloseCircuit(void* user_data)
|
||||
{
|
||||
LLNetListItem* itemp = (LLNetListItem*)user_data;
|
||||
LLCircuitData* cdp = itemp->mCircuitData;
|
||||
if(!cdp) return FALSE;
|
||||
LLSD args;
|
||||
args["MESSAGE"] = "This will delete local circuit data.\nDo you want to tell the remote host to close the circuit too?";
|
||||
LLSD payload;
|
||||
payload["netlistitem"] = (int)((void*)itemp); //oh god, this is so very wrong, wonder if there's another way to get LLSD to like pointers
|
||||
LLNotifications::instance().add("GenericAlertYesNoCancel", args, payload, onConfirmCloseCircuit);
|
||||
return TRUE;
|
||||
}
|
||||
// static
|
||||
void LLFloaterMessageLog::onConfirmCloseCircuit(S32 option, LLSD payload)
|
||||
{
|
||||
LLNetListItem* itemp = (LLNetListItem*)((void*)(payload["netlistitem"].asInteger())); //yep...
|
||||
LLCircuitData* cdp = itemp->mCircuitData;
|
||||
if(!cdp) return;
|
||||
LLViewerRegion* regionp = LLWorld::getInstance()->getRegion(cdp->getHost());
|
||||
switch(option)
|
||||
{
|
||||
case 0: // yes
|
||||
gMessageSystem->newMessageFast(_PREHASH_CloseCircuit);
|
||||
gMessageSystem->sendReliable(cdp->getHost());
|
||||
break;
|
||||
case 2: // cancel
|
||||
return;
|
||||
break;
|
||||
case 1: // no
|
||||
default:
|
||||
break;
|
||||
}
|
||||
if(gMessageSystem->findCircuitCode(cdp->getHost()))
|
||||
gMessageSystem->disableCircuit(cdp->getHost());
|
||||
else
|
||||
gMessageSystem->getCircuit()->removeCircuitData(cdp->getHost());
|
||||
if(regionp)
|
||||
{
|
||||
LLSD args;
|
||||
args["MESSAGE"] = "That host had a region associated with it.\nDo you want to clean that up?";
|
||||
LLSD payload;
|
||||
payload["region"] = (int)((void*)regionp);
|
||||
LLNotifications::instance().add("GenericAlertYesNo", args, payload, onConfirmRemoveRegion);
|
||||
}
|
||||
}
|
||||
// static
|
||||
void LLFloaterMessageLog::onConfirmRemoveRegion(S32 option, LLSD payload)
|
||||
{
|
||||
LLViewerRegion* regionp = (LLViewerRegion*)((void*)(payload["region"].asInteger()));
|
||||
if(option == 0) // yes
|
||||
LLWorld::getInstance()->removeRegion(regionp->getHost());
|
||||
}
|
||||
// static
|
||||
void LLFloaterMessageLog::onClickFilterApply(void* user_data)
|
||||
{
|
||||
LLFloaterMessageLog* floaterp = (LLFloaterMessageLog*)user_data;
|
||||
floaterp->startApplyingFilter(floaterp->childGetValue("filter_edit"), FALSE);
|
||||
}
|
||||
void LLFloaterMessageLog::startApplyingFilter(std::string filter, BOOL force)
|
||||
{
|
||||
LLMessageLogFilter new_filter = LLMessageLogFilter();
|
||||
sMessageLogFilterString = filter;
|
||||
new_filter.set(sMessageLogFilterString);
|
||||
childSetText("filter_edit", filter + " ");
|
||||
if(force
|
||||
|| (new_filter.mNegativeNames != sMessageLogFilter.mNegativeNames)
|
||||
|| (new_filter.mPositiveNames != sMessageLogFilter.mPositiveNames))
|
||||
{
|
||||
stopApplyingFilter();
|
||||
sMessageLogFilter = new_filter;
|
||||
sFloaterMessageLogItems.clear();
|
||||
getChild<LLScrollListCtrl>("message_log")->clearRows();
|
||||
sBusyApplyingFilter = TRUE;
|
||||
childSetVisible("message_log", false);
|
||||
//childSetVisible("log_status_text", true);
|
||||
mMessageLogFilterApply = new LLMessageLogFilterApply();
|
||||
}
|
||||
}
|
||||
void LLFloaterMessageLog::stopApplyingFilter()
|
||||
{
|
||||
if(mMessageLogFilterApply)
|
||||
{
|
||||
if(!(mMessageLogFilterApply->mFinished))
|
||||
mMessageLogFilterApply->cancel();
|
||||
//delete mMessageLogFilterApply;
|
||||
sBusyApplyingFilter = FALSE;
|
||||
//childSetVisible("log_status_text", false);
|
||||
childSetVisible("message_log", true);
|
||||
childSetText("log_status_text", llformat("Showing %d messages from %d", sFloaterMessageLogItems.size(), sMessageLogEntries.size()));
|
||||
}
|
||||
}
|
||||
void LLFloaterMessageLog::updateFilterStatus()
|
||||
{
|
||||
if(!mMessageLogFilterApply || !sBusyApplyingFilter) return;
|
||||
S32 progress = mMessageLogFilterApply->mProgress;
|
||||
S32 packets = sMessageLogEntries.size();
|
||||
S32 matches = sFloaterMessageLogItems.size();
|
||||
std::string text = llformat("Applying filter ( %d / %d ), %d matches ...", progress, packets, matches);
|
||||
childSetText("log_status_text", text);
|
||||
}
|
||||
// static
|
||||
void LLFloaterMessageLog::onCommitFilter(LLUICtrl* ctrl, void* user_data)
|
||||
{
|
||||
LLFloaterMessageLog* floaterp = (LLFloaterMessageLog*)user_data;
|
||||
floaterp->startApplyingFilter(floaterp->childGetValue("filter_edit"), FALSE);
|
||||
}
|
||||
// static
|
||||
void LLFloaterMessageLog::onClickClearLog(void* user_data)
|
||||
{
|
||||
LLFloaterMessageLog* floaterp = (LLFloaterMessageLog*)user_data;
|
||||
floaterp->stopApplyingFilter();
|
||||
floaterp->getChild<LLScrollListCtrl>("message_log")->clearRows();
|
||||
floaterp->setNetInfoMode(NI_NET);
|
||||
sMessageLogEntries.clear();
|
||||
sFloaterMessageLogItems.clear();
|
||||
}
|
||||
// static
|
||||
void LLFloaterMessageLog::onClickFilterChoice(void* user_data)
|
||||
{
|
||||
LLMenuGL* menu = new LLMenuGL(LLStringUtil::null);
|
||||
menu->append(new LLMenuItemCallGL("No filter", onClickFilterMenu, NULL, (void*)""));
|
||||
menu->append(new LLMenuItemCallGL("Fewer spammy messages", onClickFilterMenu, NULL, (void*)"!StartPingCheck !CompletePingCheck !PacketAck !SimulatorViewerTimeMessage !SimStats !AgentUpdate !AgentAnimation !AvatarAnimation !ViewerEffect !CoarseLocationUpdate !LayerData !CameraConstraint !ObjectUpdateCached !RequestMultipleObjects !ObjectUpdate !ObjectUpdateCompressed !ImprovedTerseObjectUpdate !KillObject !ImagePacket !SendXferPacket !ConfirmXferPacket !TransferPacket"));
|
||||
menu->append(new LLMenuItemCallGL("Object updates", onClickFilterMenu, NULL, (void*)"ObjectUpdateCached ObjectUpdate ObjectUpdateCompressed ImprovedTerseObjectUpdate KillObject RequestMultipleObjects"));
|
||||
menu->append(new LLMenuItemCallGL("Abnormal", onClickFilterMenu, NULL, (void*)"Invalid TestMessage AddCircuitCode NeighborList AvatarTextureUpdate SimulatorMapUpdate SimulatorSetMap SubscribeLoad UnsubscribeLoad SimulatorReady SimulatorPresentAtLocation SimulatorLoad SimulatorShutdownRequest RegionPresenceRequestByRegionID RegionPresenceRequestByHandle RegionPresenceResponse UpdateSimulator LogDwellTime FeatureDisabled LogFailedMoneyTransaction UserReportInternal SetSimStatusInDatabase SetSimPresenceInDatabase OpenCircuit CloseCircuit DirFindQueryBackend DirPlacesQueryBackend DirClassifiedQueryBackend DirLandQueryBackend DirPopularQueryBackend GroupNoticeAdd DataHomeLocationRequest DataHomeLocationReply DerezContainer ObjectCategory ObjectExportSelected StateSave ReportAutosaveCrash AgentAlertMessage NearestLandingRegionRequest NearestLandingRegionReply NearestLandingRegionUpdated TeleportLandingStatusChanged ConfirmEnableSimulator KickUserAck SystemKickUser AvatarPropertiesRequestBackend UpdateParcel RemoveParcel MergeParcel LogParcelChanges CheckParcelSales ParcelSales StartAuction ConfirmAuctionStart CompleteAuction CancelAuction CheckParcelAuctions ParcelAuctions ChatPass EdgeDataPacket SimStatus ChildAgentUpdate ChildAgentAlive ChildAgentPositionUpdate ChildAgentDying ChildAgentUnknown AtomicPassObject KillChildAgents ScriptSensorRequest ScriptSensorReply DataServerLogout RequestInventoryAsset InventoryAssetResponse TransferInventory TransferInventoryAck EventLocationRequest EventLocationReply MoneyTransferBackend RoutedMoneyBalanceReply SetStartLocation NetTest SetCPURatio SimCrashed NameValuePair RemoveNameValuePair UpdateAttachment RemoveAttachment EmailMessageRequest EmailMessageReply InternalScriptMail ScriptDataRequest ScriptDataReply InviteGroupResponse TallyVotes LiveHelpGroupRequest LiveHelpGroupReply GroupDataUpdate LogTextMessage CreateTrustedCircuit ParcelRename SystemMessage RpcChannelRequest RpcChannelReply RpcScriptRequestInbound RpcScriptRequestInboundForward RpcScriptReplyInbound ScriptMailRegistration Error"));
|
||||
menu->updateParent(LLMenuGL::sMenuContainer);
|
||||
menu->setCanTearOff(FALSE);
|
||||
LLView* buttonp = sInstance->getChild<LLView>("filter_choice_btn");
|
||||
S32 x = buttonp->getRect().mLeft;
|
||||
S32 y = buttonp->getRect().mBottom;
|
||||
LLMenuGL::showPopup(sInstance, menu, x, y);
|
||||
}
|
||||
// static
|
||||
void LLFloaterMessageLog::onClickFilterMenu(void* user_data)
|
||||
{
|
||||
std::string filter = std::string((char*)user_data);
|
||||
sInstance->childSetText("filter_edit", filter);
|
||||
sInstance->startApplyingFilter(filter, FALSE);
|
||||
}
|
||||
// static
|
||||
void LLFloaterMessageLog::onClickSendToMessageBuilder(void* user_data)
|
||||
{
|
||||
LLFloaterMessageLog* floaterp = (LLFloaterMessageLog*)user_data;
|
||||
LLScrollListCtrl* scrollp = floaterp->getChild<LLScrollListCtrl>("message_log");
|
||||
LLScrollListItem* selected_itemp = scrollp->getFirstSelected();
|
||||
if(!selected_itemp) return;
|
||||
LLUUID id = selected_itemp->getUUID();
|
||||
std::vector<LLFloaterMessageLogItem>::iterator end = sFloaterMessageLogItems.end();
|
||||
for(std::vector<LLFloaterMessageLogItem>::iterator iter = sFloaterMessageLogItems.begin(); iter != end; ++iter)
|
||||
{
|
||||
if(iter->mID == id)
|
||||
{
|
||||
std::string message_text = iter->getFull(FALSE);
|
||||
LLFloaterMessageBuilder::show(message_text);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
// </edit>
|
||||
92
indra/newview/llfloatermessagelog.h
Normal file
92
indra/newview/llfloatermessagelog.h
Normal file
@@ -0,0 +1,92 @@
|
||||
// <edit>
|
||||
#include "llfloater.h"
|
||||
#include "llmessagelog.h"
|
||||
#include "lltemplatemessagereader.h"
|
||||
class LLNetListItem
|
||||
{
|
||||
public:
|
||||
LLNetListItem(LLUUID id);
|
||||
LLUUID mID;
|
||||
BOOL mAutoName;
|
||||
std::string mName;
|
||||
std::string mPreviousRegionName;
|
||||
LLCircuitData* mCircuitData;
|
||||
};
|
||||
class LLFloaterMessageLogItem : public LLMessageLogEntry
|
||||
{
|
||||
public:
|
||||
LLFloaterMessageLogItem(LLMessageLogEntry entry);
|
||||
~LLFloaterMessageLogItem();
|
||||
LLUUID mID;
|
||||
U32 mSequenceID;
|
||||
std::string mName;
|
||||
std::string mSummary;
|
||||
U32 mFlags;
|
||||
std::string getFull(BOOL show_header = TRUE);
|
||||
BOOL isOutgoing();
|
||||
private:
|
||||
static U8 sDecodeBuffer[8192];
|
||||
static LLTemplateMessageReader* sTemplateMessageReader;
|
||||
static std::string getString(LLTemplateMessageReader* readerp, const char* block_name, S32 block_num, const char* var_name, e_message_variable_type var_type, BOOL &returned_hex, BOOL summary_mode = FALSE);
|
||||
};
|
||||
class LLMessageLogFilter
|
||||
{
|
||||
public:
|
||||
LLMessageLogFilter();
|
||||
~LLMessageLogFilter();
|
||||
BOOL set(std::string filter);
|
||||
std::list<std::string> mPositiveNames;
|
||||
std::list<std::string> mNegativeNames;
|
||||
};
|
||||
class LLMessageLogFilterApply : public LLEventTimer
|
||||
{
|
||||
public:
|
||||
LLMessageLogFilterApply();
|
||||
void cancel();
|
||||
BOOL tick();
|
||||
S32 mProgress;
|
||||
BOOL mFinished;
|
||||
private:
|
||||
std::deque<LLMessageLogEntry>::iterator mIter;
|
||||
};
|
||||
class LLFloaterMessageLog : public LLFloater, public LLEventTimer
|
||||
{
|
||||
public:
|
||||
LLFloaterMessageLog();
|
||||
~LLFloaterMessageLog();
|
||||
static void show();
|
||||
BOOL postBuild();
|
||||
BOOL tick();
|
||||
LLNetListItem* findNetListItem(LLHost host);
|
||||
LLNetListItem* findNetListItem(LLUUID id);
|
||||
void refreshNetList();
|
||||
void refreshNetInfo(BOOL force);
|
||||
enum ENetInfoMode { NI_NET, NI_LOG };
|
||||
void setNetInfoMode(ENetInfoMode mode);
|
||||
static void onLog(LLMessageLogEntry entry);
|
||||
static void conditionalLog(LLFloaterMessageLogItem item);
|
||||
static void onCommitNetList(LLUICtrl* ctrl, void* user_data);
|
||||
static void onCommitMessageLog(LLUICtrl* ctrl, void* user_data);
|
||||
static void onCommitFilter(LLUICtrl* ctrl, void* user_data);
|
||||
static BOOL onClickCloseCircuit(void* user_data);
|
||||
static void onConfirmCloseCircuit(S32 option, LLSD payload);
|
||||
static void onConfirmRemoveRegion(S32 option, LLSD payload);
|
||||
static void onClickFilterApply(void* user_data);
|
||||
void startApplyingFilter(std::string filter, BOOL force);
|
||||
void stopApplyingFilter();
|
||||
void updateFilterStatus();
|
||||
static BOOL sBusyApplyingFilter;
|
||||
LLMessageLogFilterApply* mMessageLogFilterApply;
|
||||
static void onClickClearLog(void* user_data);
|
||||
static LLFloaterMessageLog* sInstance;
|
||||
static std::list<LLNetListItem*> sNetListItems;
|
||||
static std::deque<LLMessageLogEntry> sMessageLogEntries;
|
||||
static std::vector<LLFloaterMessageLogItem> sFloaterMessageLogItems;
|
||||
static LLMessageLogFilter sMessageLogFilter;
|
||||
static std::string sMessageLogFilterString;
|
||||
ENetInfoMode mNetInfoMode;
|
||||
static void onClickFilterChoice(void* user_data);
|
||||
static void onClickFilterMenu(void* user_data);
|
||||
static void onClickSendToMessageBuilder(void* user_data);
|
||||
};
|
||||
// </edit>
|
||||
17
indra/newview/skins/default/xui/en-us/floater_message_builder.xml
Executable file
17
indra/newview/skins/default/xui/en-us/floater_message_builder.xml
Executable file
@@ -0,0 +1,17 @@
|
||||
<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
|
||||
<floater name="Message Builder" title="Message Builder" width="400" min_width="400" height="600" min_height="600" can_close="true" can_resize="true" can_minimize="true">
|
||||
<scroll_list column_padding="0" draw_heading="false" follows="left|top|right" left="10" top="-25"
|
||||
name="net_list" search_column="0" right="-10" bottom="450">
|
||||
<column dynamicwidth="true" name="text" label="text" />
|
||||
<column name="icon0" label="icon0" width="24" />
|
||||
<column name="icon1" label="icon1" width="24" />
|
||||
<column name="icon2" label="icon2" width="24" />
|
||||
</scroll_list>
|
||||
<combo_box name="untrusted_message_combo" allow_text_entry="false" follows="left|top" left="10" top="-150" right="-370" bottom="433" tool_tip="No trust">
|
||||
</combo_box>
|
||||
<combo_box name="trusted_message_combo" allow_text_entry="false" follows="left|top" left="30" top="-150" right="-350" bottom="433" tool_tip="Trust">
|
||||
</combo_box>
|
||||
<text_editor name="message_edit" follows="left|top|right|bottom" left="10" top="-168" bottom="30" right="-10" max_length="65535">
|
||||
</text_editor>
|
||||
<button name="send_btn" follows="right|bottom" left="310" top="-570" right="-10" bottom="10" label="Send" tool_tip="Send (Ctrl+Enter)"/>
|
||||
</floater>
|
||||
32
indra/newview/skins/default/xui/en-us/floater_message_log.xml
Executable file
32
indra/newview/skins/default/xui/en-us/floater_message_log.xml
Executable file
@@ -0,0 +1,32 @@
|
||||
<?xml version="1.0" encoding="utf-8" standalone="yes" ?>
|
||||
<floater name="Message Log" title="Message Log" width="400" min_width="400" height="600" min_height="600" can_close="true" can_resize="true" can_minimize="true">
|
||||
<scroll_list column_padding="0" draw_heading="false" follows="left|top|right" left="10" top="-25"
|
||||
name="net_list" search_column="0" right="-10" bottom="450">
|
||||
<column dynamicwidth="true" name="text" label="text" />
|
||||
<column name="icon0" label="icon0" width="24" />
|
||||
<column name="icon1" label="icon1" width="24" />
|
||||
<column name="icon2" label="icon2" width="24" />
|
||||
</scroll_list>
|
||||
<button name="filter_choice_btn" follows="left|top" left="10" top="-150" right="-370" bottom="430" label="…"/>
|
||||
<line_editor name="filter_edit" follows="left|top|right" left="30" top="-149" right="-28" bottom="430" max_length="65535"/>
|
||||
<button name="filter_apply_btn" follows="top|right" left="370" top="-150" right="-9" bottom="430" label="✔"/>
|
||||
<button name="clear_log_btn" follows="top|right" left="370" top="-170" right="-9" bottom="410" label="C"/>
|
||||
<scroll_list column_padding="0" draw_heading="false" follows="left|top|right" left="10" top="-190"
|
||||
name="message_log" search_column="0" right="-10" bottom="200">
|
||||
<column name="sequence" label="sequence" width="48"/>
|
||||
<column name="type" label="type" width="32"/>
|
||||
<column name="direction" label="direction" width="32"/>
|
||||
<column name="net" label="net" width="100"/>
|
||||
<column name="name" label="name" width="128"/>
|
||||
<!--<column name="flag_zer" label="zer" width="8"/>
|
||||
<column name="flag_rel" label="rel" width="8"/>
|
||||
<column name="flag_rsd" label="rsd" width="8"/>
|
||||
<column name="flag_ack" label="ack" width="8"/>-->
|
||||
<column name="summary" label="summary" dynamicwidth="true"/>
|
||||
</scroll_list>
|
||||
<text name="log_status_text" follows="left|top|right" left="10" top="-172" right="-10" height="20">
|
||||
</text>
|
||||
<text_editor name="net_info" follows="left|top|right|bottom" left="10" top="-400" bottom="30" right="-10" enabled="false" max_length="65535">
|
||||
</text_editor>
|
||||
<button name="send_to_message_builder_btn" follows="right|bottom" left="210" top="-570" right="-10" bottom="10" label="Send to Message Builder" enabled="false"/>
|
||||
</floater>
|
||||
Reference in New Issue
Block a user