bool wxXmlDocument::Save(wxOutputStream& stream) const
{
if ( !IsOk() )
return false;
wxString s;
wxMBConv *convMem = NULL;
#if wxUSE_UNICODE
wxMBConv *convFile = new wxCSConv(GetFileEncoding());
#else
wxMBConv *convFile = NULL;
if ( GetFileEncoding() != GetEncoding() )
{
convFile = new wxCSConv(GetFileEncoding());
convMem = new wxCSConv(GetEncoding());
}
#endif
s.Printf(wxT("<?xml version=\"%s\" encoding=\"%s\"?>\n"),
GetVersion().c_str(), GetFileEncoding().c_str());
OutputString(stream, s, NULL, NULL);
OutputNode(stream, GetRoot(), 0, convMem, convFile);
OutputString(stream, wxT("\n"), NULL, NULL);
if ( convFile )
delete convFile;
if ( convMem )
delete convMem;
return true;
}
void OGRDXFDataSource::ReadLayerDefinition()
{
char szLineBuf[257];
int nCode;
std::map<CPLString,CPLString> oLayerProperties;
CPLString osLayerName = "";
oLayerProperties["Hidden"] = "0";
while( (nCode = ReadValue( szLineBuf, sizeof(szLineBuf) )) > 0 )
{
switch( nCode )
{
case 2:
osLayerName = ACTextUnescape(szLineBuf,GetEncoding());
oLayerProperties["Exists"] = "1";
break;
case 6:
oLayerProperties["Linetype"] = ACTextUnescape(szLineBuf,
GetEncoding());
break;
case 62:
oLayerProperties["Color"] = szLineBuf;
if( atoi(szLineBuf) < 0 ) // Is layer off?
oLayerProperties["Hidden"] = "1";
break;
case 70:
oLayerProperties["Flags"] = szLineBuf;
if( atoi(szLineBuf) & 0x01 ) // Is layer frozen?
oLayerProperties["Hidden"] = "1";
break;
case 370:
case 39:
oLayerProperties["LineWeight"] = szLineBuf;
break;
default:
break;
}
}
if( oLayerProperties.size() > 0 )
oLayerTable[osLayerName] = oLayerProperties;
if( nCode == 0 )
UnreadValue();
}
bool loadXMLFile (TiXmlDocument &pXMLDoc, std::string XMLFilename, std::map<int,
std::string> * pMapXmlStrings, bool isSourceFile)
{
if (!pXMLDoc.LoadFile(XMLFilename.c_str()))
{
printf ("%s %s\n", pXMLDoc.ErrorDesc(), XMLFilename.c_str());
return false;
}
if (isSourceFile) GetEncoding(&pXMLDoc, sourceXMLEncoding);
else GetEncoding(&pXMLDoc, foreignXMLEncoding);
TiXmlElement* pRootElement = pXMLDoc.RootElement();
if (!pRootElement || pRootElement->NoChildren() || pRootElement->ValueTStr()!="strings")
{
printf ("error: No root element called: \"strings\" or no child found in input XML file: %s\n",
XMLFilename.c_str());
return false;
}
if (isSourceFile) GetComment(pRootElement->FirstChild(), -1);
const TiXmlElement *pChildElement = pRootElement->FirstChildElement("string");
const char* pAttrId = NULL;
const char* pValue = NULL;
std::string valueString;
int id;
while (pChildElement)
{
pAttrId=pChildElement->Attribute("id");
if (pAttrId && !pChildElement->NoChildren())
{
id = atoi(pAttrId);
if (pMapXmlStrings->find(id) == pMapXmlStrings->end())
{
pValue = pChildElement->FirstChild()->Value();
valueString = EscapeLF(pValue);
if (isSourceFile)
multimapSourceXmlStrings.insert(std::pair<std::string,int>( valueString,id));
(*pMapXmlStrings)[id] = valueString;
if (pChildElement && isSourceFile) GetComment(pChildElement->NextSibling(), id);
}
}
pChildElement = pChildElement->NextSiblingElement("string");
}
// Free up the allocated memory for the XML file
pXMLDoc.Clear();
return true;
}
wxDatabaseResultSet* wxSqlitePreparedStatement::RunQueryWithResults()
{
ResetErrorCodes();
if (m_Statements.size() > 1)
{
for (unsigned int i=0; i<m_Statements.size()-1; i++)
{
int nReturn = sqlite3_step(m_Statements[i]);
if (nReturn != SQLITE_ROW)
sqlite3_reset(m_Statements[i]);
if ((nReturn != SQLITE_ROW) && (nReturn != SQLITE_DONE))
{
wxLogError(_("Error with RunQueryWithResults\n"));
SetErrorCode(wxSqliteDatabase::TranslateErrorCode(nReturn));
SetErrorMessage(ConvertFromUnicodeStream(sqlite3_errmsg(m_pDatabase)));
ThrowDatabaseException();
return NULL;
}
}
}
// Work off the assumption that only the last statement will return result
wxSqliteResultSet* pResultSet = new wxSqliteResultSet(this);
if (pResultSet)
pResultSet->SetEncoding(GetEncoding());
LogResultSetForCleanup(pResultSet);
return pResultSet;
}
int IMapInfoFile::TestUtf8Capability() const
{
const char* pszEncoding( GetEncoding() );
if( strlen( pszEncoding ) == 0 )
{
return FALSE;
}
CPLClearRecodeWarningFlags();
CPLErrorReset();
CPLPushErrorHandler(CPLQuietErrorHandler);
char* pszTest( CPLRecode( "test", GetEncoding(), CPL_ENC_UTF8 ) );
CPLPopErrorHandler();
if( pszTest == nullptr )
{
return FALSE;
}
CPLFree( pszTest );
if( CPLGetLastErrorType() != 0 )
{
return FALSE;
}
return TRUE;
}
bool CFarInetMessage::DecodeKludge( LPSTR Data )
{
far_assert( Data != NULL );
if ( *Data != '\0')
strcpy( Data, UnMimeHeader( Data, GetEncoding() ) );
return true;
}
charconv* CharConvOpen(const tchar_t* From, const tchar_t* To)
{
charconv_osx TmpConv;
charconv_osx *CC;
TmpConv.EncFrom = GetEncoding(From);
TmpConv.EncTo = GetEncoding(To);
if (TmpConv.EncFrom == kCFStringEncodingInvalidId || TmpConv.EncTo == kCFStringEncodingInvalidId || TmpConv.EncFrom == TmpConv.EncTo)
return NULL;
CC = malloc(sizeof(*CC));
CC->EncFrom = TmpConv.EncFrom;
CC->EncTo = TmpConv.EncTo;
return (charconv*)CC;
}
wxDatabaseResultSet* wxMysqlPreparedStatementWrapper::RunQueryWithResults()
{
wxMysqlPreparedStatementResultSet* pResultSet = NULL;
MYSQL_BIND* pBoundParameters = m_Parameters.GetMysqlParameterBindings();
if (m_pInterface->GetMysqlStmtBindParam()(m_pStatement, pBoundParameters))
{
SetErrorCode(wxMysqlDatabase::TranslateErrorCode(m_pInterface->GetMysqlStmtErrno()(m_pStatement)));
SetErrorMessage(ConvertFromUnicodeStream(m_pInterface->GetMysqlStmtError()(m_pStatement)));
wxDELETEA(pBoundParameters);
ThrowDatabaseException();
return NULL;
}
else
{
if (m_pInterface->GetMysqlStmtExecute()(m_pStatement) != 0)
{
SetErrorCode(wxMysqlDatabase::TranslateErrorCode(m_pInterface->GetMysqlStmtErrno()(m_pStatement)));
SetErrorMessage(ConvertFromUnicodeStream(m_pInterface->GetMysqlStmtError()(m_pStatement)));
wxDELETEA(pBoundParameters);
ThrowDatabaseException();
return NULL;
}
else
{
pResultSet = new wxMysqlPreparedStatementResultSet(m_pInterface, m_pStatement);
if (pResultSet)
pResultSet->SetEncoding(GetEncoding());
}
}
wxDELETEA(pBoundParameters);;
return pResultSet;
}
result_t CYamlEmitter::SaveStreamStart ( yaml_emitter_t& _emitter ) const
{
result_t result_t = eResult_OK;
yaml_event_t event;
yaml_stream_start_event_initialize ( &event, GetEncoding(m_Encoding) );
yaml_emitter_emit ( &_emitter, &event ) || yaml_emitter_flush ( &_emitter );
return eResult;
}
DatabaseResultSet* TdsDatabaseLayer::RunQueryWithResults(const wxString& strQuery)
{
ResetErrorCodes();
if (m_pDatabase != NULL)
{
FreeAllocatedResultSets();
wxArrayString QueryArray = ParseQueries(strQuery);
for (unsigned int i=0; i<(QueryArray.size()-1); i++)
{
char* szErrorMessage = NULL;
wxString strErrorMessage = wxT("");
wxString sql = RemoveLastSemiColon(QueryArray[i]);
wxCharBuffer sqlBuffer = ConvertToUnicodeStream(sql);
//fprintf(stderr, "Running query '%s'\n", sqlBuffer);
int nReturn = tds_submit_query(m_pDatabase, sqlBuffer);
if (nReturn != TDS_SUCCEED)
{
//fprintf(stderr, "tds_submit_query() failed for query '%s'\n", sql.c_str());
FreeAllocatedResultSets();
ThrowDatabaseException();
return NULL;
}
FreeAllocatedResultSets();
}
// Create a Prepared statement for the last SQL statement and get a result set from it
wxString strQuery = RemoveLastSemiColon(QueryArray[QueryArray.size()-1]);
wxCharBuffer sqlBuffer = ConvertToUnicodeStream(strQuery);
//fprintf(stderr, "Running query (with results) '%s'\n", sqlBuffer);
int nReturn = tds_submit_query(m_pDatabase, sqlBuffer);
if (nReturn != TDS_SUCCEED)
{
//fprintf(stderr, "tds_submit_query() failed for query '%s'\n", sqlBuffer);
//fprintf(stderr, "tds_submit_query() failed for query '%s'\n", strQuery.c_str());
FreeAllocatedResultSets();
ThrowDatabaseException();
return NULL;
}
TdsResultSet* pResultSet = new TdsResultSet(m_pDatabase);
if (pResultSet)
pResultSet->SetEncoding(GetEncoding());
LogResultSetForCleanup(pResultSet);
//fprintf(stderr, "Returning result set\n");
return pResultSet;
}
else
{
return NULL;
}
}
ServerOptions IrcJoinGroupChat::GetServerOptions () const
{
ServerOptions so;
so.ServerName_ = GetServer ();
so.ServerPort_ = GetPort ();
so.ServerEncoding_ = GetEncoding ();
so.ServerPassword_ = QString ();
so.SSL_ = GetSSL ();
so.ServerNickName_ = GetNickname ();
return so;
}
/**
* Internally used to track down the encoding to be used at the headers
* or parameters. We know the version is legal, or we couldn't have
* found a starting point, so it is used but not checked again. We
* also know that since there is a version, there is an encoding.
*/
nsresult
nsSOAPMessage::GetEncodingWithVersion(nsIDOMElement * aFirst,
PRUint16 * aVersion,
nsISOAPEncoding ** aEncoding)
{
nsCOMPtr<nsISOAPEncoding> encoding;
nsresult rv = GetEncoding(getter_AddRefs(encoding));
if (NS_FAILED(rv))
return rv;
rv = GetVersion(aVersion);
if (NS_FAILED(rv))
return rv;
nsCOMPtr<nsIDOMElement> element = aFirst;
// Check for stray encodingStyle attributes. If none found, then
// use empty string encoding style.
nsAutoString style;
for (;;) {
nsCOMPtr<nsIDOMAttr> enc;
rv = element->GetAttributeNodeNS(*gSOAPStrings->kSOAPEnvURI[*aVersion],
gSOAPStrings->kEncodingStyleAttribute,
getter_AddRefs(enc));
if (NS_FAILED(rv))
return rv;
if (enc) {
rv = enc->GetNodeValue(style);
if (NS_FAILED(rv))
return rv;
break;
} else {
nsCOMPtr<nsIDOMNode> next;
rv = element->GetParentNode(getter_AddRefs(next));
if (NS_FAILED(rv))
return rv;
if (next) {
PRUint16 type;
rv = next->GetNodeType(&type);
if (NS_FAILED(rv))
return rv;
if (type != nsIDOMNode::ELEMENT_NODE) {
next = nsnull;
}
}
if (next) {
element = do_QueryInterface(next);
} else {
break;
}
}
}
return encoding->GetAssociatedEncoding(style, PR_TRUE, aEncoding);
}
bool wxXmlDocument::Save(wxOutputStream& stream, int indentstep) const
{
if ( !IsOk() )
return false;
wxString s;
wxMBConv *convMem = NULL,
*convFile;
#if wxUSE_UNICODE
convFile = new wxCSConv(GetFileEncoding());
convMem = NULL;
#else
if ( GetFileEncoding().CmpNoCase(GetEncoding()) != 0 )
{
convFile = new wxCSConv(GetFileEncoding());
convMem = new wxCSConv(GetEncoding());
}
else // file and in-memory encodings are the same, no conversion needed
{
convFile =
convMem = NULL;
}
#endif
s.Printf(wxT("<?xml version=\"%s\" encoding=\"%s\"?>\n"),
GetVersion().c_str(), GetFileEncoding().c_str());
OutputString(stream, s);
OutputNode(stream, GetRoot(), 0, convMem, convFile, indentstep);
OutputString(stream, wxT("\n"));
delete convFile;
delete convMem;
return true;
}
bool wxXmlDocument::Save(wxOutputStream& stream, int indentstep) const
{
if ( !IsOk() )
return false;
wxScopedPtr<wxMBConv> convMem, convFile;
#if wxUSE_UNICODE
convFile.reset(new wxCSConv(GetFileEncoding()));
#else
if ( GetFileEncoding().CmpNoCase(GetEncoding()) != 0 )
{
convFile.reset(new wxCSConv(GetFileEncoding()));
convMem.reset(new wxCSConv(GetEncoding()));
}
//else: file and in-memory encodings are the same, no conversion needed
#endif
wxString dec = wxString::Format(
wxS("<?xml version=\"%s\" encoding=\"%s\"?>\n"),
GetVersion(), GetFileEncoding()
);
bool rc = OutputString(stream, dec, convMem.get(), convFile.get());
wxXmlNode *node = GetDocumentNode();
if ( node )
node = node->GetChildren();
while( rc && node )
{
rc = OutputNode(stream, node, 0, convMem.get(),
convFile.get(), indentstep) &&
OutputString(stream, wxS("\n"), convMem.get(), convFile.get());
node = node->GetNext();
}
return rc;
}
DatabaseResultSet* TdsPreparedStatement::RunQueryWithResults()
{
ResetErrorCodes();
//fprintf(stderr, "Running statement with results\n");
// Prepare the statement
wxCharBuffer sqlBuffer = ConvertToUnicodeStream(m_strOriginalQuery);
//fprintf(stderr, "Preparing statement: '%s'\n", (const char*)sqlBuffer);
m_pStatement = NULL;
int nReturn = tds_submit_prepare(m_pDatabase, sqlBuffer, NULL, &m_pStatement, m_pParameters);
if (nReturn != TDS_SUCCEED)
{
//fprintf(stderr, "tds_submit_prepare() failed for query '%s'\n", m_strOriginalQuery.c_str());
if (m_pStatement != NULL)
tds_free_dynamic(m_pDatabase, m_pStatement);
if (m_pParameters != NULL)
tds_free_param_results(m_pParameters);
SetErrorInformationFromDatabaseLayer();
FreeAllocatedResultSets();
ThrowDatabaseException();
return NULL;
}
FreeAllocatedResultSets();
tds_free_input_params(m_pStatement);
m_pStatement->params = m_pParameters;
// Execute the query
//fprintf(stderr, "Statement prepared. Ready to execute\n");
nReturn = tds_submit_execute(m_pDatabase, m_pStatement);
if (nReturn != TDS_SUCCEED)
{
//fprintf(stderr, "tds_submit_execute() failed for query '%s'\n", m_pStatement->query);
//fprintf(stderr, "tds_submit_execute() return code: %d\n", nReturn);
SetErrorInformationFromDatabaseLayer();
FreeAllocatedResultSets();
ThrowDatabaseException();
return NULL;
}
TdsResultSet* pResultSet = new TdsResultSet(m_pDatabase);
if (pResultSet)
pResultSet->SetEncoding(GetEncoding());
LogResultSetForCleanup(pResultSet);
//fprintf(stderr, "Returning prepared statement result set\n");
return pResultSet;
}
DatabaseResultSet* SqliteDatabaseLayer::RunQueryWithResults(const wxString& strQuery)
{
ResetErrorCodes();
if (m_pDatabase != NULL)
{
wxArrayString QueryArray = ParseQueries(strQuery);
for (unsigned int i=0; i<(QueryArray.size()-1); i++)
{
char* szErrorMessage = NULL;
wxString strErrorMessage = _("");
wxCharBuffer sqlBuffer = ConvertToUnicodeStream(QueryArray[i]);
int nReturn = sqlite3_exec((sqlite3*)m_pDatabase, sqlBuffer, 0, 0, &szErrorMessage);
if (szErrorMessage != NULL)
{
SetErrorCode(SqliteDatabaseLayer::TranslateErrorCode(sqlite3_errcode((sqlite3*)m_pDatabase)));
strErrorMessage = ConvertFromUnicodeStream(szErrorMessage);
sqlite3_free(szErrorMessage);
return NULL;
}
if (nReturn != SQLITE_OK)
{
SetErrorCode(SqliteDatabaseLayer::TranslateErrorCode(sqlite3_errcode((sqlite3*)m_pDatabase)));
SetErrorMessage(strErrorMessage);
ThrowDatabaseException();
return NULL;
}
}
// Create a Prepared statement for the last SQL statement and get a result set from it
SqlitePreparedStatement* pStatement = (SqlitePreparedStatement*)PrepareStatement(QueryArray[QueryArray.size()-1], false);
SqliteResultSet* pResultSet = new SqliteResultSet(pStatement, true);
if (pResultSet)
pResultSet->SetEncoding(GetEncoding());
LogResultSetForCleanup(pResultSet);
return pResultSet;
}
else
{
return NULL;
}
}
PreparedStatement* TdsDatabaseLayer::PrepareStatement(const wxString& strQuery)
{
ResetErrorCodes();
if (m_pDatabase != NULL)
{
wxString sql = RemoveLastSemiColon(strQuery);
/*
wxCharBuffer sqlBuffer = ConvertToUnicodeStream(sql);
TDSDYNAMIC* pStatement = NULL;
TDSPARAMINFO* pParameters = NULL;
int nReturn = tds_submit_prepare(m_pDatabase, sqlBuffer, NULL, &pStatement, pParameters);
if (nReturn != TDS_SUCCEED)
{
//fprintf(stderr, "tds_submit_prepare() failed for query '%s'\n", strQuery.c_str());
if (pStatement != NULL)
tds_free_dynamic(m_pDatabase, pStatement);
if (pParameters != NULL)
tds_free_param_results(pParameters);
FreeAllocatedResultSets();
ThrowDatabaseException();
return NULL;
}
FreeAllocatedResultSets();
TdsPreparedStatement* pReturnStatement = new TdsPreparedStatement(m_pDatabase, pStatement, strQuery);
if (pReturnStatement)
pReturnStatement->SetEncoding(GetEncoding());
*/
TdsPreparedStatement* pReturnStatement = new TdsPreparedStatement(m_pDatabase, sql);
if (pReturnStatement)
pReturnStatement->SetEncoding(GetEncoding());
if (pReturnStatement != NULL)
LogStatementForCleanup(pReturnStatement);
return pReturnStatement;
}
else
{
return NULL;
}
}
wxMysqlPreparedStatementResultSet::wxMysqlPreparedStatementResultSet(wxMysqlDynamicInterface* pInterface, MYSQL_STMT* pStatement, bool bManageStatement /* = false*/)
: wxDatabaseResultSet()
{
m_pInterface = pInterface;
m_pStatement = pStatement;
m_pResultBindings = NULL;
m_bManageStatement = bManageStatement;
MYSQL_RES* pResultMetadata = m_pInterface->GetMysqlStmtResultMetadata()(m_pStatement);
if (!pResultMetadata)
{
SetErrorCode(wxMysqlDatabase::TranslateErrorCode(m_pInterface->GetMysqlStmtErrno()(m_pStatement)));
SetErrorMessage(ConvertFromUnicodeStream(m_pInterface->GetMysqlStmtError()(m_pStatement)));
ThrowDatabaseException();
}
else
{
int nParameters = m_pInterface->GetMysqlNumFields()(pResultMetadata);
m_pResultBindings = new MYSQL_BIND[nParameters];
memset(m_pResultBindings, 0, sizeof(MYSQL_BIND)*nParameters);
MYSQL_BIND* pCurrentBinding = m_pResultBindings;
MYSQL_FIELD* pCurrentField = m_pInterface->GetMysqlFetchField()(pResultMetadata);
for (int i=0; i<nParameters; i++)
{
// Set up the map so we can look this value up later
wxString strFieldName = ConvertFromUnicodeStream(pCurrentField->name);
wxMysqlPreparedStatementParameter* pParameter = new wxMysqlPreparedStatementParameter(pCurrentBinding, pCurrentField);
if (pParameter)
pParameter->SetEncoding(GetEncoding());
m_BindingWrappers[i] = pParameter;
m_FieldLookupMap[strFieldName] = i;
// Move to the next fields
pCurrentBinding++;
pCurrentField++;
}
m_pInterface->GetMysqlStmtBindResult()(m_pStatement, m_pResultBindings);
m_pInterface->GetMysqlFreeResult()(pResultMetadata);
}
}
ServerOptions IrcJoinGroupChat::GetConnectionOptions () const
{
ServerOptions opts;
opts.NetworkName_ = QString ();
opts.ServerName_ = GetServer ();
opts.ServerPort_ = GetPort ();
opts.ServerPassword_ = QString ();
opts.ServerEncoding_ = GetEncoding ();
opts.SSL_ = GetSSL ();
opts.ServerNicknames_ << GetNickname ();
QString username;
if (SelectedAccount_->GetServers ().isEmpty ())
username = Core::Instance ().GetDefaultUserName ();
else
username = SelectedAccount_->GetServers ().at (0).ServerRealName_;
opts.ServerRealName_ = username;
return opts;
}
void OGRDXFDataSource::ReadLineTypeDefinition()
{
char szLineBuf[257];
int nCode;
CPLString osLineTypeName;
CPLString osLineTypeDef;
while( (nCode = ReadValue( szLineBuf, sizeof(szLineBuf) )) > 0 )
{
switch( nCode )
{
case 2:
osLineTypeName = ACTextUnescape(szLineBuf,GetEncoding());
break;
case 49:
{
if( osLineTypeDef != "" )
osLineTypeDef += " ";
if( szLineBuf[0] == '-' )
osLineTypeDef += szLineBuf+1;
else
osLineTypeDef += szLineBuf;
osLineTypeDef += "g";
}
break;
default:
break;
}
}
if( osLineTypeDef != "" )
oLineTypeTable[osLineTypeName] = osLineTypeDef;
if( nCode == 0 )
UnreadValue();
}
wxPreparedStatement* wxOdbcDatabase::PrepareStatement( const wxString& strQuery, bool bParseQuery )
{
ResetErrorCodes();
wxArrayString QueryArray;
if (bParseQuery)
QueryArray = ParseQueries(strQuery);
else
QueryArray.push_back(strQuery);
wxOdbcPreparedStatement* pReturnStatement = new wxOdbcPreparedStatement(m_pInterface, (SQLHENV)m_sqlEnvHandle, (SQLHDBC)m_sqlHDBC);
if (pReturnStatement)
pReturnStatement->SetEncoding(GetEncoding());
for (unsigned int i=0; i<(QueryArray.size()); i++)
{
//#if wxUSE_UNICODE
// void* sqlBuffer = (void*)(QueryArray[i].c_str());
//#else
wxCharBuffer sqlBuffer = ConvertToUnicodeStream(QueryArray[i]);
//#endif
//wxPrintf(_("Preparing statement: '%s'\n"), sqlBuffer);
SQLHSTMT pSqlStatement = allocStmth();
SQLRETURN nRet = m_pInterface->GetSQLPrepare()(pSqlStatement, (SQLTCHAR*)(const char*)sqlBuffer, SQL_NTS);
if ( nRet != SQL_SUCCESS && nRet != SQL_SUCCESS_WITH_INFO )
{
InterpretErrorCodes( nRet );
m_pInterface->GetSQLFreeStmt()(pSqlStatement, SQL_CLOSE);
ThrowDatabaseException();
return NULL;
}
if ( pSqlStatement )
pReturnStatement->AddPreparedStatement( pSqlStatement );
}
return pReturnStatement;
}
bool wxFontBase::operator==(const wxFont& font) const
{
// either it is the same font, i.e. they share the same common data or they
// have different ref datas but still describe the same font
return IsSameAs(font) ||
(
IsOk() == font.IsOk() &&
GetPointSize() == font.GetPointSize() &&
// in wxGTK1 GetPixelSize() calls GetInternalFont() which uses
// operator==() resulting in infinite recursion so we can't use it
// in that port
#if !defined(__WXGTK__) || defined(__WXGTK20__)
GetPixelSize() == font.GetPixelSize() &&
#endif
GetFamily() == font.GetFamily() &&
GetStyle() == font.GetStyle() &&
GetWeight() == font.GetWeight() &&
GetUnderlined() == font.GetUnderlined() &&
GetFaceName().IsSameAs(font.GetFaceName(), false) &&
GetEncoding() == font.GetEncoding()
);
}
bool CInetMessageT::SetEncoding( long Encoding )
{
if ( GetEncoding() != Encoding )
{
if ( m_From )
{
delete m_From;
m_From = NULL;
}
if ( m_To )
{
delete m_To;
m_To = NULL;
}
if ( m_Cc )
{
delete m_Cc;
m_Cc = NULL;
}
}
return CMessageT::SetEncoding( Encoding );
}
wxDatabaseResultSet* wxPostgresDatabase::RunQueryWithResults(const wxString& strQuery)
{
ResetErrorCodes();
wxCharBuffer sqlBuffer = ConvertToUnicodeStream(strQuery);
PGresult* pResultCode = m_pInterface->GetPQexec()((PGconn*)m_pDatabase, sqlBuffer);
if ((pResultCode == NULL) || (m_pInterface->GetPQresultStatus()(pResultCode) != PGRES_TUPLES_OK))
{
SetErrorCode(wxPostgresDatabase::TranslateErrorCode(m_pInterface->GetPQstatus()((PGconn*)m_pDatabase)));
SetErrorMessage(ConvertFromUnicodeStream(m_pInterface->GetPQerrorMessage()((PGconn*)m_pDatabase)));
m_pInterface->GetPQclear()(pResultCode);
ThrowDatabaseException();
return NULL;
}
else
{
wxPostgresResultSet* pResultSet = new wxPostgresResultSet(m_pInterface, pResultCode);
pResultSet->SetEncoding(GetEncoding());
LogResultSetForCleanup(pResultSet);
return pResultSet;
}
}
DatabaseResultSet* PostgresPreparedStatementWrapper::RunQueryWithResults()
{
int nParameters = m_Parameters.GetSize();
char** paramValues = m_Parameters.GetParamValues();
int* paramLengths = m_Parameters.GetParamLengths();
int* paramFormats = m_Parameters.GetParamFormats();
int nResultFormat = 0; // 0 = text, 1 = binary (all or none on the result set, not column based)
wxCharBuffer statementNameBuffer = ConvertToUnicodeStream(m_strStatementName);
PGresult* pResult = m_pInterface->GetPQexecPrepared()(m_pDatabase, statementNameBuffer, nParameters, paramValues, paramLengths, paramFormats, nResultFormat);
if (pResult != NULL)
{
ExecStatusType status = m_pInterface->GetPQresultStatus()(pResult);
if ((status != PGRES_COMMAND_OK) && (status != PGRES_TUPLES_OK))
{
SetErrorCode(PostgresDatabaseLayer::TranslateErrorCode(status));
SetErrorMessage(ConvertFromUnicodeStream(m_pInterface->GetPQresultErrorMessage()(pResult)));
}
else
{
delete []paramValues;
delete []paramLengths;
delete []paramFormats;
PostgresResultSet* pResultSet = new PostgresResultSet(m_pInterface, pResult);
pResultSet->SetEncoding(GetEncoding());
return pResultSet;
}
m_pInterface->GetPQclear()(pResult);
}
delete []paramValues;
delete []paramLengths;
delete []paramFormats;
ThrowDatabaseException();
return NULL;
}
PreparedStatement* SqliteDatabaseLayer::PrepareStatement(const wxString& strQuery, bool bLogForCleanup)
{
ResetErrorCodes();
if (m_pDatabase != NULL)
{
SqlitePreparedStatement* pReturnStatement = new SqlitePreparedStatement((sqlite3*)m_pDatabase);
if (pReturnStatement)
pReturnStatement->SetEncoding(GetEncoding());
wxArrayString QueryArray = ParseQueries(strQuery);
wxArrayString::iterator start = QueryArray.begin();
wxArrayString::iterator stop = QueryArray.end();
while (start != stop)
{
const char* szTail=0;
wxCharBuffer sqlBuffer;
do
{
sqlite3_stmt* pStatement;
wxString strSQL;
if (szTail != 0)
{
strSQL = (wxChar*)szTail;
}
else
{
strSQL = (*start);
}
sqlBuffer = ConvertToUnicodeStream(strSQL);
#if SQLITE_VERSION_NUMBER>=3003009
int nReturn = sqlite3_prepare_v2((sqlite3*)m_pDatabase, sqlBuffer, -1, &pStatement, &szTail);
#else
int nReturn = sqlite3_prepare((sqlite3*)m_pDatabase, sqlBuffer, -1, &pStatement, &szTail);
#endif
if (nReturn != SQLITE_OK)
{
SetErrorCode(SqliteDatabaseLayer::TranslateErrorCode(nReturn));
SetErrorMessage(ConvertFromUnicodeStream(sqlite3_errmsg((sqlite3*)m_pDatabase)));
wxDELETE(pReturnStatement);
ThrowDatabaseException();
return NULL;
}
pReturnStatement->AddPreparedStatement(pStatement);
#if wxUSE_UNICODE
} while (strlen(szTail) > 0);
#else
} while (wxStrlen(szTail) > 0);
#endif
start++;
}
if (bLogForCleanup)
LogStatementForCleanup(pReturnStatement);
return pReturnStatement;
}
OPENMPT_NAMESPACE_BEGIN
#if MPT_COMPILER_GCC
#if MPT_GCC_AT_LEAST(4,6,0)
#pragma GCC diagnostic push
#endif
#pragma GCC diagnostic ignored "-Wswitch"
#elif MPT_COMPILER_CLANG
#pragma clang diagnostic push
#if MPT_CLANG_AT_LEAST(3,3,0)
#pragma clang diagnostic ignored "-Wswitch"
#else
#pragma clang diagnostic ignored "-Wswitch-enum"
#endif
#endif
// Read a sample from memory
size_t SampleIO::ReadSample(ModSample &sample, FileReader &file) const
//--------------------------------------------------------------------
{
if(sample.nLength < 1 || !file.IsValid())
{
return 0;
}
LimitMax(sample.nLength, MAX_SAMPLE_LENGTH);
const char * const sourceBuf = file.GetRawData();
const FileReader::off_t fileSize = file.BytesLeft(), filePosition = file.GetPosition();
FileReader::off_t bytesRead = 0; // Amount of memory that has been read from file
sample.uFlags.set(CHN_16BIT, GetBitDepth() >= 16);
sample.uFlags.set(CHN_STEREO, GetChannelFormat() != mono);
size_t sampleSize = sample.AllocateSample(); // Target sample size in bytes
if(sampleSize == 0)
{
sample.nLength = 0;
return 0;
}
ASSERT(sampleSize >= sample.GetSampleSizeInBytes());
//////////////////////////////////////////////////////
// 8-Bit / Mono / PCM
if(GetBitDepth() == 8 && GetChannelFormat() == mono)
{
switch(GetEncoding())
{
case signedPCM: // 8-Bit / Mono / Signed / PCM
bytesRead = CopyMonoSample<SC::DecodeInt8>(sample, sourceBuf, fileSize);
break;
case unsignedPCM: // 8-Bit / Mono / Unsigned / PCM
bytesRead = CopyMonoSample<SC::DecodeUint8>(sample, sourceBuf, fileSize);
break;
case deltaPCM: // 8-Bit / Mono / Delta / PCM
case MT2:
bytesRead = CopyMonoSample<SC::DecodeInt8Delta>(sample, sourceBuf, fileSize);
break;
case PCM7to8: // 7 Bit stored as 8-Bit with highest bit unused / Mono / Signed / PCM
bytesRead = CopyMonoSample<SC::DecodeInt7>(sample, sourceBuf, fileSize);
break;
}
}
//////////////////////////////////////////////////////
// 8-Bit / Stereo Split / PCM
else if(GetBitDepth() == 8 && GetChannelFormat() == stereoSplit)
{
switch(GetEncoding())
{
case signedPCM: // 8-Bit / Stereo Split / Signed / PCM
bytesRead = CopyStereoSplitSample<SC::DecodeInt8>(sample, sourceBuf, fileSize);
break;
case unsignedPCM: // 8-Bit / Stereo Split / Unsigned / PCM
bytesRead = CopyStereoSplitSample<SC::DecodeUint8>(sample, sourceBuf, fileSize);
break;
case deltaPCM: // 8-Bit / Stereo Split / Delta / PCM
case MT2:
bytesRead = CopyStereoSplitSample<SC::DecodeInt8Delta>(sample, sourceBuf, fileSize);
break;
}
}
//////////////////////////////////////////////////////
// 8-Bit / Stereo Interleaved / PCM
else if(GetBitDepth() == 8 && GetChannelFormat() == stereoInterleaved)
{
switch(GetEncoding())
{
case signedPCM: // 8-Bit / Stereo Interleaved / Signed / PCM
bytesRead = CopyStereoInterleavedSample<SC::DecodeInt8>(sample, sourceBuf, fileSize);
break;
case unsignedPCM: // 8-Bit / Stereo Interleaved / Unsigned / PCM
bytesRead = CopyStereoInterleavedSample<SC::DecodeUint8>(sample, sourceBuf, fileSize);
break;
case deltaPCM: // 8-Bit / Stereo Interleaved / Delta / PCM
bytesRead = CopyStereoInterleavedSample<SC::DecodeInt8Delta>(sample, sourceBuf, fileSize);
break;
}
}
//////////////////////////////////////////////////////
// 16-Bit / Mono / Little Endian / PCM
else if(GetBitDepth() == 16 && GetChannelFormat() == mono && GetEndianness() == littleEndian)
{
switch(GetEncoding())
{
case signedPCM: // 16-Bit / Stereo Interleaved / Signed / PCM
bytesRead = CopyMonoSample<SC::DecodeInt16<0, littleEndian16> >(sample, sourceBuf, fileSize);
break;
case unsignedPCM: // 16-Bit / Stereo Interleaved / Unsigned / PCM
bytesRead = CopyMonoSample<SC::DecodeInt16<0x8000u, littleEndian16> >(sample, sourceBuf, fileSize);
break;
case deltaPCM: // 16-Bit / Stereo Interleaved / Delta / PCM
case MT2:
bytesRead = CopyMonoSample<SC::DecodeInt16Delta<littleEndian16> >(sample, sourceBuf, fileSize);
break;
}
}
//////////////////////////////////////////////////////
// 16-Bit / Mono / Big Endian / PCM
else if(GetBitDepth() == 16 && GetChannelFormat() == mono && GetEndianness() == bigEndian)
{
switch(GetEncoding())
{
case signedPCM: // 16-Bit / Mono / Signed / PCM
bytesRead = CopyMonoSample<SC::DecodeInt16<0, bigEndian16> >(sample, sourceBuf, fileSize);
break;
case unsignedPCM: // 16-Bit / Mono / Unsigned / PCM
bytesRead = CopyMonoSample<SC::DecodeInt16<0x8000u, bigEndian16> >(sample, sourceBuf, fileSize);
break;
case deltaPCM: // 16-Bit / Mono / Delta / PCM
bytesRead = CopyMonoSample<SC::DecodeInt16Delta<bigEndian16> >(sample, sourceBuf, fileSize);
break;
}
}
//////////////////////////////////////////////////////
// 16-Bit / Stereo Split / Little Endian / PCM
else if(GetBitDepth() == 16 && GetChannelFormat() == stereoSplit && GetEndianness() == littleEndian)
{
switch(GetEncoding())
{
case signedPCM: // 16-Bit / Stereo Split / Signed / PCM
bytesRead = CopyStereoSplitSample<SC::DecodeInt16<0, littleEndian16> >(sample, sourceBuf, fileSize);
break;
case unsignedPCM: // 16-Bit / Stereo Split / Unsigned / PCM
bytesRead = CopyStereoSplitSample<SC::DecodeInt16<0x8000u, littleEndian16> >(sample, sourceBuf, fileSize);
break;
case deltaPCM: // 16-Bit / Stereo Split / Delta / PCM
case MT2:
bytesRead = CopyStereoSplitSample<SC::DecodeInt16Delta<littleEndian16> >(sample, sourceBuf, fileSize);
break;
}
}
//////////////////////////////////////////////////////
// 16-Bit / Stereo Split / Big Endian / PCM
else if(GetBitDepth() == 16 && GetChannelFormat() == stereoSplit && GetEndianness() == bigEndian)
{
switch(GetEncoding())
{
case signedPCM: // 16-Bit / Stereo Split / Signed / PCM
bytesRead = CopyStereoSplitSample<SC::DecodeInt16<0, bigEndian16> >(sample, sourceBuf, fileSize);
break;
case unsignedPCM: // 16-Bit / Stereo Split / Unsigned / PCM
bytesRead = CopyStereoSplitSample<SC::DecodeInt16<0x8000u, bigEndian16> >(sample, sourceBuf, fileSize);
break;
case deltaPCM: // 16-Bit / Stereo Split / Delta / PCM
bytesRead = CopyStereoSplitSample<SC::DecodeInt16Delta<bigEndian16> >(sample, sourceBuf, fileSize);
break;
}
}
//////////////////////////////////////////////////////
// 16-Bit / Stereo Interleaved / Little Endian / PCM
else if(GetBitDepth() == 16 && GetChannelFormat() == stereoInterleaved && GetEndianness() == littleEndian)
{
switch(GetEncoding())
{
case signedPCM: // 16-Bit / Stereo Interleaved / Signed / PCM
bytesRead = CopyStereoInterleavedSample<SC::DecodeInt16<0, littleEndian16> >(sample, sourceBuf, fileSize);
break;
case unsignedPCM: // 16-Bit / Stereo Interleaved / Unsigned / PCM
bytesRead = CopyStereoInterleavedSample<SC::DecodeInt16<0x8000u, littleEndian16> >(sample, sourceBuf, fileSize);
break;
case deltaPCM: // 16-Bit / Stereo Interleaved / Delta / PCM
bytesRead = CopyStereoInterleavedSample<SC::DecodeInt16Delta<littleEndian16> >(sample, sourceBuf, fileSize);
break;
}
}
//////////////////////////////////////////////////////
// 16-Bit / Stereo Interleaved / Big Endian / PCM
else if(GetBitDepth() == 16 && GetChannelFormat() == stereoInterleaved && GetEndianness() == bigEndian)
{
switch(GetEncoding())
{
case signedPCM: // 16-Bit / Stereo Interleaved / Signed / PCM
bytesRead = CopyStereoInterleavedSample<SC::DecodeInt16<0, bigEndian16> >(sample, sourceBuf, fileSize);
break;
case unsignedPCM: // 16-Bit / Stereo Interleaved / Unsigned / PCM
bytesRead = CopyStereoInterleavedSample<SC::DecodeInt16<0x8000u, bigEndian16> >(sample, sourceBuf, fileSize);
break;
case deltaPCM: // 16-Bit / Stereo Interleaved / Delta / PCM
bytesRead = CopyStereoInterleavedSample<SC::DecodeInt16Delta<bigEndian16> >(sample, sourceBuf, fileSize);
break;
}
}
//////////////////////////////////////////////////////
// 24-Bit / Signed / Mono / PCM
else if(GetBitDepth() == 24 && GetChannelFormat() == mono && GetEncoding() == signedPCM)
{
if(GetEndianness() == littleEndian)
{
bytesRead = CopyMonoSample<SC::ConversionChain<SC::Convert<int16, int32>, SC::DecodeInt24<0, littleEndian24> > >(sample, sourceBuf, fileSize);
} else
{
bytesRead = CopyMonoSample<SC::ConversionChain<SC::Convert<int16, int32>, SC::DecodeInt24<0, bigEndian24> > >(sample, sourceBuf, fileSize);
}
}
//////////////////////////////////////////////////////
// 24-Bit / Signed / Stereo Interleaved / PCM
else if(GetBitDepth() == 24 && GetChannelFormat() == stereoInterleaved && GetEncoding() == signedPCM)
{
if(GetEndianness() == littleEndian)
{
bytesRead = CopyStereoInterleavedSample<SC::ConversionChain<SC::Convert<int16, int32>, SC::DecodeInt24<0, littleEndian24> > >(sample, sourceBuf, fileSize);
} else
{
bytesRead = CopyStereoInterleavedSample<SC::ConversionChain<SC::Convert<int16, int32>, SC::DecodeInt24<0, bigEndian24> > >(sample, sourceBuf, fileSize);
}
}
//////////////////////////////////////////////////////
// 32-Bit / Signed / Mono / PCM
else if(GetBitDepth() == 32 && GetChannelFormat() == mono && GetEncoding() == signedPCM)
{
if(GetEndianness() == littleEndian)
{
bytesRead = CopyMonoSample<SC::ConversionChain<SC::Convert<int16, int32>, SC::DecodeInt32<0, littleEndian32> > >(sample, sourceBuf, fileSize);
} else
{
bytesRead = CopyMonoSample<SC::ConversionChain<SC::Convert<int16, int32>, SC::DecodeInt32<0, bigEndian32> > >(sample, sourceBuf, fileSize);
}
}
//////////////////////////////////////////////////////
// 32-Bit / Signed / Stereo Interleaved / PCM
else if(GetBitDepth() == 32 && GetChannelFormat() == stereoInterleaved && GetEncoding() == signedPCM)
{
if(GetEndianness() == littleEndian)
{
bytesRead = CopyStereoInterleavedSample<SC::ConversionChain<SC::Convert<int16, int32>, SC::DecodeInt32<0, littleEndian32> > >(sample, sourceBuf, fileSize);
} else
{
bytesRead = CopyStereoInterleavedSample<SC::ConversionChain<SC::Convert<int16, int32>, SC::DecodeInt32<0, bigEndian32> > >(sample, sourceBuf, fileSize);
}
}
//////////////////////////////////////////////////////
// 32-Bit / Float / Mono / PCM
else if(GetBitDepth() == 32 && GetChannelFormat() == mono && GetEncoding() == floatPCM)
{
if(GetEndianness() == littleEndian)
{
bytesRead = CopyMonoSample<SC::ConversionChain<SC::Convert<int16, float32>, SC::DecodeFloat32<littleEndian32> > >(sample, sourceBuf, fileSize);
} else
{
bytesRead = CopyMonoSample<SC::ConversionChain<SC::Convert<int16, float32>, SC::DecodeFloat32<bigEndian32> > >(sample, sourceBuf, fileSize);
}
}
//////////////////////////////////////////////////////
// 32-Bit / Float / Stereo Interleaved / PCM
else if(GetBitDepth() == 32 && GetChannelFormat() == stereoInterleaved && GetEncoding() == floatPCM)
{
if(GetEndianness() == littleEndian)
{
bytesRead = CopyStereoInterleavedSample<SC::ConversionChain<SC::Convert<int16, float32>, SC::DecodeFloat32<littleEndian32> > >(sample, sourceBuf, fileSize);
} else
{
bytesRead = CopyStereoInterleavedSample<SC::ConversionChain<SC::Convert<int16, float32>, SC::DecodeFloat32<bigEndian32> > >(sample, sourceBuf, fileSize);
}
}
//////////////////////////////////////////////////////
// 24-Bit / Signed / Mono, Stereo Interleaved / PCM
else if(GetBitDepth() == 24 && (GetChannelFormat() == mono || GetChannelFormat() == stereoInterleaved) && GetEncoding() == signedPCMnormalize)
{
// Normalize to 16-Bit
uint32 srcPeak = uint32(1)<<31;
if(GetEndianness() == littleEndian)
{
bytesRead = CopyAndNormalizeSample<SC::NormalizationChain<SC::Convert<int16, int32>, SC::DecodeInt24<0, littleEndian24> > >(sample, sourceBuf, fileSize, &srcPeak);
} else
{
bytesRead = CopyAndNormalizeSample<SC::NormalizationChain<SC::Convert<int16, int32>, SC::DecodeInt24<0, bigEndian24> > >(sample, sourceBuf, fileSize, &srcPeak);
}
if(bytesRead)
{
// Adjust sample volume so we do not affect relative volume of the sample. Normalizing is only done to increase precision.
sample.nGlobalVol = static_cast<uint16>(Clamp(Util::muldivr_unsigned(sample.nGlobalVol, srcPeak, uint32(1)<<31), uint32(1), uint32(64)));
}
}
//////////////////////////////////////////////////////
// 32-Bit / Signed / Mono, Stereo Interleaved / PCM
else if(GetBitDepth() == 32 && (GetChannelFormat() == mono || GetChannelFormat() == stereoInterleaved) && GetEncoding() == signedPCMnormalize)
{
// Normalize to 16-Bit
uint32 srcPeak = uint32(1)<<31;
if(GetEndianness() == littleEndian)
{
bytesRead = CopyAndNormalizeSample<SC::NormalizationChain<SC::Convert<int16, int32>, SC::DecodeInt32<0, littleEndian32> > >(sample, sourceBuf, fileSize, &srcPeak);
} else
{
bytesRead = CopyAndNormalizeSample<SC::NormalizationChain<SC::Convert<int16, int32>, SC::DecodeInt32<0, bigEndian32> > >(sample, sourceBuf, fileSize, &srcPeak);
}
if(bytesRead)
{
// Adjust sample volume so we do not affect relative volume of the sample. Normalizing is only done to increase precision.
sample.nGlobalVol = static_cast<uint16>(Clamp(Util::muldivr_unsigned(sample.nGlobalVol, srcPeak, uint32(1)<<31), uint32(1), uint32(64)));
}
}
//////////////////////////////////////////////////////
// 32-Bit / Float / Mono, Stereo Interleaved / PCM
else if(GetBitDepth() == 32 && (GetChannelFormat() == mono || GetChannelFormat() == stereoInterleaved) && GetEncoding() == floatPCMnormalize)
{
// Normalize to 16-Bit
float32 srcPeak = 1.0f;
if(GetEndianness() == littleEndian)
{
bytesRead = CopyAndNormalizeSample<SC::NormalizationChain<SC::Convert<int16, float32>, SC::DecodeFloat32<littleEndian32> > >(sample, sourceBuf, fileSize, &srcPeak);
} else
{
bytesRead = CopyAndNormalizeSample<SC::NormalizationChain<SC::Convert<int16, float32>, SC::DecodeFloat32<bigEndian32> > >(sample, sourceBuf, fileSize, &srcPeak);
}
if(bytesRead)
{
// Adjust sample volume so we do not affect relative volume of the sample. Normalizing is only done to increase precision.
sample.nGlobalVol = Util::Round<uint16>(Clamp(sample.nGlobalVol * srcPeak, 1.0f, 64.0f));
}
}
//////////////////////////////////////////////////////
// 32-Bit / Float / Mono / PCM / full scale 2^15
else if(GetBitDepth() == 32 && GetChannelFormat() == mono && GetEncoding() == floatPCM15)
{
if(GetEndianness() == littleEndian)
{
bytesRead = CopyMonoSample
(sample, sourceBuf, fileSize,
SC::ConversionChain<SC::Convert<int16, float32>, SC::DecodeScaledFloat32<littleEndian32> >
(SC::Convert<int16, float32>(), SC::DecodeScaledFloat32<littleEndian32>(1.0f / static_cast<float>(1<<15)))
);
} else
{
bytesRead = CopyMonoSample
(sample, sourceBuf, fileSize,
SC::ConversionChain<SC::Convert<int16, float32>, SC::DecodeScaledFloat32<bigEndian32> >
(SC::Convert<int16, float32>(), SC::DecodeScaledFloat32<bigEndian32>(1.0f / static_cast<float>(1<<15)))
);
}
}
//////////////////////////////////////////////////////
// 32-Bit / Float / Stereo Interleaved / PCM / full scale 2^15
else if(GetBitDepth() == 32 && GetChannelFormat() == stereoInterleaved && GetEncoding() == floatPCM15)
{
if(GetEndianness() == littleEndian)
{
bytesRead = CopyStereoInterleavedSample
(sample, sourceBuf, fileSize,
SC::ConversionChain<SC::Convert<int16, float32>, SC::DecodeScaledFloat32<littleEndian32> >
(SC::Convert<int16, float32>(), SC::DecodeScaledFloat32<littleEndian32>(1.0f / static_cast<float>(1<<15)))
);
} else
{
bytesRead = CopyStereoInterleavedSample
(sample, sourceBuf, fileSize,
SC::ConversionChain<SC::Convert<int16, float32>, SC::DecodeScaledFloat32<bigEndian32> >
(SC::Convert<int16, float32>(), SC::DecodeScaledFloat32<bigEndian32>(1.0f / static_cast<float>(1<<15)))
);
}
}
//////////////////////////////////////////////////////
// 32-Bit / Float / Stereo Interleaved / PCM / full scale 2^23
else if(GetBitDepth() == 32 && GetChannelFormat() == mono && GetEncoding() == floatPCM23)
{
if(GetEndianness() == littleEndian)
{
bytesRead = CopyMonoSample
(sample, sourceBuf, fileSize,
SC::ConversionChain<SC::Convert<int16, float32>, SC::DecodeScaledFloat32<littleEndian32> >
(SC::Convert<int16, float32>(), SC::DecodeScaledFloat32<littleEndian32>(1.0f / static_cast<float>(1<<23)))
);
} else
{
bytesRead = CopyMonoSample
(sample, sourceBuf, fileSize,
SC::ConversionChain<SC::Convert<int16, float32>, SC::DecodeScaledFloat32<bigEndian32> >
(SC::Convert<int16, float32>(), SC::DecodeScaledFloat32<bigEndian32>(1.0f / static_cast<float>(1<<23)))
);
}
}
//////////////////////////////////////////////////////
// 32-Bit / Float / Stereo Interleaved / PCM / full scale 2^23
else if(GetBitDepth() == 32 && GetChannelFormat() == stereoInterleaved && GetEncoding() == floatPCM23)
{
if(GetEndianness() == littleEndian)
{
bytesRead = CopyStereoInterleavedSample
(sample, sourceBuf, fileSize,
SC::ConversionChain<SC::Convert<int16, float32>, SC::DecodeScaledFloat32<littleEndian32> >
(SC::Convert<int16, float32>(), SC::DecodeScaledFloat32<littleEndian32>(1.0f / static_cast<float>(1<<23)))
);
} else
{
bytesRead = CopyStereoInterleavedSample
(sample, sourceBuf, fileSize,
SC::ConversionChain<SC::Convert<int16, float32>, SC::DecodeScaledFloat32<bigEndian32> >
(SC::Convert<int16, float32>(), SC::DecodeScaledFloat32<bigEndian32>(1.0f / static_cast<float>(1<<23)))
);
}
}
//////////////////////////////////////////////////////
// Compressed samples
if(*this == SampleIO(_8bit, mono, littleEndian, ADPCM))
{
// 4-Bit ADPCM data
int8 compressionTable[16]; // ADPCM Compression LUT
if(file.ReadArray(compressionTable))
{
size_t readLength = (sample.nLength + 1) / 2;
LimitMax(readLength, file.BytesLeft());
const uint8 *inBuf = reinterpret_cast<const uint8*>(sourceBuf) + sizeof(compressionTable);
int8 *outBuf = static_cast<int8 *>(sample.pSample);
int8 delta = 0;
for(size_t i = readLength; i != 0; i--)
{
delta += compressionTable[*inBuf & 0x0F];
*(outBuf++) = delta;
delta += compressionTable[(*inBuf >> 4) & 0x0F];
*(outBuf++) = delta;
inBuf++;
}
bytesRead = sizeof(compressionTable) + readLength;
}
bool loadAddonXMLFile (std::string AddonXMLFilename)
{
TiXmlDocument xmlAddonXML;
if (!xmlAddonXML.LoadFile(AddonXMLFilename.c_str()))
{
printf ("%s %s\n", xmlAddonXML.ErrorDesc(), (WorkingDir + "addon.xml").c_str());
return false;
}
GetEncoding(&xmlAddonXML, addonXMLEncoding);
TiXmlElement* pRootElement = xmlAddonXML.RootElement();
if (!pRootElement || pRootElement->NoChildren() || pRootElement->ValueTStr()!="addon")
{
printf ("error: No root element called: \"addon\" or no child found in AddonXML file: %s\n",
AddonXMLFilename.c_str());
return false;
}
const char* pMainAttrId = NULL;
pMainAttrId=pRootElement->Attribute("id");
if (!pMainAttrId)
{
printf ("warning: No addon name was available in addon.xml file: %s\n", AddonXMLFilename.c_str());
ProjName = "xbmc-unnamed";
}
else
ProjName = EscapeLF(pMainAttrId);
pMainAttrId=pRootElement->Attribute("version");
if (!pMainAttrId)
{
printf ("warning: No version name was available in addon.xml file: %s\n", AddonXMLFilename.c_str());
ProjVersion = "rev_unknown";
}
else
ProjVersion = EscapeLF(pMainAttrId);
pMainAttrId=pRootElement->Attribute("name");
if (!pMainAttrId)
{
printf ("warning: No addon name was available in addon.xml file: %s\n", AddonXMLFilename.c_str());
ProjTextName = "unknown";
}
else
ProjTextName = EscapeLF(pMainAttrId);
pMainAttrId=pRootElement->Attribute("provider-name");
if (!pMainAttrId)
{
printf ("warning: No addon provider was available in addon.xml file: %s\n", AddonXMLFilename.c_str());
ProjProvider = "unknown";
}
else
ProjProvider = EscapeLF(pMainAttrId);
std::string strAttrToSearch = "xbmc.addon.metadata";
const TiXmlElement *pChildElement = pRootElement->FirstChildElement("extension");
while (pChildElement && strcmp(pChildElement->Attribute("point"), "xbmc.addon.metadata") != 0)
pChildElement = pChildElement->NextSiblingElement("extension");
const TiXmlElement *pChildSummElement = pChildElement->FirstChildElement("summary");
while (pChildSummElement && pChildSummElement->FirstChild())
{
std::string strLang = pChildSummElement->Attribute("lang");
if (pChildSummElement->FirstChild())
{
std::string strValue = EscapeLF(pChildSummElement->FirstChild()->Value());
mapAddonXMLData[strLang].strSummary = strValue;
}
pChildSummElement = pChildSummElement->NextSiblingElement("summary");
}
const TiXmlElement *pChildDescElement = pChildElement->FirstChildElement("description");
while (pChildDescElement && pChildDescElement->FirstChild())
{
std::string strLang = pChildDescElement->Attribute("lang");
if (pChildDescElement->FirstChild())
{
std::string strValue = EscapeLF(pChildDescElement->FirstChild()->Value());
mapAddonXMLData[strLang].strDescription = strValue;
}
pChildDescElement = pChildDescElement->NextSiblingElement("description");
}
const TiXmlElement *pChildDisclElement = pChildElement->FirstChildElement("disclaimer");
while (pChildDisclElement && pChildDisclElement->FirstChild())
{
std::string strLang = pChildDisclElement->Attribute("lang");
if (pChildDisclElement->FirstChild())
{
std::string strValue = EscapeLF(pChildDisclElement->FirstChild()->Value());
mapAddonXMLData[strLang].strDisclaimer = strValue;
}
pChildDisclElement = pChildDisclElement->NextSiblingElement("disclaimer");
}
return true;
}
wxFontEncoding
wxFontMapper::CharsetToEncoding(const wxString& charset, bool interactive)
{
// try the ways not needing the users intervention first
int encoding = wxFontMapperBase::NonInteractiveCharsetToEncoding(charset);
// if we failed to find the encoding, ask the user -- unless disabled
if ( encoding == wxFONTENCODING_UNKNOWN )
{
// this is the special value which disables asking the user (he had
// chosen to suppress this the last time)
encoding = wxFONTENCODING_SYSTEM;
}
#if wxUSE_CHOICEDLG
else if ( (encoding == wxFONTENCODING_SYSTEM) && interactive )
{
// prepare the dialog data
// the dialog title
wxString title(m_titleDialog);
if ( !title )
title << wxTheApp->GetAppDisplayName() << _(": unknown charset");
// the message
wxString msg;
msg.Printf(_("The charset '%s' is unknown. You may select\nanother charset to replace it with or choose\n[Cancel] if it cannot be replaced"), charset);
// the list of choices
const size_t count = GetSupportedEncodingsCount();
wxString *encodingNamesTranslated = new wxString[count];
for ( size_t i = 0; i < count; i++ )
{
encodingNamesTranslated[i] = GetEncodingDescription(GetEncoding(i));
}
// the parent window
wxWindow *parent = m_windowParent;
if ( !parent )
parent = wxTheApp->GetTopWindow();
// do ask the user and get back the index in encodings table
int n = wxGetSingleChoiceIndex(msg, title,
count,
encodingNamesTranslated,
parent);
delete [] encodingNamesTranslated;
if ( n != -1 )
{
encoding = GetEncoding(n);
}
#if wxUSE_CONFIG && wxUSE_FILECONFIG
// save the result in the config now
wxFontMapperPathChanger path(this, FONTMAPPER_CHARSET_PATH);
if ( path.IsOk() )
{
wxConfigBase *config = GetConfig();
// remember the alt encoding for this charset -- or remember that
// we don't know it
long value = n == -1 ? (long)wxFONTENCODING_UNKNOWN : (long)encoding;
if ( !config->Write(charset, value) )
{
wxLogError(_("Failed to remember the encoding for the charset '%s'."), charset);
}
}
#endif // wxUSE_CONFIG
}
#else
wxUnusedVar(interactive);
#endif // wxUSE_CHOICEDLG
return (wxFontEncoding)encoding;
}
wxString wxNativeFontInfo::ToUserString() const
{
wxString desc;
// first put the adjectives, if any - this is English-centric, of course,
// but what else can we do?
if ( GetUnderlined() )
{
desc << _("underlined");
}
if ( GetStrikethrough() )
{
desc << _("strikethrough");
}
switch ( GetWeight() )
{
default:
wxFAIL_MSG( wxT("unknown font weight") );
// fall through
case wxFONTWEIGHT_NORMAL:
break;
case wxFONTWEIGHT_LIGHT:
desc << _(" light");
break;
case wxFONTWEIGHT_BOLD:
desc << _(" bold");
break;
}
switch ( GetStyle() )
{
default:
wxFAIL_MSG( wxT("unknown font style") );
// fall through
case wxFONTSTYLE_NORMAL:
break;
// we don't distinguish between the two for now anyhow...
case wxFONTSTYLE_ITALIC:
case wxFONTSTYLE_SLANT:
desc << _(" italic");
break;
}
wxString face = GetFaceName();
if ( !face.empty() )
{
if (face.Contains(' ') || face.Contains(';') || face.Contains(','))
{
face.Replace("'", "");
// eventually remove quote characters: most systems do not
// allow them in a facename anyway so this usually does nothing
// make it possible for FromUserString() function to understand
// that the different words which compose this facename are
// not different adjectives or other data but rather all parts
// of the facename
desc << wxT(" '") << face << _("'");
}
else
desc << wxT(' ') << face;
}
else // no face name specified
{
// use the family
wxString familyStr;
switch ( GetFamily() )
{
case wxFONTFAMILY_DECORATIVE:
familyStr = "decorative";
break;
case wxFONTFAMILY_ROMAN:
familyStr = "roman";
break;
case wxFONTFAMILY_SCRIPT:
familyStr = "script";
break;
case wxFONTFAMILY_SWISS:
familyStr = "swiss";
break;
case wxFONTFAMILY_MODERN:
familyStr = "modern";
break;
case wxFONTFAMILY_TELETYPE:
familyStr = "teletype";
break;
case wxFONTFAMILY_DEFAULT:
case wxFONTFAMILY_UNKNOWN:
break;
default:
wxFAIL_MSG( "unknown font family" );
}
if ( !familyStr.empty() )
desc << " '" << familyStr << " family'";
}
int size = GetPointSize();
if ( size != wxNORMAL_FONT->GetPointSize() )
{
desc << wxT(' ') << size;
}
#if wxUSE_FONTMAP
wxFontEncoding enc = GetEncoding();
if ( enc != wxFONTENCODING_DEFAULT && enc != wxFONTENCODING_SYSTEM )
{
desc << wxT(' ') << wxFontMapper::GetEncodingName(enc);
}
#endif // wxUSE_FONTMAP
return desc.Strip(wxString::both).MakeLower();
}
