void delete_vars(UniVar *vars, int which)
{
while(--which)
{
if (IsStr(which) && !IsProc(which))
{
#ifdef DEBUG
debug("(delete_vars) deleting string var `%s'\n",VarName[which].name);
#endif /* DEBUG */
Free((char**)&vars[which].str_var);
}
}
#ifdef DEBUG
debug("(delete_vars) all done\n");
#endif /* DEBUG */
}
OP_STATUS SoundUtils::SoundIt(const OpStringC &sndfile, BOOL force, BOOL async)
{
OP_STATUS rc = OpStatus::OK;
if ((!g_pcui->GetIntegerPref(PrefsCollectionUI::SoundsEnabled) && !force) || !IsStr(sndfile.CStr()))
return rc;
OpString osPrefsNoSound;
TRAP_AND_RETURN(rc, g_languageManager->GetStringL(Str::SI_NO_SOUND_STRING, osPrefsNoSound));
if (sndfile.CompareI(osPrefsNoSound) == 0 || sndfile.Compare("None") == 0)
return OpStatus::ERR;
#if defined(MSWIN)
rc = ( sndPlaySound(sndfile.CStr(), (async ? SND_ASYNC : SND_SYNC) | SND_NODEFAULT)==TRUE ? OpStatus::OK : OpStatus::ERR);
#elif defined(_UNIX_DESKTOP_)
if (g_audio_player)
{
char *filename = uni_down_strdup(sndfile.CStr());
if (!filename)
return OpStatus::ERR_NO_MEMORY;
WavFile *wav = OP_NEW(WavFile, ());
if (!wav)
{
rc = OpStatus::ERR_NO_MEMORY;
}
else
{
if (wav->Open(filename))
{
g_audio_player->Play(wav);
}
else
{
OP_DELETE(wav);
rc = OpStatus::ERR;
}
}
op_free(filename);
}
#elif defined(_MACINTOSH_)
rc = (MacPlaySound(sndfile.CStr(), async) == TRUE) ? OpStatus::OK : OpStatus::ERR;
#endif
return rc;
}
void copy_vars(UniVar *dst, UniVar *src)
{
int i;
for(i=0;i<CHANSET_SIZE;i++)
{
if (IsStr(i))
{
if (src[i].str_var)
{
set_mallocdoer(copy_vars);
dst[i].str_var = Strdup(src[i].str_var);
}
}
else
{
dst[i].int_var = src[i].int_var;
}
}
}
uint64 LLBC_Variant::AsUInt64() const
{
if (IsNil())
{
return 0;
}
else if (IsDict())
{
return 0;
}
else if (IsStr())
{
return LLBC_Str2UInt64(_holder.str.c_str());
}
if (IsDouble() || IsFloat())
{
return static_cast<uint64>(_holder.raw.doubleVal);
}
return _holder.raw.uint64Val;
}
bool LLBC_Variant::AsBool() const
{
if (IsNil())
{
return false;
}
else if (IsDict())
{
return false;
}
else if (IsStr())
{
LLBC_String trimedData(LLBC_Trim(_holder.str));
if (trimedData.length() != 4 && trimedData.length() != 5)
{
return (AsInt64() != 0 ? true : false);
}
LLBC_String lowerData(LLBC_ToLower(trimedData.c_str()));
return (lowerData == "true" ? true : false);
}
return _holder.raw.uint64Val != 0;
}
bool CTag::WriteNewEd2kTag(CFileDataIO* data, EUtf8Str eStrEncode) const
{
// Write tag type
uint8 uType;
if (IsInt()) {
if (m_uVal <= 0xFF) {
uType = TAGTYPE_UINT8;
} else if (m_uVal <= 0xFFFF) {
uType = TAGTYPE_UINT16;
} else if (m_uVal <= 0xFFFFFFFF) {
uType = TAGTYPE_UINT32;
} else {
uType = TAGTYPE_UINT64;
}
} else if (IsStr()) {
uint16 uStrValLen = GetRawSize(*m_pstrVal, eStrEncode);
if (uStrValLen >= 1 && uStrValLen <= 16) {
uType = TAGTYPE_STR1 + uStrValLen - 1;
} else {
uType = TAGTYPE_STRING;
}
} else {
uType = m_uType;
}
// Write tag name
if (!m_Name.IsEmpty()) {
data->WriteUInt8(uType);
data->WriteString(m_Name,utf8strNone);
} else {
wxASSERT( m_uName != 0 );
data->WriteUInt8(uType | 0x80);
data->WriteUInt8(m_uName);
}
// Write tag data
switch (uType) {
case TAGTYPE_STRING:
data->WriteString(*m_pstrVal,eStrEncode);
break;
case TAGTYPE_UINT64:
data->WriteUInt64(m_uVal);
break;
case TAGTYPE_UINT32:
data->WriteUInt32(m_uVal);
break;
case TAGTYPE_UINT16:
data->WriteUInt16(m_uVal);
break;
case TAGTYPE_UINT8:
data->WriteUInt8(m_uVal);
break;
case TAGTYPE_FLOAT32:
//#warning Endianess problem?
data->Write(&m_fVal, 4);
break;
case TAGTYPE_HASH16:
data->WriteHash(*m_hashVal);
break;
case TAGTYPE_BLOB:
data->WriteUInt32(m_nSize);
data->Write(m_pData, m_nSize);
break;
default:
// See comment on the default: of CTag::CTag(const CFileDataIO& data, bool bOptUTF8)
if (uType >= TAGTYPE_STR1 && uType <= TAGTYPE_STR16) {
// Sending '0' as len size makes it not write the len on the IO file.
// This is because this tag types send the len as their type.
data->WriteString(*m_pstrVal,eStrEncode,0);
} else {
printf("%s; Unknown tag: type=0x%02X\n", __FUNCTION__, uType);
wxFAIL;
return false;
}
break;
}
return true;
}
const wxString& CTag::GetStr() const
{
CHECK_TAG_TYPE(IsStr(), String);
return *m_pstrVal;
}
bool CTag::WriteNewEd2kTag(CFileDataIO* data, EUtf8Str eStrEncode) const
{
ASSERT_VALID(this);
// Write tag type
uint8 uType;
UINT uStrValLen = 0;
LPCSTR pszValA = NULL;
CStringA* pstrValA = NULL;
if (IsInt())
{
if (m_uVal <= 0xFF)
uType = TAGTYPE_UINT8;
else if (m_uVal <= 0xFFFF)
uType = TAGTYPE_UINT16;
else
uType = TAGTYPE_UINT32;
}
else if (IsStr())
{
#ifdef _UNICODE
if (eStrEncode == utf8strRaw)
{
CUnicodeToUTF8 utf8(*m_pstrVal);
pstrValA = new CStringA((LPCSTR)utf8, utf8.GetLength());
}
else if (eStrEncode == utf8strOptBOM)
{
if (NeedUTF8String(*m_pstrVal))
{
CUnicodeToBOMUTF8 bomutf8(*m_pstrVal);
pstrValA = new CStringA((LPCSTR)bomutf8, bomutf8.GetLength());
}
else
{
CUnicodeToMultiByte mb(*m_pstrVal);
pstrValA = new CStringA((LPCSTR)mb, mb.GetLength());
}
}
else
{
CUnicodeToMultiByte mb(*m_pstrVal);
pstrValA = new CStringA((LPCSTR)mb, mb.GetLength());
}
uStrValLen = pstrValA->GetLength();
pszValA = *pstrValA;
#else
uStrValLen = m_pstrVal->GetLength();
pszValA = *m_pstrVal;
#endif
if (uStrValLen >= 1 && uStrValLen <= 16)
uType = TAGTYPE_STR1 + uStrValLen - 1;
else
uType = TAGTYPE_STRING;
}
else
uType = m_uType;
// Write tag name
if (m_pszName)
{
data->WriteUInt8(uType);
UINT uTagNameLen = strlen(m_pszName);
data->WriteUInt16(uTagNameLen);
data->Write(m_pszName, uTagNameLen);
}
else
{
ASSERT( m_uName != 0 );
data->WriteUInt8(uType | 0x80);
data->WriteUInt8(m_uName);
}
// Write tag data
if (uType == TAGTYPE_STRING)
{
data->WriteUInt16(uStrValLen);
data->Write(pszValA, uStrValLen);
}
else if (uType >= TAGTYPE_STR1 && uType <= TAGTYPE_STR16)
{
data->Write(pszValA, uStrValLen);
}
else if (uType == TAGTYPE_UINT32)
{
data->WriteUInt32(m_uVal);
}
else if (uType == TAGTYPE_UINT16)
{
data->WriteUInt16(m_uVal);
}
else if (uType == TAGTYPE_UINT8)
{
data->WriteUInt8(m_uVal);
}
else if (uType == TAGTYPE_FLOAT32)
{
data->Write(&m_fVal, 4);
}
else if (uType == TAGTYPE_HASH)
{
data->WriteHash16(m_pData);
}
else if (uType == TAGTYPE_BLOB)
{
data->WriteUInt32(m_nBlobSize);
data->Write(m_pData, m_nBlobSize);
}
else
{
TRACE("%s; Unknown tag: type=0x%02X\n", __FUNCTION__, uType);
ASSERT(0);
return false;
}
delete pstrValA;
return true;
}
bool LLBC_Variant::DeSerialize(LLBC_Stream &stream)
{
BecomeNil();
if (!stream.Read(_holder.type))
{
return false;
}
if (IsNil())
{
return true;
}
if (IsRaw())
{
if (!stream.Read(_holder.raw.uint64Val))
{
_holder.type = LLBC_VariantType::VT_NIL;
return false;
}
}
else if (IsStr())
{
if (!stream.Read(_holder.str))
{
_holder.type = LLBC_VariantType::VT_NIL;
return false;
}
}
else if (IsDict())
{
uint32 count = 0;
if (!stream.Read(count))
{
_holder.type = LLBC_VariantType::VT_NIL;
return false;
}
if (count == 0)
{
return true;
}
_holder.dict = new Dict;
for (uint32 i = 0; i < count; i ++)
{
LLBC_Variant key;
LLBC_Variant val;
if (!stream.Read(key) || !stream.Read(val))
{
LLBC_XDelete(_holder.dict);
_holder.type = LLBC_VariantType::VT_NIL;
return false;
}
_holder.dict->insert(std::make_pair(key, val));
}
return true;
}
return false;
}
LLBC_String LLBC_Variant::ValueToString() const
{
if (IsStr())
{
return _holder.str;
}
else if (IsDict())
{
LLBC_String content;
content.append("{");
if (_holder.dict)
{
for (DictConstIter it = _holder.dict->begin();
it != _holder.dict->end();
)
{
content.append(it->first.ValueToString());
content.append(":");
content.append(it->second.ValueToString());
if (++ it != _holder.dict->end())
{
content.append("|");
}
}
}
content.append("}");
return content;
}
else if (IsNil())
{
return "nil";
}
// RAW type var data.
switch(_holder.type)
{
case LLBC_VariantType::VT_RAW_BOOL:
return _holder.raw.int64Val != 0 ? "true" : "false";
case LLBC_VariantType::VT_RAW_SINT8:
case LLBC_VariantType::VT_RAW_SINT16:
case LLBC_VariantType::VT_RAW_SINT32:
case LLBC_VariantType::VT_RAW_LONG:
case LLBC_VariantType::VT_RAW_SINT64:
return LLBC_Num2Str(_holder.raw.int64Val);
case LLBC_VariantType::VT_RAW_UINT8:
case LLBC_VariantType::VT_RAW_UINT16:
case LLBC_VariantType::VT_RAW_UINT32:
case LLBC_VariantType::VT_RAW_ULONG:
case LLBC_VariantType::VT_RAW_UINT64:
return LLBC_Num2Str(_holder.raw.uint64Val);
case LLBC_VariantType::VT_RAW_FLOAT:
case LLBC_VariantType::VT_RAW_DOUBLE:
return LLBC_Num2Str(_holder.raw.doubleVal);
default:
break;
}
return "";
}
void do_set(COMMAND_ARGS)
{
/*
* on_msg checks:
*/
Chan *chan;
UniVar *univar,*varval;
char tmp[MSGLEN];
char *pp,*channel,*name;
int n,which,i,sz,limit,uaccess;
/*
*
*/
channel = get_channel2(to,&rest);
chan = find_channel_ny(channel);
name = chop(&rest);
/*
* empty args, its "set" or "set #channel"
*/
if (!name)
{
if (!chan)
{
to_user(from,ERR_CHAN,channel);
return;
}
if (!CurrentDCC)
return;
i = CHANSET_SIZE;
limit = SIZE_VARS - 1;
univar = current->setting;
*tmp = 0;
if ((uaccess = get_useraccess(from,GLOBAL_CHANNEL)))
to_user(from,str_underline("Global settings"));
second_pass:
for(;i<limit;i++)
{
if (uaccess < VarName[i].uaccess)
continue;
varval = (IsProc(i)) ? current->setting[i].proc_var : &univar[i];
sz = Strlen2(tmp,VarName[i].name);
if (IsStr(i))
{
sz += (varval->str_var) ? strlen(varval->str_var) : 7;
}
if (sz > 58)
{
to_user(from,FMT_PLAIN,tmp);
*tmp = 0;
}
if (IsInt(i))
{
pp = tolowercat(tmp,VarName[i].name);
sprintf(pp,(IsChar(i)) ? "=`%c' " : "=%i ",varval->int_var);
}
else
if (IsStr(i))
{
pp = tolowercat(tmp,VarName[i].name);
sprintf(pp,(varval->str_var) ? "=\"%s\" " : "=(unset) ",varval->str_var);
}
else
if (IsTog(i))
{
pp = Strcat(tmp,(varval->int_var) ? "+" : "-");
pp = tolowercat(pp,VarName[i].name);
pp[0] = ' ';
pp[1] = 0;
}
}
if (*tmp && tmp[1])
to_user(from,FMT_PLAIN,tmp);
if (limit != CHANSET_SIZE)
{
to_user(from,"\037Channel settings: %s\037",(chan) ? chan->name : rest);
i = 0;
limit = CHANSET_SIZE;
univar = chan->setting;
*tmp = 0;
uaccess = get_useraccess(from,(chan) ? chan->name : rest);
goto second_pass;
}
return;
}
/*
* alter a setting
*/
if ((which = find_setting(name)) == -1)
{
set_usage:
usage(from); /* usage for CurrentCmd->name */
return;
}
if ((which < CHANSET_SIZE) && *channel != '*')
{
if (!chan)
{
to_user(from,ERR_CHAN,channel);
return;
}
/*
* its a channel setting
*/
channel = chan->name;
varval = &chan->setting[which];
}
else
{
/*
* its a global setting
*/
channel = MATCH_ALL;
varval = ¤t->setting[which];
}
if (VarName[which].uaccess > get_authaccess(from,channel))
return;
/*
* Check each type and process `rest' if needed.
*/
n = 0;
if (IsChar(which))
{
if (rest[1])
goto set_usage;
}
else
if (IsNum(which))
{
if (IsTog(which))
{
if (!Strcasecmp(rest,"ON"))
{
n = 1;
goto num_data_ok;
}
else
if (!Strcasecmp(rest,"OFF"))
{
/* n is 0 by default */
goto num_data_ok;
}
}
n = a2i((rest = chop(&rest)));
if (errno || n < VarName[which].min || n > VarName[which].max)
{
to_user(from,"Possible values are %i through %i",VarName[which].min,VarName[which].max);
return;
}
}
num_data_ok:
/*
*
*/
if ((which < CHANSET_SIZE) && *channel == '*')
{
for(chan=current->chanlist;chan;chan=chan->next)
{
if (IsNum(which))
{
chan->setting[which].int_var = n;
}
else
if (IsStr(which))
{
Free((char**)&chan->setting[which].str_var);
if (*rest)
{
set_mallocdoer(do_set);
chan->setting[which].str_var = Strdup(rest);
}
}
}
channel = "(all channels)";
}
else
{
if (IsProc(which))
varval = varval->proc_var;
if (IsChar(which))
varval->char_var = *rest;
else
if (IsNum(which))
varval->int_var = n;
else
{
if (varval->str_var)
Free((char**)&varval->str_var);
if (*rest)
{
set_mallocdoer(do_set);
varval->str_var = Strdup(rest);
}
}
}
to_user(from,"Var: %s On: %s Set to: %s",VarName[which].name,
(which >= CHANSET_SIZE) ? "(global)" : channel,(*rest) ? rest : NULLSTR);
if (VarName[which].func)
VarName[which].func(&VarName[which]);
}
void ec_set(char *from, char *to)
{
Chan *chan;
UniVar *varval;
char num[20];
char *src;
int which,uaccess;
src = ec_src;
while(*src && *src != ')')
src++;
if (*src != ')')
return;
*(src++) = 0;
if ((which = find_setting(ec_src)) >= 0)
{
if (which >= CHANSET_SIZE)
{
uaccess = get_useraccess(from,ANY_CHANNEL);
varval = ¤t->setting[which];
}
else
if ((chan = find_channel_ny(to)))
{
uaccess = get_useraccess(from,to);
varval = &chan->setting[which];
}
else
{
nobo_strcpy("(unknown channel)");
return;
}
if (uaccess < VarName[which].uaccess)
return;
if (IsProc(which))
varval = varval->proc_var;
if (IsChar(which))
{
num[0] = varval->char_var;
num[1] = 0;
nobo_strcpy(num);
}
else
if (IsInt(which))
{
sprintf(num,"%i",varval->int_var);
nobo_strcpy(num);
}
else
if (IsTog(which))
{
nobo_strcpy((varval->int_var) ? "on" : "off");
}
else
if (IsStr(which))
{
nobo_strcpy(nullstr(varval->str_var));
}
}
else
{
nobo_strcpy("(unknown setting)");
}
ec_src = src;
}
