Rocket::Core::FileHandle UI_FileInterface::Open(const Rocket::Core::String & path)
{
int filenum = 0;
int length = -1;
Rocket::Core::URL url( path );
Rocket::Core::String protocol = url.GetProtocol();
// local
if( protocol.Empty() || protocol == "file" ) {
Rocket::Core::String path2( url.GetPathedFileName() );
if( path2[0] == '/' ) {
path2.Erase( 0, 1 );
}
length = trap::FS_FOpenFile( path2.CString(), &filenum, FS_READ );
}
else if( protocol == "http" ) {
// allow blocking download of remote resources
length = trap::FS_FOpenFile( path.CString(), &filenum, FS_READ );
}
if( length == -1 )
return 0;
// cache file length
fileSizeMap[filenum] = length;
// Com_Printf("UI_FileInterface opened %s\n", path2.CString() );
return static_cast<Rocket::Core::FileHandle>( filenum );
}
DataFormatter::DataFormatter(const Rocket::Core::String& _name)
{
if (!_name.Empty())
{
name = _name;
}
else
{
name.FormatString(64, "%x", this);
}
data_formatters[name] = this;
}
// Submits the form.
void ElementForm::Submit(const Rocket::Core::String& name, const Rocket::Core::String& submit_value)
{
Rocket::Core::Dictionary values;
if (name.Empty())
values.Set("submit", submit_value);
else
values.Set(name, submit_value);
Core::ElementList form_controls;
Core::ElementUtilities::GetElementsByTagName(form_controls, this, "input");
Core::ElementUtilities::GetElementsByTagName(form_controls, this, "textarea");
Core::ElementUtilities::GetElementsByTagName(form_controls, this, "select");
Core::ElementUtilities::GetElementsByTagName(form_controls, this, "dataselect");
for (size_t i = 0; i < form_controls.size(); i++)
{
ElementFormControl* control = rocket_dynamic_cast< ElementFormControl* >(form_controls[i]);
if (!control)
continue;
// Skip disabled controls.
if (control->IsDisabled())
continue;
// Only process controls that should be submitted.
if (!control->IsSubmitted())
continue;
Rocket::Core::String control_name = control->GetName();
Rocket::Core::String control_value = control->GetValue();
// Skip over unnamed form controls.
if (control_name.Empty())
continue;
// If the item already exists, append to it.
Rocket::Core::Variant* value = values.Get(control_name);
if (value != NULL)
value->Set(value->Get< Rocket::Core::String >() + ", " + control_value);
else
values.Set< Rocket::Core::String >(control_name, control_value);
}
DispatchEvent("submit", values);
}
void DataQuery::ExecuteQuery(DataSource* _data_source, const Rocket::Core::String& _table, const Rocket::Core::String& _fields, int _offset, int _limit, const Rocket::Core::String& order)
{
data_source = _data_source;
table = _table;
offset = _offset;
limit = _limit;
// Set up the field list and field index cache.
Rocket::Core::StringUtilities::ExpandString(fields, _fields);
for (size_t i = 0; i < fields.size(); i++)
{
field_indices[fields[i]] = i;
}
// Initialise the row pointer.
current_row = -1;
// If limit is -1, then we fetch to the end of the data source.
if (limit == -1)
{
limit = data_source->GetNumRows(table) - offset;
}
if (!order.Empty())
{
// Fetch the rows from offset to limit.
rows.resize(limit);
for (int i = 0; i < limit; i++)
{
data_source->GetRow(rows[i], table, offset + i, fields);
}
// Now sort the rows, based on the ordering requirements.
Rocket::Core::StringList order_parameters;
Rocket::Core::StringUtilities::ExpandString(order_parameters, order);
sort(rows.begin(), rows.end(), DataQuerySort(order_parameters));
}
}
void ElementDocumentWrapper::LoadScript(Rocket::Core::Stream* stream, const Rocket::Core::String& source_name)
{
// If theres a source, check if the code is already loaded and just reuse it
if (!source_name.Empty())
{
Rocket::Core::String module_name = Rocket::Core::String(source_name).Replace("/", "_");
module_name = module_name.Replace("\\", "_");
module_name = module_name.Replace(".py", "");
PyObject* modules = PyImport_GetModuleDict();
PyObject* merge_module = PyDict_GetItemString(modules, module_name.CString());
#ifdef ROCKET_DEBUG
// In debug builds, force module to NULL so that scripts are always reloaded
merge_module = NULL;
#else
if (merge_module)
{
Py_INCREF(merge_module);
}
#endif
if (!merge_module)
{
// Compile the code as a python module
Rocket::Core::String source_buffer;
PreprocessCode(source_buffer, stream);
PyObject* code = Py_CompileString(source_buffer.CString(), source_name.CString(), Py_file_input);
if (code)
{
merge_module = PyImport_ExecCodeModule((char*)module_name.CString(), code);
Py_DECREF(code);
}
}
if (merge_module)
{
PyObject* dict = PyModule_GetDict(merge_module);
PyDict_Merge(module_namespace, dict, 0);
Py_DECREF(merge_module);
}
else
{
Rocket::Core::Python::Utilities::PrintError();
}
}
else
{
// Compile directly onto the python module
Rocket::Core::String source_buffer;
PreprocessCode(source_buffer, stream);
PyObject* result = PyRun_String(source_buffer.CString(), Py_file_input, module_namespace, module_namespace);
if ( !result )
{
Rocket::Core::Python::Utilities::PrintError();
}
else
{
Py_DECREF(result);
}
}
}
Rocket::Core::String Rocket_QuakeToRML(const char* in, int parseFlags = 0) {
const char* p;
Rocket::Core::String out;
Rocket::Core::String spanstr;
bool span = false;
bool spanHasContent = false;
if (!*in) {
return "";
}
for (p = in; p && *p; ++p) {
if (*p == '<') {
if (span && !spanHasContent) {
spanHasContent = true;
out.Append(spanstr);
}
out.Append("<");
} else if (*p == '>') {
if (span && !spanHasContent) {
spanHasContent = true;
out.Append(spanstr);
}
out.Append(">");
} else if (*p == '&') {
if (span && !spanHasContent) {
spanHasContent = true;
out.Append(spanstr);
}
out.Append("&");
} else if (*p == '\n') {
out.Append(span && spanHasContent ? "</span><br />" : "<br />");
span = false;
spanHasContent = false;
} else if (Q_IsColorString(p)) {
if (span && spanHasContent) {
out.Append("</span>");
span = false;
spanHasContent = false;
}
char rgb[32];
int code = ColorIndex(*++p);
Com_sprintf(rgb, sizeof(rgb), "<span style='color: #%02X%02X%02X;'>", (int) (g_color_table[code][0] * 255), (int) (g_color_table[code][1] * 255), (int) (g_color_table[code][2] * 255));
// don't add the span yet, because it might be empty
spanstr = rgb;
span = true;
spanHasContent = false;
} else {
if (span && !spanHasContent) {
out.Append(spanstr);
spanHasContent = true;
}
out.Append(*p);
}
}
if (span && spanHasContent) {
out.Append("</span>");
}
// ^^ -> ^
while (out.Find("^^") != Rocket::Core::String::npos) {
out = out.Replace("^^", "^");
}
if (parseFlags & RP_EMOTICONS) {
// Parse emoticons
size_t openBracket = 0;
size_t closeBracket = 0;
size_t currentPosition = 0;
while (1) {
Rocket::Core::String emoticon;
const char* path;
openBracket = out.Find("[", currentPosition);
if (openBracket == Rocket::Core::String::npos) {
break;
}
closeBracket = out.Find("]", openBracket);
if (closeBracket == Rocket::Core::String::npos) {
break;
}
emoticon = out.Substring(openBracket + 1, closeBracket - openBracket - 1);
// Certain characters are invalid
if (emoticon.Empty() || IsInvalidEmoticon(emoticon)) {
currentPosition = closeBracket + 1;
continue;
}
// TODO: Dont hardcode the extension.
path = va("emoticons/%s.crn", emoticon.CString());
if (FS_FOpenFileRead(path, nullptr, true)) {
out.Erase(openBracket, closeBracket - openBracket + 1);
path = va("<img class='trem-emoticon' src='/emoticons/%s' />",
emoticon.CString());
out.Insert(openBracket, path);
currentPosition = openBracket + strlen(path) + 1;
} else {
currentPosition = closeBracket + 1;
}
}
}
return out;
}
