void handle_png_options(std::string const& type,
int * colors,
int * compression,
int * strategy,
int * trans_mode,
double * gamma,
bool * use_octree)
{
if (type == "png" || type == "png24" || type == "png32")
{
// Shortcut when the user didn't specify any flags after the colon.
// Paletted images specify "png8 or png256".
*colors = -1;
return;
}
// TODO - convert to spirit parser
if (type.length() > 6){
boost::char_separator<char> sep(":");
boost::tokenizer< boost::char_separator<char> > tokens(type, sep);
BOOST_FOREACH(std::string t, tokens)
{
if (t == "png" || t == "png24" || t == "png32")
{
*colors = -1;
}
else if (t == "m=h")
{
*use_octree = false;
}
else if (t == "m=o")
{
*use_octree = true;
}
else if (boost::algorithm::starts_with(t, "c="))
{
if (*colors < 0)
throw ImageWriterException("invalid color parameter: unavailable for true color images");
if (!mapnik::util::string2int(t.substr(2),*colors) || *colors < 0 || *colors > 256)
throw ImageWriterException("invalid color parameter: " + t.substr(2));
}
else if (boost::algorithm::starts_with(t, "t="))
{
if (*colors < 0)
throw ImageWriterException("invalid trans_mode parameter: unavailable for true color images");
if (!mapnik::util::string2int(t.substr(2),*trans_mode) || *trans_mode < 0 || *trans_mode > 2)
throw ImageWriterException("invalid trans_mode parameter: " + t.substr(2));
}
else if (boost::algorithm::starts_with(t, "g="))
{
if (*colors < 0)
throw ImageWriterException("invalid gamma parameter: unavailable for true color images");
if (!mapnik::util::string2double(t.substr(2),*gamma) || *gamma < 0)
{
throw ImageWriterException("invalid gamma parameter: " + t.substr(2));
}
}
else if (boost::algorithm::starts_with(t, "z="))
{
/*
#define Z_NO_COMPRESSION 0
#define Z_BEST_SPEED 1
#define Z_BEST_COMPRESSION 9
#define Z_DEFAULT_COMPRESSION (-1)
*/
if (!mapnik::util::string2int(t.substr(2),*compression)
|| *compression < Z_DEFAULT_COMPRESSION
|| *compression > Z_BEST_COMPRESSION)
{
throw ImageWriterException("invalid compression parameter: " + t.substr(2) + " (only -1 through 9 are valid)");
}
}
else if (boost::algorithm::starts_with(t, "s="))
{
std::string const& s = t.substr(2);
if (s == "default")
{
*strategy = Z_DEFAULT_STRATEGY;
}
else if (s == "filtered")
{
*strategy = Z_FILTERED;
}
else if (s == "huff")
{
*strategy = Z_HUFFMAN_ONLY;
}
else if (s == "rle")
{
*strategy = Z_RLE;
}
else
{
throw ImageWriterException("invalid compression strategy parameter: " + s);
}
}
}
}
bool Item::LoadFromDB(uint32 guid, uint64 owner_guid, Field* fields, uint32 entry)
{
// 0 1 2 3 4 5 6 7 8 9 10
//result = CharacterDatabase.PQuery("SELECT creatorGuid, giftCreatorGuid, count, duration, charges, flags, enchantments, randomPropertyId, durability, playedTime, text FROM item_instance WHERE guid = '%u'", guid);
// create item before any checks for store correct guid
// and allow use "FSetState(ITEM_REMOVED); SaveToDB();" for deleting item from DB
Object::_Create(guid, 0, HIGHGUID_ITEM);
// Set entry, MUST be before proto check
SetEntry(entry);
SetFloatValue(OBJECT_FIELD_SCALE_X, 1.0f);
ItemTemplate const* proto = GetTemplate();
if (!proto)
return false;
// set owner (not if item is only loaded for gbank/auction/mail
if (owner_guid != 0)
SetOwnerGUID(owner_guid);
bool need_save = false; // need explicit save data at load fixes
SetUInt64Value(ITEM_FIELD_CREATOR, MAKE_NEW_GUID(fields[0].GetUInt32(), 0, HIGHGUID_PLAYER));
SetUInt64Value(ITEM_FIELD_GIFTCREATOR, MAKE_NEW_GUID(fields[1].GetUInt32(), 0, HIGHGUID_PLAYER));
SetCount(fields[2].GetUInt32());
uint32 duration = fields[3].GetUInt32();
SetUInt32Value(ITEM_FIELD_DURATION, duration);
// update duration if need, and remove if not need
if ((proto->Duration == 0) != (duration == 0))
{
SetUInt32Value(ITEM_FIELD_DURATION, abs(proto->Duration));
need_save = true;
}
Tokens tokens(fields[4].GetString(), ' ', MAX_ITEM_PROTO_SPELLS);
if (tokens.size() == MAX_ITEM_PROTO_SPELLS)
for (uint8 i = 0; i < MAX_ITEM_PROTO_SPELLS; ++i)
SetSpellCharges(i, atoi(tokens[i]));
SetUInt32Value(ITEM_FIELD_FLAGS, fields[5].GetUInt32());
// Remove bind flag for items vs NO_BIND set
if (IsSoulBound() && proto->Bonding == NO_BIND)
{
ApplyModFlag(ITEM_FIELD_FLAGS, ITEM_FLAG_SOULBOUND, false);
need_save = true;
}
std::string enchants = fields[6].GetString();
_LoadIntoDataField(enchants.c_str(), ITEM_FIELD_ENCHANTMENT_1_1, MAX_ENCHANTMENT_SLOT * MAX_ENCHANTMENT_OFFSET);
SetInt32Value(ITEM_FIELD_RANDOM_PROPERTIES_ID, fields[7].GetInt16());
// recalculate suffix factor
if (GetItemRandomPropertyId() < 0)
UpdateItemSuffixFactor();
uint32 durability = fields[8].GetUInt16();
SetUInt32Value(ITEM_FIELD_DURABILITY, durability);
// update max durability (and durability) if need
SetUInt32Value(ITEM_FIELD_MAXDURABILITY, proto->MaxDurability);
if (durability > proto->MaxDurability)
{
SetUInt32Value(ITEM_FIELD_DURABILITY, proto->MaxDurability);
need_save = true;
}
SetUInt32Value(ITEM_FIELD_CREATE_PLAYED_TIME, fields[9].GetUInt32());
SetText(fields[10].GetString());
if (need_save) // normal item changed state set not work at loading
{
PreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_ITEM_INSTANCE_ON_LOAD);
stmt->setUInt32(0, GetUInt32Value(ITEM_FIELD_DURATION));
stmt->setUInt32(1, GetUInt32Value(ITEM_FIELD_FLAGS));
stmt->setUInt32(2, GetUInt32Value(ITEM_FIELD_DURABILITY));
stmt->setUInt32(3, guid);
CharacterDatabase.Execute(stmt);
}
return true;
}
// BuildArgs
//------------------------------------------------------------------------------
bool CSNode::BuildArgs( Args & fullArgs ) const
{
// split into tokens
Array< AString > tokens( 1024, true );
m_CompilerArgs.Tokenize( tokens );
AStackString<> quote( "\"" );
const AString * const end = tokens.End();
for ( const AString * it = tokens.Begin(); it!=end; ++it )
{
const AString & token = *it;
if ( token.EndsWith( "%1" ) )
{
// handle /Option:%1 -> /Option:A /Option:B /Option:C
AStackString<> pre;
if ( token.GetLength() > 2 )
{
pre.Assign( token.Get(), token.GetEnd() - 2 );
}
// concatenate files, unquoted
GetInputFiles( fullArgs, pre, AString::GetEmpty() );
}
else if ( token.EndsWith( "\"%1\"" ) )
{
// handle /Option:"%1" -> /Option:"A" /Option:"B" /Option:"C"
AStackString<> pre( token.Get(), token.GetEnd() - 3 ); // 3 instead of 4 to include quote
// concatenate files, quoted
GetInputFiles( fullArgs, pre, quote );
}
else if ( token.EndsWith( "%2" ) )
{
// handle /Option:%2 -> /Option:A
if ( token.GetLength() > 2 )
{
fullArgs += AStackString<>( token.Get(), token.GetEnd() - 2 );
}
fullArgs += m_Name;
}
else if ( token.EndsWith( "\"%2\"" ) )
{
// handle /Option:"%2" -> /Option:"A"
AStackString<> pre( token.Get(), token.GetEnd() - 3 ); // 3 instead of 4 to include quote
fullArgs += pre;
fullArgs += m_Name;
fullArgs += '"'; // post
}
else if ( token.EndsWith( "%3" ) )
{
// handle /Option:%3 -> /Option:A,B,C
AStackString<> pre( token.Get(), token.GetEnd() - 2 );
fullArgs += pre;
// concatenate files, unquoted
GetExtraRefs( fullArgs, AString::GetEmpty(), AString::GetEmpty() );
}
else if ( token.EndsWith( "\"%3\"" ) )
{
// handle /Option:"%3" -> /Option:"A","B","C"
AStackString<> pre( token.Get(), token.GetEnd() - 4 );
fullArgs += pre;
// concatenate files, quoted
GetExtraRefs( fullArgs, quote, quote );
}
else
{
fullArgs += token;
}
fullArgs.AddDelimiter();
}
// Handle all the special needs of args
const bool canUseResponseFile( true );
if ( fullArgs.Finalize( m_CompilerPath, GetName(), canUseResponseFile ) == false )
{
return false; // Finalize will have emitted an error
}
return true;
}
/**
char* upload_pick(void* data)
If applicable, brings up a file chooser in which the user selects a file
to upload for a particular task. If the file is valid for the given action,
returns the string to the full path filename, else returns NULL.
Data is the load filter for the type of file as defined in LLFilePicker.
**/
const std::string upload_pick(void* data)
{
if( gAgentCamera.cameraMouselook() )
{
gAgentCamera.changeCameraToDefault();
// This doesn't seem necessary. JC
// display();
}
LLFilePicker::ELoadFilter type;
if(data)
{
type = (LLFilePicker::ELoadFilter)((intptr_t)data);
}
else
{
type = LLFilePicker::FFLOAD_ALL;
}
LLFilePicker& picker = LLFilePicker::instance();
if (!picker.getOpenFile(type))
{
llinfos << "Couldn't import objects from file" << llendl;
return std::string();
}
const std::string& filename = picker.getFirstFile();
std::string ext = gDirUtilp->getExtension(filename);
//strincmp doesn't like NULL pointers
if (ext.empty())
{
std::string short_name = gDirUtilp->getBaseFileName(filename);
// No extension
LLSD args;
args["FILE"] = short_name;
LLNotificationsUtil::add("NoFileExtension", args);
return std::string();
}
else
{
//so there is an extension
//loop over the valid extensions and compare to see
//if the extension is valid
//now grab the set of valid file extensions
std::string valid_extensions = build_extensions_string(type);
BOOL ext_valid = FALSE;
typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
boost::char_separator<char> sep(" ");
tokenizer tokens(valid_extensions, sep);
tokenizer::iterator token_iter;
//now loop over all valid file extensions
//and compare them to the extension of the file
//to be uploaded
for( token_iter = tokens.begin();
token_iter != tokens.end() && ext_valid != TRUE;
++token_iter)
{
const std::string& cur_token = *token_iter;
if (cur_token == ext || cur_token == "*.*")
{
//valid extension
//or the acceptable extension is any
ext_valid = TRUE;
}
}//end for (loop over all tokens)
if (ext_valid == FALSE)
{
//should only get here if the extension exists
//but is invalid
LLSD args;
args["EXTENSION"] = ext;
args["VALIDS"] = valid_extensions;
LLNotificationsUtil::add("InvalidFileExtension", args);
return std::string();
}
}//end else (non-null extension)
//valid file extension
//now we check to see
//if the file is actually a valid image/sound/etc.
if (type == LLFilePicker::FFLOAD_WAV)
{
// pre-qualify wavs to make sure the format is acceptable
std::string error_msg;
if (check_for_invalid_wav_formats(filename,error_msg))
{
llinfos << error_msg << ": " << filename << llendl;
LLSD args;
args["FILE"] = filename;
LLNotificationsUtil::add( error_msg, args );
return std::string();
}
}//end if a wave/sound file
return filename;
}
Modifier*
Modifier::from_string(const std::string& name, const std::string& value)
{
if (name == "axismap")
{
return AxismapModifier::from_string(value);
}
else if (name == "buttonmap" || name == "btnmap")
{
return ButtonmapModifier::from_string(value);
}
else
{
typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
tokenizer tokens(value, boost::char_separator<char>(":", "", boost::keep_empty_tokens));
std::vector<std::string> args(tokens.begin(), tokens.end());
if (name == "dpad-rotation" || name == "dpad-rotate")
{
return DpadRotationModifier::from_string(args);
}
else if (name == "4wayrest" || name == "four-way-restrictor")
{
return FourWayRestrictorModifier::from_string(args);
}
else if (name == "square" || name == "square-axis")
{
return SquareAxisModifier::from_string(args);
}
else if (name == "rotate")
{
return RotateAxisModifier::from_string(args);
}
else if (name == "stat" || name == "statistic")
{
return StatisticModifier::from_string(args);
}
else if (name == "dpad-restrictor")
{
return DpadRestrictorModifier::from_string(args);
}
else if (name == "btn2axis" || name == "button2axis")
{
return Button2AxisModifier::from_string(args);
}
else if (name == "acc2axis")
{
return Acc2AxisModifier::from_string(args);
}
else if (name == "ir2axis")
{
return IR2AxisModifier::from_string(args);
}
else if (name == "stickzone")
{
return StickZoneModifier::from_string(args);
}
else if (name == "split-axis" || name == "splitaxis")
{
return SplitAxisModifier::from_string(args);
}
else if (name == "join-axis" || name == "joinaxis")
{
return JoinAxisModifier::from_string(args);
}
else if (name == "sector2btn" || name == "sector2button")
{
return Sector2ButtonModifier::from_string(args);
}
else if (name == "latency")
{
return LatencyModifier::from_string(args);
}
else if (name == "copy")
{
if (args.size() < 2)
{
raise_exception(std::runtime_error, "'copy' modifier requires at least two arguments");
}
else
{
switch(get_event_type(args[0]))
{
case EV_REL:
case EV_ABS:
raise_exception(std::runtime_error, "not implemented");
break;
case EV_KEY:
return KeyCopyModifier::from_string(args);
default:
raise_exception(std::runtime_error, "'copy' modifier couldn't guess");
}
}
}
else if (name == "key-copy")
{
return KeyCopyModifier::from_string(args);
}
else if (name == "log")
{
return LogModifier::from_string(value);
}
else if (name == "compat")
{
return new CompatModifier;
}
else
{
throw std::runtime_error("unknown modifier: " + name);
}
}
throw std::runtime_error("unknown modifier: " + name);
}
