Singularity-Viewer/SingularityViewer
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
7533b475beca4988443e3bd12d5e99e160c78dad
SingularityViewer/indra/newview/floaterao.cpp
Lirusaito 0846f8a963 Fixeds and ToDones 
-Color Fixies-
Fixed Gemini skin not looking as it originally did.
We now use DefaultListText to color all otherwise uncolored text in scroll list cells.
All of our dark skins have been updated to use white here, as dark skins are intended to have white text...
This includes the Dark we ship with.

LLFloaterActiveSpeakers no longer uses hard coded font colors, it uses SpeakersInactive, DefaultListText, and SpeakersGhost.

LLFloaterAvatarList no longer uses hard coded font colors, it uses DefaultListText, RadarTextChatRange, RadarTextShoutRange, and RadarTextDrawDist, in place of previously hard coded font colors
Since the tooltip defines color meaning, these new colors should only be skinned to change shade.

DefaultListText defaults to black; SpeaksInactive, gray(grey4); SpeakersGhost, Red; RadarTextChatRange, Red; RadarTextShoutRange, Yellow(yellow1); RadarTextDrawDist, Green(green2).


-Translation update and fixies-
Partial credit to viewer-development, thanks for hanging onto old strings!  Also, updated to look more like v-d in translated areas.
Punctuation strings can be used quite a lot.  Brought them all in, just in case.

AscentPrefs*:
Drag and Drop points now use CurrentlySetTo, CurrentlyNotSet, AnItemNotOnThisAccount, and NotLoggedIn. (applies, as well, to FloaterAO)
Power User message is now built from PowerUser1, PowerUser2, Unlocked:, PowerUser3, RightClick, PowerUser4 and PowerUser5; this should give translators enough space to explain any tough to translate, and make the message easier to alter in the future, if necessary.

LLCompileQueue:
Now uses translation strings from upstream
Starting, Done, Resetting, Running, and NotRunning in its xml.
CompileQueueTitle, CompileQueueStart, CompileQueueDownloadedCompiling, CompileQueueScriptNotFound, CompileQueueProblemDownloading, CompileQueueInsufficientPermDownload, CompileQueueInsufficientPermFor, CompileQueueUnknownFailure, ResetQueueTitle, ResetQueueStart, NotRunQueueTitle, and NotRunQueueStart from strings.

LLFloaterAvatarList(floater_radar) now uses has_entered, has_left, the_sim, draw_distance, shout_range, and chat_range in its xml for translatable alerts.

LLFloaterLand(floater_about_land) now uses minutes, 1_minute, 1_second, seconds, and remaining from its xml.
LLFloaterLand, LLFolderView, LLPanelDirBrowser now make use of InventoryNoMatchingItems, NoneFound, and Searching in their searches.
LLFolderView was brought closer to v-d in translation.

LLGroupNotify now uses GroupNotifyGroupNotice, GroupNotifySentBy, GroupNotifyAttached, next (also now used by LLNotify), ok, GroupNotifyGroupNotices, GroupNotifyViewPastNotices, GroupNotifyOpenAttachment, and GroupNotifySaveAttachment.

LLInventoryFilter synced with V-D for translation:
Now uses Animations, Calling Cards, Clothing, Gestures, Landmarks, Notecards, Objects, Scripts, Sounds, Textures, Snapshots, No Filters, Since Logoff, and Worn.

LLManipRotate now uses Direction_Forward, Direction_Left, Direction_Right, Direction_Back, Direction_North, Direction_South, Direction_West, Direction_East, Direction_Up, and Direction_Down, like upstream v-d.

LLPanelAvatar(panel_avatar) now uses None string in its xml for when there are no groups, also removed cruft. Though the None has not been showing up for quite some time, anyway...

LLPanelObjectInventory now uses Buy, LoadingContents and NoContents,
however the last two strings did not seem to show up anyway...
thanks to Latif Khalifa, Jean Horten, theGenius Indigo and Cubbi Bearcat for confirming this happens across many different versions and on both Windows and linux(32 and 64).

LLPreviewScript now uses CompileSuccessful, SaveComplete, ObjectOutOfRange, and CompileSuccessfulSaving.

LLScrollingPanelParam now translates Less and More.
Avatar Shape Information strings now used for customize appearance panels.

LLTextureCtrl now uses multiple_textures.

LLToolpie has been updated to use v-d include order and now uses UnmuteAvatar, MuteAvatar, UnmuteObject, and MuteObject2 strings.
LLVOAvatarSelf now uses BodyParts* strings for translation of toolpie entries pertaining to bodyparts.

LLViewerMenuFile now uses UnknownFileExtension, and UploadingCosts.

LLViewerMessage now uses Cancel(also used by LLViewerDisplay), AcquiredItems, Saved_message, IM_autoresponse_sent_item, IM_autoresponded_to, IM_announce_incoming, InvOfferDecline, InvOfferGaveYou, InvOfferOwnedByUnknownUser, InvOfferAnObjectNamed, InvOfferOwnedBy, InvOfferOwnedByUnknownGroup, and InvOfferOwnedByGroup.


-AvatarRadar Update-
AvatarRadar enhanced with code from both Cool VL Viewer and some avian corpse.
e_radar_alert_type has been reworked to allow bitwise usage in the future.

Cool stuff:
gSavedSettings for radar are now CachedControls,
entering boolean is now checked before going into the switchcase,
Style changes, yay C++ style.

Avian Flu:
Distance for shout range corrected to be 96.
handleKeyHere: If the user hits enter with an avatar on the radar selected, focus camera on selected avatar; ctrl-enter, teleport to selected avatar.

Otherwise:
Tiny spelling fixies, and a suggestive comment.
2012-08-05 20:40:02 -04:00

1436 lines
49 KiB
C++
Raw Blame History

/**
* @file llfloaterao.cpp
* @brief clientside animation overrider
* by Skills Hak
*/
#include "llviewerprecompiledheaders.h"
#include "floaterao.h"
#include "llagent.h"
#include "llagentcamera.h"
#include "llvoavatarself.h"
#include "llanimationstates.h"
#include "lluictrlfactory.h"
#include "llstartup.h"
#include "llpreviewnotecard.h"
#include "llviewertexteditor.h"
#include "llcheckboxctrl.h"
#include "llcombobox.h"
#include "llspinctrl.h"
#include "chatbar_as_cmdline.h"
//#include "llfloaterchat.h"
#include "llfirstuse.h"
#include "lltrans.h"
#include "llinventory.h"
#include "llinventoryfunctions.h"
#include "llinventorypanel.h"
#include "llinventorymodelbackgroundfetch.h"
#include "roles_constants.h"
#include "llviewerregion.h"
#include "llpanelobjectinventory.h"
#include "llinventorybridge.h"
#include "llboost.h"
#include <boost/regex.hpp>
// Uncomment and use instead if we ever add the chatbar as a command line - MC
void cmdline_printchat(std::string message);
class AONotecardCallback : public LLInventoryCallback
{
public:
AONotecardCallback(std::string &filename)
{
mFileName = filename;
}
void fire(const LLUUID &inv_item)
{
if (!mFileName.empty())
{
LLPreviewNotecard* nc;
nc = (LLPreviewNotecard*)LLPreview::find(inv_item);
if(nc)
{
nc->open();
LLTextEditor *text = nc->getEditor();
if (text)
{
text->clear();
text->makePristine();
std::ifstream file(mFileName.c_str());
std::string line;
while (!file.eof())
{
getline(file, line);
line = line + "\n";
text->insertText(line);
}
file.close();
nc->saveIfNeeded();
}
}
}
}
private:
std::string mFileName;
};
AOInvTimer* gAOInvTimer = NULL;
// -------------------------------------------------------
AOStandTimer* mAOStandTimer;
AOStandTimer::AOStandTimer() : LLEventTimer( gSavedSettings.getF32("AOStandInterval") )
{
AOStandTimer::tick();
}
AOStandTimer::~AOStandTimer()
{
// llinfos << "dead" << llendl;
}
void AOStandTimer::reset()
{
mPeriod = gSavedSettings.getF32("AOStandInterval");
mEventTimer.reset();
// llinfos << "reset" << llendl;
}
BOOL AOStandTimer::tick()
{
LLFloaterAO::stand_iterator++;
// llinfos << "tick" << llendl;
LLFloaterAO::ChangeStand();
return FALSE;
// return LLFloaterAO::ChangeStand(); //timer is always active now ..
}
// -------------------------------------------------------
AOInvTimer::AOInvTimer() : LLEventTimer( (F32)1.0 )
{
}
AOInvTimer::~AOInvTimer()
{
}
BOOL AOInvTimer::tick()
{
if (!(gSavedSettings.getBOOL("AOEnabled"))) return TRUE;
if(LLStartUp::getStartupState() >= STATE_INVENTORY_SEND)
{
if(LLInventoryModelBackgroundFetch::instance().isEverythingFetched())
{
// cmdline_printchat("Inventory fetched, loading AO.");
LLFloaterAO::init();
return TRUE;
}
}
return FALSE;
}
// NC DROP -------------------------------------------------------
class AONoteCardDropTarget : public LLView
{
public:
AONoteCardDropTarget(const std::string& name, const LLRect& rect, void (*callback)(LLViewerInventoryItem*));
~AONoteCardDropTarget();
void doDrop(EDragAndDropType cargo_type, void* cargo_data);
//
// LLView functionality
virtual BOOL handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
EDragAndDropType cargo_type,
void* cargo_data,
EAcceptance* accept,
std::string& tooltip_msg);
protected:
void (*mDownCallback)(LLViewerInventoryItem*);
};
AONoteCardDropTarget::AONoteCardDropTarget(const std::string& name, const LLRect& rect,
void (*callback)(LLViewerInventoryItem*)) :
LLView(name, rect, NOT_MOUSE_OPAQUE, FOLLOWS_ALL),
mDownCallback(callback)
{
}
AONoteCardDropTarget::~AONoteCardDropTarget()
{
}
void AONoteCardDropTarget::doDrop(EDragAndDropType cargo_type, void* cargo_data)
{
// llinfos << "AONoteCardDropTarget::doDrop()" << llendl;
}
BOOL AONoteCardDropTarget::handleDragAndDrop(S32 x, S32 y, MASK mask, BOOL drop,
EDragAndDropType cargo_type,
void* cargo_data,
EAcceptance* accept,
std::string& tooltip_msg)
{
BOOL handled = FALSE;
if(getParent())
{
handled = TRUE;
LLViewerInventoryItem* inv_item = (LLViewerInventoryItem*)cargo_data;
if(gInventory.getItem(inv_item->getUUID()))
{
*accept = ACCEPT_YES_COPY_SINGLE;
if(drop)
{
mDownCallback(inv_item);
}
}
else
{
*accept = ACCEPT_NO;
}
}
return handled;
}
AONoteCardDropTarget * LLFloaterAO::mAOItemDropTarget;
// STUFF -------------------------------------------------------
int LLFloaterAO::mAnimationState = 0;
int LLFloaterAO::stand_iterator = 0;
LLUUID LLFloaterAO::invfolderid = LLUUID::null;
LLUUID LLFloaterAO::mCurrentStandId = LLUUID::null;
LLComboBox* mcomboBox_stands;
LLComboBox* mcomboBox_walks;
LLComboBox* mcomboBox_runs;
LLComboBox* mcomboBox_jumps;
LLComboBox* mcomboBox_sits;
LLComboBox* mcomboBox_gsits;
LLComboBox* mcomboBox_crouchs;
LLComboBox* mcomboBox_cwalks;
LLComboBox* mcomboBox_falls;
LLComboBox* mcomboBox_hovers;
LLComboBox* mcomboBox_flys;
LLComboBox* mcomboBox_flyslows;
LLComboBox* mcomboBox_flyups;
LLComboBox* mcomboBox_flydowns;
LLComboBox* mcomboBox_lands;
LLComboBox* mcomboBox_standups;
LLComboBox* mcomboBox_prejumps;
struct struct_overrides
{
LLUUID orig_id;
LLUUID ao_id;
int state;
};
std::vector<struct_overrides> mAOOverrides;
struct struct_stands
{
LLUUID ao_id;
std::string anim_name;
};
std::vector<struct_stands> mAOStands;
struct struct_tokens
{
std::string token;
int state;
};
std::vector<struct_tokens> mAOTokens;
LLFloaterAO* LLFloaterAO::sInstance = NULL;
LLFloaterAO::LLFloaterAO()
:LLFloater(std::string("floater_ao"))
{
// init();
llassert_always(sInstance == NULL);
LLUICtrlFactory::getInstance()->buildFloater(this, "floater_ao.xml");
sInstance = this;
}
LLFloaterAO::~LLFloaterAO()
{
sInstance=NULL;
mcomboBox_stands = 0;
mcomboBox_walks = 0;
mcomboBox_runs = 0;
mcomboBox_jumps = 0;
mcomboBox_sits = 0;
mcomboBox_gsits = 0;
mcomboBox_crouchs = 0;
mcomboBox_cwalks = 0;
mcomboBox_falls = 0;
mcomboBox_hovers = 0;
mcomboBox_flys = 0;
mcomboBox_flyslows = 0;
mcomboBox_flyups = 0;
mcomboBox_flydowns = 0;
mcomboBox_lands = 0;
mcomboBox_standups = 0;
mcomboBox_prejumps = 0;
delete mAOItemDropTarget;
mAOItemDropTarget = NULL;
// llinfos << "floater destroyed" << llendl;
}
void LLFloaterAO::show(void*)
{
if (!sInstance)
{
sInstance = new LLFloaterAO();
updateLayout(sInstance);
init();
sInstance->open();
}
else
{
sInstance->close();
}
LLFirstUse::useAO();
}
bool LLFloaterAO::getInstance()
{
if (sInstance)
return true;
else
return false;
}
BOOL LLFloaterAO::postBuild()
{
LLView *target_view = getChild<LLView>("ao_notecard");
if(target_view)
{
if (mAOItemDropTarget)
{
delete mAOItemDropTarget;
}
mAOItemDropTarget = new AONoteCardDropTarget("drop target", target_view->getRect(), AOItemDrop);//, mAvatarID);
addChild(mAOItemDropTarget);
}
if(LLStartUp::getStartupState() == STATE_STARTED)
{
LLUUID itemidimport = (LLUUID)gSavedPerAccountSettings.getString("AOConfigNotecardID");
LLViewerInventoryItem* itemimport = gInventory.getItem(itemidimport);
if(itemimport)
{
childSetValue("ao_nc_text", LLTrans::getString("CurrentlySetTo") + LLTrans::getString(":") + " " +itemimport->getName());
}
else if(itemidimport.isNull())
{
childSetValue("ao_nc_text", LLTrans::getString("CurrentlyNotSet"));
}
else
{
childSetValue("ao_nc_text", LLTrans::getString("CurrentlySetTo") + " " + LLTrans::getString("AnItemNotOnThisAccount"));
}
}
else
{
childSetValue("ao_nc_text", LLTrans::getString("NotLoggedIn"));
}
childSetAction("more_btn", onClickMore, this);
childSetAction("less_btn", onClickLess, this);
childSetAction("reloadcard",onClickReloadCard,this);
childSetAction("opencard",onClickOpenCard,this);
childSetAction("newcard",onClickNewCard,this);
childSetAction("prevstand",onClickPrevStand,this);
childSetAction("nextstand",onClickNextStand,this);
childSetCommitCallback("AOEnabled",onClickToggleAO);
childSetCommitCallback("AOSitsEnabled",onClickToggleSits);
childSetCommitCallback("standtime",onSpinnerCommit);
mcomboBox_stands = getChild<LLComboBox>("stands");
mcomboBox_walks = getChild<LLComboBox>("walks");
mcomboBox_runs = getChild<LLComboBox>("runs");
mcomboBox_jumps = getChild<LLComboBox>("jumps");
mcomboBox_sits = getChild<LLComboBox>("sits");
mcomboBox_gsits = getChild<LLComboBox>("gsits");
mcomboBox_crouchs = getChild<LLComboBox>("crouchs");
mcomboBox_cwalks = getChild<LLComboBox>("cwalks");
mcomboBox_falls = getChild<LLComboBox>("falls");
mcomboBox_hovers = getChild<LLComboBox>("hovers");
mcomboBox_flys = getChild<LLComboBox>("flys");
mcomboBox_flyslows = getChild<LLComboBox>("flyslows");
mcomboBox_flyups = getChild<LLComboBox>("flyups");
mcomboBox_flydowns = getChild<LLComboBox>("flydowns");
mcomboBox_lands = getChild<LLComboBox>("lands");
mcomboBox_standups = getChild<LLComboBox>("standups");
mcomboBox_prejumps = getChild<LLComboBox>("prejumps");
getChild<LLComboBox>("stands")->setCommitCallback(onComboBoxCommit);
getChild<LLComboBox>("walks")->setCommitCallback(onComboBoxCommit);
getChild<LLComboBox>("runs")->setCommitCallback(onComboBoxCommit);
getChild<LLComboBox>("jumps")->setCommitCallback(onComboBoxCommit);
getChild<LLComboBox>("sits")->setCommitCallback(onComboBoxCommit);
getChild<LLComboBox>("gsits")->setCommitCallback(onComboBoxCommit);
getChild<LLComboBox>("crouchs")->setCommitCallback(onComboBoxCommit);
getChild<LLComboBox>("cwalks")->setCommitCallback(onComboBoxCommit);
getChild<LLComboBox>("falls")->setCommitCallback(onComboBoxCommit);
getChild<LLComboBox>("hovers")->setCommitCallback(onComboBoxCommit);
getChild<LLComboBox>("flys")->setCommitCallback(onComboBoxCommit);
getChild<LLComboBox>("flyslows")->setCommitCallback(onComboBoxCommit);
getChild<LLComboBox>("flyups")->setCommitCallback(onComboBoxCommit);
getChild<LLComboBox>("flydowns")->setCommitCallback(onComboBoxCommit);
getChild<LLComboBox>("lands")->setCommitCallback(onComboBoxCommit);
getChild<LLComboBox>("standups")->setCommitCallback(onComboBoxCommit);
getChild<LLComboBox>("prejumps")->setCommitCallback(onComboBoxCommit);
return TRUE;
}
void LLFloaterAO::onSpinnerCommit(LLUICtrl* ctrl, void* userdata)
{
LLSpinCtrl* spin = (LLSpinCtrl*) ctrl;
if(spin)
{
if (spin->getName() == "standtime")
{
if (mAOStandTimer) mAOStandTimer->reset();
}
}
}
void LLFloaterAO::onComboBoxCommit(LLUICtrl* ctrl, void* userdata)
{
LLComboBox* box = (LLComboBox*)ctrl;
if(box)
{
if (box->getName() == "stands")
{
stand_iterator = box->getCurrentIndex();
cmdline_printchat(llformat("Changing stand to %s.",mAOStands[stand_iterator].anim_name.c_str()));
ChangeStand();
}
else
{
int state = STATE_AGENT_IDLE;
std::string stranim = box->getValue().asString();
// llinfos << "state " << (gAgentAvatarp->isSitting()) << " - " << getAnimationState() << llendl;
if (box->getName() == "walks")
{
gAgent.sendAnimationRequest(GetAnimID(ANIM_AGENT_WALK), ANIM_REQUEST_STOP);
gSavedPerAccountSettings.setString("AODefaultWalk",stranim);
state = STATE_AGENT_WALK;
}
else if (box->getName() == "runs")
{
gAgent.sendAnimationRequest(GetAnimID(ANIM_AGENT_RUN), ANIM_REQUEST_STOP);
gSavedPerAccountSettings.setString("AODefaultRun",stranim);
state = STATE_AGENT_RUN;
}
else if (box->getName() == "jumps")
{
gAgent.sendAnimationRequest(GetAnimID(ANIM_AGENT_JUMP), ANIM_REQUEST_STOP);
gSavedPerAccountSettings.setString("AODefaultJump",stranim);
state = STATE_AGENT_JUMP;
}
else if (box->getName() == "sits")
{
if (gAgentAvatarp && (gSavedSettings.getBOOL("AOEnabled")) && (gSavedSettings.getBOOL("AOSitsEnabled")))
{
if ((gAgentAvatarp->isSitting()) && (getAnimationState() == STATE_AGENT_SIT))
{
// llinfos << "sitting " << GetAnimID(ANIM_AGENT_SIT) << " " << getAssetIDByName(stranim) << llendl;
gAgent.sendAnimationRequest(GetAnimID(ANIM_AGENT_SIT), ANIM_REQUEST_STOP);
gAgent.sendAnimationRequest(getAssetIDByName(stranim), ANIM_REQUEST_START);
}
}
gSavedPerAccountSettings.setString("AODefaultSit",stranim);
state = STATE_AGENT_SIT;
}
else if (box->getName() == "gsits")
{
// llinfos << "gsitting " << GetAnimID(ANIM_AGENT_SIT_GROUND) << " " << getAssetIDByName(stranim) << llendl;
if (gAgentAvatarp)
{
if ((gAgentAvatarp->isSitting()) && (getAnimationState() == STATE_AGENT_GROUNDSIT))
{
// llinfos << "gsitting " << GetAnimID(ANIM_AGENT_SIT_GROUND) << " " << getAssetIDByName(stranim) << llendl;
gAgent.sendAnimationRequest(GetAnimID(ANIM_AGENT_SIT_GROUND), ANIM_REQUEST_STOP);
gAgent.sendAnimationRequest(getAssetIDByName(stranim), ANIM_REQUEST_START);
}
}
gSavedPerAccountSettings.setString("AODefaultGroundSit",stranim);
state = STATE_AGENT_GROUNDSIT;
}
else if (box->getName() == "crouchs")
{
gAgent.sendAnimationRequest(GetAnimID(ANIM_AGENT_CROUCH), ANIM_REQUEST_STOP);
gSavedPerAccountSettings.setString("AODefaultCrouch",stranim);
state = STATE_AGENT_CROUCH;
}
else if (box->getName() == "cwalks")
{
gAgent.sendAnimationRequest(GetAnimID(ANIM_AGENT_CROUCHWALK), ANIM_REQUEST_STOP);
gSavedPerAccountSettings.setString("AODefaultCrouchWalk",stranim);
state = STATE_AGENT_CROUCHWALK;
}
else if (box->getName() == "falls")
{
gAgent.sendAnimationRequest(GetAnimID(ANIM_AGENT_FALLDOWN), ANIM_REQUEST_STOP);
gSavedPerAccountSettings.setString("AODefaultFall",stranim);
state = STATE_AGENT_FALLDOWN;
}
else if (box->getName() == "hovers")
{
gAgent.sendAnimationRequest(GetAnimID(ANIM_AGENT_HOVER), ANIM_REQUEST_STOP);
gSavedPerAccountSettings.setString("AODefaultHover",stranim);
state = STATE_AGENT_HOVER;
}
else if (box->getName() == "flys")
{
gAgent.sendAnimationRequest(GetAnimID(ANIM_AGENT_FLY), ANIM_REQUEST_STOP);
gSavedPerAccountSettings.setString("AODefaultFly",stranim);
state = STATE_AGENT_FLY;
}
else if (box->getName() == "flyslows")
{
gAgent.sendAnimationRequest(GetAnimID(ANIM_AGENT_FLYSLOW), ANIM_REQUEST_STOP);
gSavedPerAccountSettings.setString("AODefaultFlySlow",stranim);
state = STATE_AGENT_FLYSLOW;
}
else if (box->getName() == "flyups")
{
gAgent.sendAnimationRequest(GetAnimID(ANIM_AGENT_HOVER_UP), ANIM_REQUEST_STOP);
gSavedPerAccountSettings.setString("AODefaultFlyUp",stranim);
state = STATE_AGENT_HOVER_UP;
}
else if (box->getName() == "flydowns")
{
gAgent.sendAnimationRequest(GetAnimID(ANIM_AGENT_HOVER_DOWN), ANIM_REQUEST_STOP);
gSavedPerAccountSettings.setString("AODefaultFlyDown",stranim);
state = STATE_AGENT_HOVER_DOWN;
}
else if (box->getName() == "lands")
{
gAgent.sendAnimationRequest(GetAnimID(ANIM_AGENT_LAND), ANIM_REQUEST_STOP);
gSavedPerAccountSettings.setString("AODefaultLand",stranim);
state = STATE_AGENT_LAND;
}
else if (box->getName() == "standups")
{
gAgent.sendAnimationRequest(GetAnimID(ANIM_AGENT_STAND), ANIM_REQUEST_STOP);
gSavedPerAccountSettings.setString("AODefaultStandUp",stranim);
state = STATE_AGENT_STAND;
}
else if (box->getName() == "prejumps")
{
gAgent.sendAnimationRequest(GetAnimID(ANIM_AGENT_PRE_JUMP), ANIM_REQUEST_STOP);
gSavedPerAccountSettings.setString("AODefaultPreJump",stranim);
state = STATE_AGENT_PRE_JUMP;
}
for (std::vector<struct_overrides>::iterator iter = mAOOverrides.begin(); iter != mAOOverrides.end(); ++iter)
{
if (state == iter->state)
{
iter->ao_id = getAssetIDByName(stranim);
}
}
}
}
}
void LLFloaterAO::updateLayout(LLFloaterAO* floater)
{
if (floater)
{
BOOL advanced = gSavedSettings.getBOOL( "AOAdvanced");
if (advanced)
{
floater->reshape(610,380); //view->getRect().getWidth(), view->getUIWinHeightLong());
}
else
{
floater->reshape(200,380); //view->getRect().getWidth(), view->getUIWinHeightShort());
}
floater->childSetVisible("more_btn", !advanced);
floater->childSetVisible("less_btn", advanced);
floater->childSetVisible("tabcontainer", advanced);
floater->childSetVisible("tabdefaultanims", advanced);
floater->childSetVisible("textdefaultwalk", advanced);
floater->childSetVisible("textdefaultrun", advanced);
floater->childSetVisible("textdefaultjump", advanced);
floater->childSetVisible("textdefaultsit", advanced);
floater->childSetVisible("textdefaultgsit", advanced);
floater->childSetVisible("textdefaultcrouch", advanced);
floater->childSetVisible("textdefaultcrouchwalk", advanced);
floater->childSetVisible("textdefaultfall", advanced);
floater->childSetVisible("textdefaulthover", advanced);
floater->childSetVisible("textdefaultfly", advanced);
floater->childSetVisible("textdefaultflyslow", advanced);
floater->childSetVisible("textdefaultflyup", advanced);
floater->childSetVisible("textdefaultflydown", advanced);
floater->childSetVisible("textdefaultland", advanced);
floater->childSetVisible("textdefaultstandup", advanced);
floater->childSetVisible("textdefaultprejump", advanced);
floater->childSetVisible("walks", advanced);
floater->childSetVisible("runs", advanced);
floater->childSetVisible("jumps", advanced);
floater->childSetVisible("sits", advanced);
floater->childSetVisible("gsits", advanced);
floater->childSetVisible("crouchs", advanced);
floater->childSetVisible("crouchwalks", advanced);
floater->childSetVisible("falls", advanced);
floater->childSetVisible("hovers", advanced);
floater->childSetVisible("flys", advanced);
floater->childSetVisible("flyslows", advanced);
floater->childSetVisible("flyups", advanced);
floater->childSetVisible("flydowns", advanced);
floater->childSetVisible("lands", advanced);
floater->childSetVisible("standups", advanced);
floater->childSetVisible("prejumps", advanced);
}
}
void LLFloaterAO::init()
{
mAOStands.clear();
mAOTokens.clear();
mAOOverrides.clear();
struct_tokens tokenloader;
tokenloader.token =
tokenloader.token = "[ Sitting On Ground ]"; tokenloader.state = STATE_AGENT_GROUNDSIT; mAOTokens.push_back(tokenloader); // 0
tokenloader.token = "[ Sitting ]"; tokenloader.state = STATE_AGENT_SIT; mAOTokens.push_back(tokenloader); // 1
tokenloader.token = "[ Crouching ]"; tokenloader.state = STATE_AGENT_CROUCH; mAOTokens.push_back(tokenloader); // 3
tokenloader.token = "[ Crouch Walking ]"; tokenloader.state = STATE_AGENT_CROUCHWALK; mAOTokens.push_back(tokenloader); // 4
tokenloader.token = "[ Standing Up ]"; tokenloader.state = STATE_AGENT_STANDUP; mAOTokens.push_back(tokenloader); // 6
tokenloader.token = "[ Falling ]"; tokenloader.state = STATE_AGENT_FALLDOWN; mAOTokens.push_back(tokenloader); // 7
tokenloader.token = "[ Flying Down ]"; tokenloader.state = STATE_AGENT_HOVER_DOWN; mAOTokens.push_back(tokenloader); // 8
tokenloader.token = "[ Flying Up ]"; tokenloader.state = STATE_AGENT_HOVER_UP; mAOTokens.push_back(tokenloader); // 9
tokenloader.token = "[ Flying Slow ]"; tokenloader.state = STATE_AGENT_FLYSLOW; mAOTokens.push_back(tokenloader); // 10
tokenloader.token = "[ Flying ]"; tokenloader.state = STATE_AGENT_FLY; mAOTokens.push_back(tokenloader); // 11
tokenloader.token = "[ Hovering ]"; tokenloader.state = STATE_AGENT_HOVER; mAOTokens.push_back(tokenloader); // 12
tokenloader.token = "[ Jumping ]"; tokenloader.state = STATE_AGENT_JUMP; mAOTokens.push_back(tokenloader); // 13
tokenloader.token = "[ Pre Jumping ]"; tokenloader.state = STATE_AGENT_PRE_JUMP; mAOTokens.push_back(tokenloader); // 14
tokenloader.token = "[ Running ]"; tokenloader.state = STATE_AGENT_RUN; mAOTokens.push_back(tokenloader); // 15
tokenloader.token = "[ Turning Right ]"; tokenloader.state = STATE_AGENT_TURNRIGHT; mAOTokens.push_back(tokenloader); // 16
tokenloader.token = "[ Turning Left ]"; tokenloader.state = STATE_AGENT_TURNLEFT; mAOTokens.push_back(tokenloader); // 17
tokenloader.token = "[ Walking ]"; tokenloader.state = STATE_AGENT_WALK; mAOTokens.push_back(tokenloader); // 18
tokenloader.token = "[ Landing ]"; tokenloader.state = STATE_AGENT_LAND; mAOTokens.push_back(tokenloader); // 19
tokenloader.token = "[ Standing ]"; tokenloader.state = STATE_AGENT_STAND; mAOTokens.push_back(tokenloader); // 20
tokenloader.token = "[ Swimming Down ]"; tokenloader.state = 999; mAOTokens.push_back(tokenloader); // 21
tokenloader.token = "[ Swimming Up ]"; tokenloader.state = 999; mAOTokens.push_back(tokenloader); // 22
tokenloader.token = "[ Swimming Forward ]"; tokenloader.state = 999; mAOTokens.push_back(tokenloader); // 23
tokenloader.token = "[ Floating ]"; tokenloader.state = 999; mAOTokens.push_back(tokenloader); // 24
struct_overrides overrideloader;
overrideloader.orig_id = ANIM_AGENT_WALK; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_WALK; mAOOverrides.push_back(overrideloader);
overrideloader.orig_id = ANIM_AGENT_RUN; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_RUN; mAOOverrides.push_back(overrideloader);
overrideloader.orig_id = ANIM_AGENT_PRE_JUMP; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_PRE_JUMP; mAOOverrides.push_back(overrideloader);
overrideloader.orig_id = ANIM_AGENT_JUMP; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_JUMP; mAOOverrides.push_back(overrideloader);
overrideloader.orig_id = ANIM_AGENT_TURNLEFT; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_TURNLEFT; mAOOverrides.push_back(overrideloader);
overrideloader.orig_id = ANIM_AGENT_TURNRIGHT; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_TURNRIGHT; mAOOverrides.push_back(overrideloader);
overrideloader.orig_id = ANIM_AGENT_SIT; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_SIT; mAOOverrides.push_back(overrideloader);
overrideloader.orig_id = ANIM_AGENT_SIT_FEMALE; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_SIT; mAOOverrides.push_back(overrideloader);
overrideloader.orig_id = ANIM_AGENT_SIT_GENERIC; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_SIT; mAOOverrides.push_back(overrideloader);
overrideloader.orig_id = ANIM_AGENT_SIT_GROUND; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_GROUNDSIT; mAOOverrides.push_back(overrideloader);
overrideloader.orig_id = ANIM_AGENT_SIT_GROUND_CONSTRAINED; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_GROUNDSIT; mAOOverrides.push_back(overrideloader);
overrideloader.orig_id = ANIM_AGENT_HOVER; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_HOVER; mAOOverrides.push_back(overrideloader);
overrideloader.orig_id = ANIM_AGENT_HOVER_DOWN; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_HOVER_DOWN; mAOOverrides.push_back(overrideloader);
overrideloader.orig_id = ANIM_AGENT_HOVER_UP; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_HOVER_UP; mAOOverrides.push_back(overrideloader);
overrideloader.orig_id = ANIM_AGENT_CROUCH; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_CROUCH; mAOOverrides.push_back(overrideloader);
overrideloader.orig_id = ANIM_AGENT_CROUCHWALK; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_CROUCHWALK; mAOOverrides.push_back(overrideloader);
overrideloader.orig_id = ANIM_AGENT_FALLDOWN; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_FALLDOWN; mAOOverrides.push_back(overrideloader);
overrideloader.orig_id = ANIM_AGENT_STANDUP; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_STANDUP; mAOOverrides.push_back(overrideloader);
overrideloader.orig_id = ANIM_AGENT_LAND; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_LAND; mAOOverrides.push_back(overrideloader);
overrideloader.orig_id = ANIM_AGENT_FLY; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_FLY; mAOOverrides.push_back(overrideloader);
overrideloader.orig_id = ANIM_AGENT_FLYSLOW; overrideloader.ao_id = LLUUID::null; overrideloader.state = STATE_AGENT_FLYSLOW; mAOOverrides.push_back(overrideloader);
BOOL success = TRUE;
if(LLStartUp::getStartupState() >= STATE_INVENTORY_SEND)
{
if(LLInventoryModelBackgroundFetch::instance().isEverythingFetched())
{
LLUUID configncitem = (LLUUID)gSavedPerAccountSettings.getString("AOConfigNotecardID");
if (configncitem.notNull())
{
success = FALSE;
const LLInventoryItem* item = gInventory.getItem(configncitem);
if(item)
{
if (gAgent.allowOperation(PERM_COPY, item->getPermissions(),GP_OBJECT_MANIPULATE) || gAgent.isGodlike())
{
if(!item->getAssetUUID().isNull())
{
LLUUID* new_uuid = new LLUUID(configncitem);
LLHost source_sim = LLHost::invalid;
invfolderid = item->getParentUUID();
gAssetStorage->getInvItemAsset(source_sim,
gAgent.getID(),
gAgent.getSessionID(),
item->getPermissions().getOwner(),
LLUUID::null,
item->getUUID(),
item->getAssetUUID(),
item->getType(),
&onNotecardLoadComplete,
(void*)new_uuid,
TRUE);
success = TRUE;
}
}
}
}
}
}
if (!success)
{
cmdline_printchat("Could not read the specified Config Notecard");
}
// mAnimationState = 0;
// mCurrentStandId = LLUUID::null;
// setAnimationState(STATE_AGENT_IDLE);
}
void LLFloaterAO::onClickMore(void* data)
{
gSavedSettings.setBOOL( "AOAdvanced", TRUE );
updateLayout(sInstance);
}
void LLFloaterAO::onClickLess(void* data)
{
gSavedSettings.setBOOL( "AOAdvanced", FALSE );
updateLayout(sInstance);
}
void LLFloaterAO::onClickToggleAO(LLUICtrl *, void*)
{
run();
}
void LLFloaterAO::onClickToggleSits(LLUICtrl *, void*)
{
run();
}
void LLFloaterAO::run()
{
setAnimationState(STATE_AGENT_IDLE); // reset state
int state = getAnimationState(); // check if sitting or hovering
if ((state == STATE_AGENT_IDLE) || (state == STATE_AGENT_STAND))
{
if (gSavedSettings.getBOOL("AOEnabled"))
{
if (mAOStandTimer)
{
mAOStandTimer->reset();
ChangeStand();
}
else
{
mAOStandTimer = new AOStandTimer();
}
}
else
{
stopMotion(getCurrentStandId(), FALSE, TRUE); //stop stand first then set state
setAnimationState(STATE_AGENT_IDLE);
}
}
else
{
if (state == STATE_AGENT_SIT) gAgent.sendAnimationRequest(GetAnimIDFromState(state), (gSavedSettings.getBOOL("AOEnabled") && gSavedSettings.getBOOL("AOSitsEnabled")) ? ANIM_REQUEST_START : ANIM_REQUEST_STOP);
else gAgent.sendAnimationRequest(GetAnimIDFromState(state), gSavedSettings.getBOOL("AOEnabled") ? ANIM_REQUEST_START : ANIM_REQUEST_STOP);
}
}
int LLFloaterAO::getAnimationState()
{
if (gAgentAvatarp)
{
if (gAgentAvatarp->isSitting()) setAnimationState(STATE_AGENT_SIT);
else if (gAgent.getFlying()) setAnimationState(STATE_AGENT_HOVER);
}
return mAnimationState;
}
void LLFloaterAO::setAnimationState(const int state)
{
mAnimationState = state;
}
LLUUID LLFloaterAO::getCurrentStandId()
{
return mCurrentStandId;
}
void LLFloaterAO::setCurrentStandId(const LLUUID& id)
{
mCurrentStandId = id;
}
void LLFloaterAO::AOItemDrop(LLViewerInventoryItem* item)
{
gSavedPerAccountSettings.setString("AOConfigNotecardID", item->getUUID().asString());
sInstance->childSetValue("ao_nc_text", LLTrans::getString("CurrentlySetTo") + LLTrans::getString(":") + " " +item->getName());
}
LLUUID LLFloaterAO::GetAnimID(const LLUUID& id)
{
for (std::vector<struct_overrides>::iterator iter = mAOOverrides.begin(); iter != mAOOverrides.end(); ++iter)
{
if (iter->orig_id == id) return iter->ao_id;
}
return LLUUID::null;
}
int LLFloaterAO::GetStateFromAnimID(const LLUUID& id)
{
for (std::vector<struct_overrides>::iterator iter = mAOOverrides.begin(); iter != mAOOverrides.end(); ++iter)
{
if (iter->orig_id == id) return iter->state;
}
return STATE_AGENT_IDLE;
}
LLUUID LLFloaterAO::GetAnimIDFromState(const int state)
{
for (std::vector<struct_overrides>::iterator iter = mAOOverrides.begin(); iter != mAOOverrides.end(); ++iter)
{
if (iter->state == state) return iter->ao_id;
}
return LLUUID::null;
}
int LLFloaterAO::GetStateFromToken(std::string strtoken)
{
for (std::vector<struct_tokens>::iterator iter = mAOTokens.begin(); iter != mAOTokens.end(); ++iter)
{
if (iter->token == strtoken) return iter->state;
}
return STATE_AGENT_IDLE;
}
void LLFloaterAO::onClickPrevStand(void* user_data)
{
if (!(mAOStands.size() > 0)) return;
stand_iterator=stand_iterator-1;
if (stand_iterator < 0) stand_iterator = int( mAOStands.size()-stand_iterator);
if (stand_iterator > int( mAOStands.size()-1)) stand_iterator = 0;
cmdline_printchat(llformat("Changing stand to %s.",mAOStands[stand_iterator].anim_name.c_str()));
ChangeStand();
}
void LLFloaterAO::onClickNextStand(void* user_data)
{
if (!(mAOStands.size() > 0)) return;
stand_iterator=stand_iterator+1;
if (stand_iterator < 0) stand_iterator = int( mAOStands.size()-stand_iterator);
if (stand_iterator > int( mAOStands.size()-1)) stand_iterator = 0;
cmdline_printchat(llformat("Changing stand to %s.",mAOStands[stand_iterator].anim_name.c_str()));
ChangeStand();
}
BOOL LLFloaterAO::ChangeStand()
{
if (gSavedSettings.getBOOL("AOEnabled"))
{
if (gAgentAvatarp)
{
if (gSavedSettings.getBOOL("AONoStandsInMouselook") && gAgentCamera.cameraMouselook()) return FALSE;
if (gAgentAvatarp->isSitting())
{
// stopMotion(getCurrentStandId(), FALSE, TRUE); //stop stand first then set state
// if (getAnimationState() != STATE_AGENT_GROUNDSIT) setAnimationState(STATE_AGENT_SIT);
// setCurrentStandId(LLUUID::null);
return FALSE;
}
}
if ((getAnimationState() == STATE_AGENT_IDLE) || (getAnimationState() == STATE_AGENT_STAND))// stands have lowest priority
{
if (!(mAOStands.size() > 0)) return TRUE;
if (gSavedSettings.getBOOL("AOStandRandomize"))
{
stand_iterator = ll_rand(mAOStands.size()-1);
}
if (stand_iterator < 0) stand_iterator = int( mAOStands.size()-stand_iterator);
if (stand_iterator > int( mAOStands.size()-1)) stand_iterator = 0;
int stand_iterator_previous = stand_iterator -1;
if (stand_iterator_previous < 0) stand_iterator_previous = int( mAOStands.size()-1);
if (mAOStands[stand_iterator].ao_id.notNull())
{
stopMotion(getCurrentStandId(), FALSE, TRUE); //stop stand first then set state
startMotion(mAOStands[stand_iterator].ao_id, 0, TRUE);
setAnimationState(STATE_AGENT_STAND);
setCurrentStandId(mAOStands[stand_iterator].ao_id);
if ((sInstance)&&(mcomboBox_stands)) mcomboBox_stands->selectNthItem(stand_iterator);
// llinfos << "changing stand to " << mAOStands[stand_iterator].anim_name << llendl;
return FALSE;
}
}
}
else
{
stopMotion(getCurrentStandId(), FALSE, TRUE);
return TRUE; //stop if ao is off
}
return TRUE;
}
BOOL LLFloaterAO::startMotion(const LLUUID& id, F32 time_offset, BOOL stand)
{
if (stand)
{
if (id.notNull())
{
BOOL sitting = FALSE;
if (gAgentAvatarp)
{
sitting = gAgentAvatarp->isSitting();
}
if (sitting) return FALSE;
gAgent.sendAnimationRequest(id, ANIM_REQUEST_START);
return TRUE;
}
}
else
{
if (GetAnimID(id).notNull() && gSavedSettings.getBOOL("AOEnabled"))
{
stopMotion(getCurrentStandId(), FALSE, TRUE); //stop stand first then set state
setAnimationState(GetStateFromAnimID(id));
// llinfos << " state " << getAnimationState() << " start anim " << id << " overriding with " << GetAnimID(id) << llendl;
if ((GetStateFromAnimID(id) == STATE_AGENT_SIT) && !(gSavedSettings.getBOOL("AOSitsEnabled"))) return TRUE;
gAgent.sendAnimationRequest(GetAnimID(id), ANIM_REQUEST_START);
return TRUE;
}
}
return FALSE;
}
BOOL LLFloaterAO::stopMotion(const LLUUID& id, BOOL stop_immediate, BOOL stand)
{
if (stand)
{
setAnimationState(STATE_AGENT_IDLE);
gAgent.sendAnimationRequest(id, ANIM_REQUEST_STOP);
return TRUE;
}
else
{
if (GetAnimID(id).notNull() && gSavedSettings.getBOOL("AOEnabled"))
{
// llinfos << " state " << getAnimationState() << "/" << GetStateFromAnimID(id) << "(now 0) stop anim " << id << " overriding with " << GetAnimID(id) << llendl;
if (getAnimationState() == GetStateFromAnimID(id))
{
setAnimationState(STATE_AGENT_IDLE);
}
ChangeStand(); // startMotion(getCurrentStandId(), 0, TRUE);
gAgent.sendAnimationRequest(GetAnimID(id), ANIM_REQUEST_STOP);
return TRUE;
}
}
return FALSE;
}
void LLFloaterAO::onClickReloadCard(void* user_data)
{
if(LLInventoryModelBackgroundFetch::instance().isEverythingFetched())
{
LLFloaterAO::init();
}
}
void LLFloaterAO::onClickOpenCard(void* user_data)
{
if(LLInventoryModelBackgroundFetch::instance().isEverythingFetched())
{
LLUUID configncitem = (LLUUID)gSavedPerAccountSettings.getString("AOConfigNotecardID");
if (configncitem.notNull())
{
const LLInventoryItem* item = gInventory.getItem(configncitem);
if(item)
{
if (gAgent.allowOperation(PERM_COPY, item->getPermissions(),GP_OBJECT_MANIPULATE) || gAgent.isGodlike())
{
if(!item->getAssetUUID().isNull())
open_notecard((LLViewerInventoryItem*)item, std::string("Note: ") + item->getName(), LLUUID::null, FALSE);
// open_notecard((LLViewerInventoryItem*)item, std::string("Note: ") + item->getName(), LLUUID::null, FALSE, LLUUID::null, FALSE);
}
}
}
}
}
void LLFloaterAO::onClickNewCard(void* user_data)
{
// load the template file from app_settings/ao_template.ini then
// create a new properly-formatted notecard in the user's inventory
std::string ao_template = gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "ao_template.ini");
if (!ao_template.empty())
{
LLPointer<LLInventoryCallback> cb = new AONotecardCallback(ao_template);
create_inventory_item(gAgent.getID(), gAgent.getSessionID(),
LLUUID::null, LLTransactionID::tnull, "New AO Notecard",
"Drop this notecard in your AO window to use", LLAssetType::AT_NOTECARD,
LLInventoryType::IT_NOTECARD, NOT_WEARABLE, PERM_ALL, cb);
}
else
{
llwarns << "Can't find ao_template.ini in app_settings!" << llendl;
}
}
struct AOAssetInfo
{
std::string path;
std::string name;
};
void LLFloaterAO::onNotecardLoadComplete(LLVFS *vfs,const LLUUID& asset_uuid,LLAssetType::EType type,void* user_data, S32 status, LLExtStat ext_status)
{
if(status == LL_ERR_NOERR)
{
S32 size = vfs->getSize(asset_uuid, type);
U8* buffer = new U8[size];
vfs->getData(asset_uuid, type, buffer, 0, size);
if(type == LLAssetType::AT_NOTECARD)
{
LLViewerTextEditor* edit = new LLViewerTextEditor("",LLRect(0,0,0,0),S32_MAX,"");
if(edit->importBuffer((char*)buffer, (S32)size))
{
llinfos << "ao nc decode success" << llendl;
std::string card = edit->getText();
edit->die();
if (mcomboBox_stands)
{
mcomboBox_stands->clear();
mcomboBox_stands->removeall();
}
if (mcomboBox_walks) mcomboBox_walks->clear();
if (mcomboBox_runs) mcomboBox_runs->clear();
if (mcomboBox_jumps) mcomboBox_jumps->clear();
if (mcomboBox_sits) mcomboBox_sits->clear();
if (mcomboBox_gsits) mcomboBox_gsits->clear();
if (mcomboBox_crouchs) mcomboBox_cwalks->clear();
if (mcomboBox_cwalks) mcomboBox_cwalks->clear();
if (mcomboBox_falls) mcomboBox_falls->clear();
if (mcomboBox_hovers) mcomboBox_hovers->clear();
if (mcomboBox_flys) mcomboBox_flys->clear();
if (mcomboBox_flyslows) mcomboBox_flyslows->clear();
if (mcomboBox_flyups) mcomboBox_flyups->clear();
if (mcomboBox_flydowns) mcomboBox_flydowns->clear();
if (mcomboBox_lands) mcomboBox_lands->clear();
if (mcomboBox_standups) mcomboBox_standups->clear();
if (mcomboBox_prejumps) mcomboBox_prejumps->clear();
struct_stands loader;
typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
boost::char_separator<char> sep("\n");
tokenizer tokline(card, sep);
for (tokenizer::iterator line = tokline.begin(); line != tokline.end(); ++line)
{
// llinfos << *line << llendl;
std::string strline(*line);
// llinfos << "uncommented line: " << strline << llendl;
boost::regex type("^(\\s*)(\\[ )(.*)( \\])");
boost::smatch what;
if (boost::regex_search(strline, what, type))
{
// llinfos << "type: " << what[0] << llendl;
// llinfos << "anims in type: " << boost::regex_replace(strline, type, "") << llendl;
boost::char_separator<char> sep("|,");
std::string stranimnames(boost::regex_replace(strline, type, ""));
tokenizer tokanimnames(stranimnames, sep);
for (tokenizer::iterator anim = tokanimnames.begin(); anim != tokanimnames.end(); ++anim)
{
std::string strtoken(what[0]);
std::string stranim(*anim);
LLUUID animid(getAssetIDByName(stranim));
// llinfos << invfolderid.asString().c_str() << llendl;
// llinfos << "anim: " << stranim.c_str() << " assetid: " << animid << llendl;
if (!(animid.notNull()))
{
cmdline_printchat(llformat("Warning: animation '%s' could not be found (Section: %s).",stranim.c_str(),strtoken.c_str()));
}
else
{
switch(GetStateFromToken(strtoken.c_str()))
{
case STATE_AGENT_STAND:
loader.ao_id = animid; loader.anim_name = stranim.c_str(); mAOStands.push_back(loader);
if(mcomboBox_stands != NULL) mcomboBox_stands->add(stranim.c_str(), ADD_BOTTOM, TRUE);
break;
case STATE_AGENT_WALK:
{
if (sInstance && (mcomboBox_walks != NULL))
{
//llinfos << "1 anim: " << stranim.c_str() << " assetid: " << animid << llendl;
if (!(mcomboBox_walks->selectByValue(stranim.c_str()))) mcomboBox_walks->add(stranim.c_str(), ADD_BOTTOM, TRUE); //check if exist
}
}
break;
case STATE_AGENT_RUN:
{
if (sInstance && (mcomboBox_runs != NULL))
{
if (!(mcomboBox_runs->selectByValue(stranim.c_str()))) mcomboBox_runs->add(stranim.c_str(), ADD_BOTTOM, TRUE); //check if exist
}
}
break;
case STATE_AGENT_JUMP:
{
if (sInstance && (mcomboBox_jumps != NULL))
{
if (!(mcomboBox_jumps->selectByValue(stranim.c_str()))) mcomboBox_jumps->add(stranim.c_str(), ADD_BOTTOM, TRUE); //check if exist
}
}
break;
case STATE_AGENT_SIT:
{
if (sInstance && (mcomboBox_sits != NULL))
{
if (!(mcomboBox_sits->selectByValue(stranim.c_str()))) mcomboBox_sits->add(stranim.c_str(), ADD_BOTTOM, TRUE); //check if exist
}
}
break;
case STATE_AGENT_GROUNDSIT:
{
if (sInstance && (mcomboBox_gsits != NULL))
{
if (!(mcomboBox_gsits->selectByValue(stranim.c_str()))) mcomboBox_gsits->add(stranim.c_str(), ADD_BOTTOM, TRUE); //check if exist
}
}
break;
case STATE_AGENT_CROUCH:
{
if (sInstance && (mcomboBox_crouchs != NULL))
{
if (!(mcomboBox_crouchs->selectByValue(stranim.c_str()))) mcomboBox_crouchs->add(stranim.c_str(), ADD_BOTTOM, TRUE); //check if exist
}
}
break;
case STATE_AGENT_CROUCHWALK:
{
if (sInstance && (mcomboBox_cwalks != NULL))
{
if (!(mcomboBox_cwalks->selectByValue(stranim.c_str()))) mcomboBox_cwalks->add(stranim.c_str(), ADD_BOTTOM, TRUE); //check if exist
}
}
break;
case STATE_AGENT_FALLDOWN:
{
if (sInstance && (mcomboBox_falls != NULL))
{
if (!(mcomboBox_falls->selectByValue(stranim.c_str()))) mcomboBox_falls->add(stranim.c_str(), ADD_BOTTOM, TRUE); //check if exist
}
}
break;
case STATE_AGENT_HOVER:
{
if (sInstance && (mcomboBox_hovers != NULL))
{
if (!(mcomboBox_hovers->selectByValue(stranim.c_str()))) mcomboBox_hovers->add(stranim.c_str(), ADD_BOTTOM, TRUE); //check if exist
}
}
break;
case STATE_AGENT_FLY:
{
if (sInstance && (mcomboBox_flys != NULL))
{
if (!(mcomboBox_flys->selectByValue(stranim.c_str()))) mcomboBox_flys->add(stranim.c_str(), ADD_BOTTOM, TRUE); //check if exist
}
}
break;
case STATE_AGENT_FLYSLOW:
{
if (sInstance && (mcomboBox_flyslows != NULL))
{
if (!(mcomboBox_flyslows->selectByValue(stranim.c_str()))) mcomboBox_flyslows->add(stranim.c_str(), ADD_BOTTOM, TRUE); //check if exist
}
}
break;
case STATE_AGENT_HOVER_UP:
{
if (sInstance && (mcomboBox_flyups != NULL))
{
if (!(mcomboBox_flyups->selectByValue(stranim.c_str()))) mcomboBox_flyups->add(stranim.c_str(), ADD_BOTTOM, TRUE); //check if exist
}
}
break;
case STATE_AGENT_HOVER_DOWN:
{
if (sInstance && (mcomboBox_flydowns != NULL))
{
if (!(mcomboBox_flydowns->selectByValue(stranim.c_str()))) mcomboBox_flydowns->add(stranim.c_str(), ADD_BOTTOM, TRUE); //check if exist
}
}
break;
case STATE_AGENT_LAND:
{
if (sInstance && (mcomboBox_lands != NULL))
{
if (!(mcomboBox_lands->selectByValue(stranim.c_str()))) mcomboBox_lands->add(stranim.c_str(), ADD_BOTTOM, TRUE); //check if exist
}
}
break;
case STATE_AGENT_STANDUP:
{
if (sInstance && (mcomboBox_standups != NULL))
{
if (!(mcomboBox_standups->selectByValue(stranim.c_str()))) mcomboBox_standups->add(stranim.c_str(), ADD_BOTTOM, TRUE); //check if exist
}
}
break;
case STATE_AGENT_PRE_JUMP:
{
if (sInstance && (mcomboBox_prejumps != NULL))
{
if (!(mcomboBox_prejumps->selectByValue(stranim.c_str()))) mcomboBox_prejumps->add(stranim.c_str(), ADD_BOTTOM, TRUE); //check if exist
}
}
break;
}
for (std::vector<struct_overrides>::iterator iter = mAOOverrides.begin(); iter != mAOOverrides.end(); ++iter)
{
if (GetStateFromToken(strtoken.c_str()) == iter->state)
{
iter->ao_id = animid;
}
}
}
}
}
}
llinfos << "ao nc read sucess" << llendl;
for (std::vector<struct_overrides>::iterator iter = mAOOverrides.begin(); iter != mAOOverrides.end(); ++iter)
{
switch(iter->state)
{
case STATE_AGENT_WALK:
{
std::string defaultanim = gSavedPerAccountSettings.getString("AODefaultWalk");
SetDefault(mcomboBox_walks,iter->ao_id,defaultanim);
if (getAssetIDByName(defaultanim) != LLUUID::null) iter->ao_id = getAssetIDByName(defaultanim);
}
break;
case STATE_AGENT_RUN:
{
std::string defaultanim = gSavedPerAccountSettings.getString("AODefaultRun");
SetDefault(mcomboBox_runs,iter->ao_id,defaultanim);
if (getAssetIDByName(defaultanim) != LLUUID::null) iter->ao_id = getAssetIDByName(defaultanim);
}
break;
case STATE_AGENT_JUMP:
{
std::string defaultanim = gSavedPerAccountSettings.getString("AODefaultJump");
SetDefault(mcomboBox_jumps,iter->ao_id,defaultanim);
if (getAssetIDByName(defaultanim) != LLUUID::null) iter->ao_id = getAssetIDByName(defaultanim);
}
break;
case STATE_AGENT_SIT:
{
std::string defaultanim = gSavedPerAccountSettings.getString("AODefaultSit");
SetDefault(mcomboBox_sits,iter->ao_id,defaultanim);
if (getAssetIDByName(defaultanim) != LLUUID::null) iter->ao_id = getAssetIDByName(defaultanim);
}
break;
case STATE_AGENT_CROUCH:
{
std::string defaultanim = gSavedPerAccountSettings.getString("AODefaultCrouch");
SetDefault(mcomboBox_crouchs,iter->ao_id,defaultanim);
if (getAssetIDByName(defaultanim) != LLUUID::null) iter->ao_id = getAssetIDByName(defaultanim);
}
break;
case STATE_AGENT_GROUNDSIT:
{
std::string defaultanim = gSavedPerAccountSettings.getString("AODefaultGroundSit");
SetDefault(mcomboBox_gsits,iter->ao_id,defaultanim);
if (getAssetIDByName(defaultanim) != LLUUID::null) iter->ao_id = getAssetIDByName(defaultanim);
}
break;
case STATE_AGENT_CROUCHWALK:
{
std::string defaultanim = gSavedPerAccountSettings.getString("AODefaultCrouchWalk");
SetDefault(mcomboBox_cwalks,iter->ao_id,defaultanim);
if (getAssetIDByName(defaultanim) != LLUUID::null) iter->ao_id = getAssetIDByName(defaultanim);
}
break;
case STATE_AGENT_FALLDOWN:
{
std::string defaultanim = gSavedPerAccountSettings.getString("AODefaultFall");
SetDefault(mcomboBox_falls,iter->ao_id,defaultanim);
if (getAssetIDByName(defaultanim) != LLUUID::null) iter->ao_id = getAssetIDByName(defaultanim);
}
break;
case STATE_AGENT_HOVER:
{
std::string defaultanim = gSavedPerAccountSettings.getString("AODefaultHover");
SetDefault(mcomboBox_hovers,iter->ao_id,defaultanim);
if (getAssetIDByName(defaultanim) != LLUUID::null) iter->ao_id = getAssetIDByName(defaultanim);
}
break;
case STATE_AGENT_FLY:
{
std::string defaultanim = gSavedPerAccountSettings.getString("AODefaultFly");
SetDefault(mcomboBox_flys,iter->ao_id,defaultanim);
if (getAssetIDByName(defaultanim) != LLUUID::null) iter->ao_id = getAssetIDByName(defaultanim);
}
break;
case STATE_AGENT_HOVER_UP:
{
std::string defaultanim = gSavedPerAccountSettings.getString("AODefaultFlyUp");
SetDefault(mcomboBox_flyups,iter->ao_id,defaultanim);
if (getAssetIDByName(defaultanim) != LLUUID::null) iter->ao_id = getAssetIDByName(defaultanim);
}
break;
case STATE_AGENT_FLYSLOW:
{
std::string defaultanim = gSavedPerAccountSettings.getString("AODefaultFlySlow");
SetDefault(mcomboBox_flyslows,iter->ao_id,defaultanim);
if (getAssetIDByName(defaultanim) != LLUUID::null) iter->ao_id = getAssetIDByName(defaultanim);
}
break;
case STATE_AGENT_HOVER_DOWN:
{
std::string defaultanim = gSavedPerAccountSettings.getString("AODefaultFlyDown");
SetDefault(mcomboBox_flydowns,iter->ao_id,defaultanim);
if (getAssetIDByName(defaultanim) != LLUUID::null) iter->ao_id = getAssetIDByName(defaultanim);
}
break;
case STATE_AGENT_LAND:
{
std::string defaultanim = gSavedPerAccountSettings.getString("AODefaultLand");
SetDefault(mcomboBox_lands,iter->ao_id,defaultanim);
if (getAssetIDByName(defaultanim) != LLUUID::null) iter->ao_id = getAssetIDByName(defaultanim);
}
break;
case STATE_AGENT_STANDUP:
{
std::string defaultanim = gSavedPerAccountSettings.getString("AODefaultStandUp");
SetDefault(mcomboBox_standups,iter->ao_id,defaultanim);
if (getAssetIDByName(defaultanim) != LLUUID::null) iter->ao_id = getAssetIDByName(defaultanim);
}
break;
case STATE_AGENT_PRE_JUMP:
{
std::string defaultanim = gSavedPerAccountSettings.getString("AODefaultPreJump");
SetDefault(mcomboBox_prejumps,iter->ao_id,defaultanim);
if (getAssetIDByName(defaultanim) != LLUUID::null) iter->ao_id = getAssetIDByName(defaultanim);
}
break;
}
}
run();
}
else
{
llinfos << "ao nc decode error" << llendl;
}
}
}
else
{
llinfos << "ao nc read error" << llendl;
}
}
BOOL LLFloaterAO::SetDefault(void* userdata, LLUUID ao_id, std::string defaultanim)
{
if (sInstance && (userdata))
{
LLComboBox *box = (LLComboBox *) userdata;
if (LLUUID::null == ao_id)
{
box->clear();
box->removeall();
}
else
{
box->selectByValue(defaultanim);
}
}
return TRUE;
}
class ObjectNameMatches : public LLInventoryCollectFunctor
{
public:
ObjectNameMatches(std::string name)
{
sName = name;
}
virtual ~ObjectNameMatches() {}
virtual bool operator()(LLInventoryCategory* cat,
LLInventoryItem* item)
{
if(item)
{
if (item->getParentUUID() == LLFloaterAO::invfolderid)
{
return (item->getName() == sName);
}
return false;
}
return false;
}
private:
std::string sName;
};
const LLUUID& LLFloaterAO::getAssetIDByName(const std::string& name)
{
if (name.empty() || !(LLInventoryModelBackgroundFetch::instance().isEverythingFetched())) return LLUUID::null;
LLViewerInventoryCategory::cat_array_t cats;
LLViewerInventoryItem::item_array_t items;
ObjectNameMatches objectnamematches(name);
gInventory.collectDescendentsIf(LLUUID::null,cats,items,FALSE,objectnamematches);
if (items.count())
{
return items[0]->getAssetUUID();
}
return LLUUID::null;
};
Reference in New Issue View Git Blame Copy Permalink