static kbool_t iterator_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, KTraceInfo *trace)
{
KRequireKonohaCommonModule(trace);
if(CT_Iterator == NULL) {
kparamtype_t IteratorParam = {TY_Object};
KDEFINE_CLASS defIterator = {0};
SETSTRUCTNAME(defIterator, Iterator);
defIterator.cflag = CFLAG_Iterator;
defIterator.init = Iterator_Init;
defIterator.cparamsize = 1;
defIterator.cParamItems = &IteratorParam;
CT_Iterator = KLIB kNameSpace_DefineClass(kctx, ns, NULL, &defIterator, trace);
CT_StringIterator = CT_p0(kctx, CT_Iterator, TY_String);
CT_GenericIterator = CT_p0(kctx, CT_Iterator, TY_0);
}
KDEFINE_METHOD MethodData[] = {
_Public, _F(Iterator_hasNext), TY_boolean, TY_Iterator, MN_("hasNext"), 0,
_Public, _F(Iterator_next), TY_0, TY_Iterator, MN_("next"), 0,
_Public, _F(Array_toIterator), TY_GenericIterator, TY_Array, MN_("toIterator"), 0,
_Public, _F(String_toIterator), TY_StringIterator, TY_String, MN_("toIterator"), 0,
DEND,
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
return true;
}
static kbool_t exception_initPackage(KonohaContext *kctx, kNameSpace *ns, int argc, const char**args, kfileline_t pline)
{
KonohaExceptionModule *mod = (KonohaExceptionModule*)KCALLOC(sizeof(KonohaExceptionModule), 1);
mod->h.name = "exception";
mod->h.setup = kModuleException_setup;
mod->h.reftrace = kModuleException_reftrace;
mod->h.free = kModuleException_free;
KLIB Konoha_setModule(kctx, MOD_exception, &mod->h, pline);
KDEFINE_CLASS defException = {
STRUCTNAME(Exception),
.cflag = CFLAG_Exception,
.init = Exception_init,
.reftrace = Exception_reftrace,
.p = Exception_p,
};
mod->cException = KLIB Konoha_defineClass(kctx, ns->packageId, PN_konoha, NULL, &defException, pline);
KDEFINE_METHOD MethodData[] = {
_Public|_Hidden, _F(System_throw), TY_void, TY_System, MN_("throw"), 1, TY_Exception, FN_("e"),
_Public|_Hidden, _F(System_getThrownException), TY_Exception, TY_System, MN_("getThrownException"), 0,
DEND,
};
KLIB kNameSpace_loadMethodData(kctx, ns, MethodData);
return true;
}
static kbool_t bytes_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, KTraceInfo *trace)
{
KRequireKonohaCommonModule(trace);
//KImportPackageSymbol(ns, "cstyle", "$SingleQuotedChar", trace);
if(KClass_Bytes == NULL) {
KDEFINE_CLASS defBytes = {0};
SETSTRUCTNAME(defBytes, Bytes);
defBytes.cflag = KClassFlag_Final;
defBytes.free = kBytes_Free;
defBytes.init = kBytes_Init;
defBytes.format = kBytes_format;
KClass_Bytes = KLIB kNameSpace_DefineClass(kctx, ns, NULL, &defBytes, trace);
}
int FN_index = KFieldName_("index");
int FN_c = KFieldName_("c");
int FN_size = KFieldName_("size");
KDEFINE_METHOD MethodData[] = {
_Public, _F(Bytes_new), KType_Bytes, KType_Bytes, KMethodName_("new"), 1, KType_Int, FN_size,
_Public|_Im, _F(Bytes_getSize), KType_Int, KType_Bytes, KMethodName_("getSize"), 0,
_Public|_Im, _F(Bytes_get), KType_Int, KType_Bytes, KMethodName_("get"), 1, KType_Int, FN_index,
_Public, _F(Bytes_Set), KType_void, KType_Bytes, KMethodName_("set"), 2, KType_Int, FN_index, KType_Int, FN_c,
_Public, _F(Bytes_SetAll), KType_void, KType_Bytes, KMethodName_("setAll"), 1, KType_Int, FN_c,
_Public|_Im|_Coercion, _F(String_toBytes), KType_Bytes, KType_String, KMethodName_To(KType_Bytes), 0,
//_Public|_Im|_Coercion, _F(Bytes_toString), KType_String, KType_Bytes, KMethodName_To(KType_String), 0,
//_Public|_Const, _F(Bytes_encodeTo), KType_Bytes, KType_Bytes, KMethodName_("encodeTo"), 1, KType_String, FN_encoding,
//_Public|_Const, _F(Bytes_decodeFrom), KType_String, KType_Bytes, KMethodName_("decodeFrom"), 1, KType_String, FN_encoding,
_Public, _F(String_new_fromBytes_withDefaultDecode), KType_String, KType_String, KMethodName_("new"), 1, KType_Bytes, KFieldName_("ba"),
_Public, _F(String_new_fromBytes_withSpecifiedDecode), KType_String, KType_String, KMethodName_("new"), 2, KType_Bytes, KFieldName_("ba"), KType_String, KFieldName_("charset"),
_Public, _F(String_new_fromSubBytes_withDefaultDecode), KType_String, KType_String, KMethodName_("new"), 3, KType_Bytes, KFieldName_("ba"), KType_Int, KFieldName_("offset"), KType_Int, KFieldName_("length"),
_Public, _F(String_new_fromSubBytes_withSpecifiedDecode), KType_String, KType_String, KMethodName_("new"), 4, KType_Bytes, KFieldName_("ba"), KType_Int, KFieldName_("offset"), KType_Int, KFieldName_("length"), KType_String, KFieldName_("charset"),
DEND,
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
return true;
}
void check_and_log_error(const char *function_name) {
GLuint error = glGetError();
if(error != GL_NO_ERROR) {
std::string error_string;
switch(error) {
case GL_INVALID_ENUM:
error_string = "GL_INVALID_ENUM";
break;
case GL_INVALID_VALUE:
error_string = "GL_INVALID_VALUE";
break;
case GL_INVALID_OPERATION:
error_string = "GL_INVALID_OPERATION";
break;
case GL_INVALID_FRAMEBUFFER_OPERATION_EXT:
error_string = "GL_INVALID_FRAMEBUFFER_OPERATION";
break;
case GL_OUT_OF_MEMORY:
error_string = "GL_OUT_OF_MEMORY";
break;
#ifndef __ANDROID__
case GL_STACK_OVERFLOW:
error_string = "GL_STACK_OVERFLOW";
break;
case GL_STACK_UNDERFLOW:
error_string = "GL_STACK_UNDERFLOW";
break;
#endif
}
L_ERROR(_F("An OpenGL error occurred: {0} - {1}").format(function_name, error_string));
throw std::runtime_error(_F("GL ERROR: {0}").format(error_string));
}
}
static kbool_t Libevent_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, KTraceInfo *trace)
{
/* Class Definition */
KDEFINE_CLASS defLibevent = {0};
SETSTRUCTNAME(defLibevent, Libevent);
defLibevent.cflag = KClassFlag_Final;
defLibevent.init = Libevent_Init;
defLibevent.free = Libevent_Free;
KClass *LibeventClass = KLIB kNameSpace_DefineClass(kctx, ns, NULL, &defLibevent, trace);
int KType_Libevent = LibeventClass->typeId;
KDEFINE_METHOD MethodData[] = {
_Public, _F(Libevent_new), KType_Libevent, KType_Libevent, KMethodName_("new"), 0,
_Public, _F(Libevent_dispatch), KType_Libevent, KType_Libevent, KMethodName_("dispatch"), 0,
_Public, _F(Libevent_event_add), KType_Int, KType_Libevent, KMethodName_("event_add"), 2, KType_Object, KFieldName_("timeval"),
_Public, _F(Libevent_event_del), KType_Int, KType_Libevent, KMethodName_("event_del"), 1,
#ifdef CUTCUT
_Public, _F(Person_say), KType_String, KType_Person, KMethodName_("say"), 0,
#endif
DEND, /* <= sentinel */
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
return true;
}
static kbool_t HelloWorld_PackupNameSpace(KonohaContext *kctx, kNameSpace *ns, int option, KTraceInfo *trace)
{
/* Class Definition */
/* If you want to create Generic class like Array<T>, see konoha.map package */
KDEFINE_CLASS defPerson = {0};
SETSTRUCTNAME(defPerson, Person);
defPerson.cflag = kClass_Final;
defPerson.init = Person_Init;
defPerson.p = Person_p;
defPerson.reftrace = Person_Reftrace;
defPerson.free = Person_Free;
KonohaClass *PersonClass = KLIB kNameSpace_DefineClass(kctx, ns, NULL, &defPerson, trace);
/* You can define methods with the following procedures. */
int TY_Person = PersonClass->typeId;
int FN_x = FN_("x");
int FN_y = FN_("y");
KDEFINE_METHOD MethodData[] = {
_Public, _F(Person_new), TY_Person, TY_Person, MN_("new"), 2, TY_String, FN_x, TY_int, FN_y,
_Public, _F(Person_say), TY_String, TY_Person, MN_("say"), 0,
DEND, /* <= sentinel */
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
/* You can define constant variable with the following procedures. */
KDEFINE_INT_CONST IntData[] = {
{"NARUTO_AGE", TY_int, 18},
{} /* <= sentinel */
};
KLIB kNameSpace_LoadConstData(kctx, ns, KonohaConst_(IntData), false/*isOverride*/, trace);
return true;
}
static kbool_t konoha_defineMethod(KonohaContext *kctx, kNameSpace *ns, KTraceInfo *trace)
{
KDEFINE_CLASS defKonohaFactory = {0};
SETSTRUCTNAME(defKonohaFactory, KonohaFactory);
defKonohaFactory.init = kKonohaFactory_Init;
defKonohaFactory.free = kKonohaFactory_Free;
KDEFINE_CLASS defKonoha = {0};
SETSTRUCTNAME(defKonoha, Konoha);
defKonoha.init = kKonoha_Init;
defKonoha.free = kKonoha_Free;
KClass *cKonohaFactory = KLIB KClass_define(kctx, ns->packageId, NULL, &defKonohaFactory, trace);
KClass *cKonoha = KLIB KClass_define(kctx, ns->packageId, NULL, &defKonoha, trace);
int KType_KonohaFactory = cKonohaFactory->typeId, KType_Konoha = cKonoha->typeId;
KDEFINE_METHOD MethodData[] = {
kMethod_Public, _F(KonohaFactory_new), KType_KonohaFactory, KType_KonohaFactory, KMethodName_("new"), 0,
kMethod_Public, _F(KonohaFactory_loadModule), KType_Boolean, KType_KonohaFactory, KMethodName_("loadModule"), 1, KType_String, KFieldName_("name"),
kMethod_Public, _F(KonohaFactory_create), KType_Konoha, KType_KonohaFactory, KMethodName_("create"), 0,
kMethod_Public, _F(Konoha_loadScript), KType_Boolean, KType_Konoha, KMethodName_("loadScript"), 1, KType_String, KFieldName_("filename"),
kMethod_Public, _F(Konoha_eval), KType_Konoha, KType_Konoha, KMethodName_("eval"), 1, KType_String, KFieldName_("script"),
DEND,
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
return true;
}
PhysicsTest* RenderTestSelector(const GLFontRenderer& texter, float x, float text_scale, int start_index, float& y_last)
{
int NbTests = GetNbTests();
const int NbToGo = ICE_ARRAYSIZE(Alpha);
float y = float(NbToGo) * text_scale;
const float XOffset = 0.01f;
// DrawRectangle(XOffset, 1.0f-XOffset, y + text_scale*2.0f, y - text_scale*9.0f, Point(1.0f, 0.5f, 0.2f), 0.5f);
PhysicsTest* CandidateTest = null;
for(int i=0;i<NbToGo;i++)
{
const float a = Alpha[i];
const bool Selected = a==1.0f;
if(Selected)
texter.setColor(1.0f, 0.5f, 0.2f, a);
else
texter.setColor(1.0f, 1.0f, 1.0f, a);
const int RealIndex = start_index % NbTests;
PhysicsTest* Test = GetTest(RealIndex);
if(Test)
{
static const char* CategoryText[] =
{
"(undefined)",
"(API)",
"(behavior)",
"(contact generation)",
"(performance)",
"(raycast)",
"(sweep)",
"(overlap)",
"(CCD)",
"(static scene)",
};
const TestCategory TC = Test->GetCategory();
if(Test->IsPrivate())
{
texter.print(x+XOffset, y, text_scale, _F("%d: %s - %s (PRIVATE)", RealIndex, CategoryText[TC], Test->GetName()));
}
else
{
texter.print(x+XOffset, y, text_scale, _F("%d: %s - %s", RealIndex, CategoryText[TC], Test->GetName()));
}
}
if(Selected)
CandidateTest = Test;
y -= text_scale;
start_index++;
}
y_last = y;
return CandidateTest;
}
void ProcessRepXFile_RemoveDynamics(const char* filename)
{
ASSERT(filename);
if(!_ProcessRepXFile_RemoveDynamics(_F("../build/%s", filename)))
if(!_ProcessRepXFile_RemoveDynamics(_F("./%s", filename)))
printf(_F("Failed to load '%s'\n", filename));
}
static void class_defineMethod(KonohaContext *kctx, kNameSpace *ns, KTraceInfo *trace)
{
KDEFINE_METHOD MethodData[] = {
_Public|_Const|_Ignored, _F(NameSpace_AllowImplicitField), KType_void, KType_NameSpace, KMethodName_("AllowImplicitField"), 1, KType_Boolean, KFieldName_("allow"),
_Public|_Const, _F(NameSpace_AddMethodDecl), KType_void, KType_NameSpace, KMethodName_("AddMethodDecl"), 1, KType_Node, KFieldName_("node"),
DEND,
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
}
static void Syntax_defineMessageMethod(KonohaContext *kctx, kNameSpace *ns, KTraceInfo *trace)
{
KDEFINE_METHOD MethodData[] = {
_Public, _F(Node_Message), KType_Node, KType_Node, KMethodName_("Message"), 2, TP_level, TP_message,
_Public, _F(NodeToken_Message), KType_Node, KType_Node, KMethodName_("Message"), 3, TP_level, TP_token, TP_message,
DEND,
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
}
BOOL Font::Load(const char *filename, ResourceManager *res, IMemoryPool *pool)
{
ASSERT_NULL(filename);
ASSERT_NULL(res);
ASSERT_NULL(pool);
if (this->Unload())
{
this->pFilename = filename;
this->pRes = res;
this->pPool = pool;
stFile.Close();
SECURITY_CHECK(pFileSystem->Open(filename, &stFile, pool), "Could not open font file.");
const u8 *ptr = static_cast<const u8 *>(stFile.GetData());
ObjectHeader *block = NULL;
READ_STRUCT(block, ObjectHeader, ptr);
SECURITY_CHECK(seed_validate_block(&stFile, block, FONT_OBJECT_MAGIC, FONT_OBJECT_VERSION), "Invalid block header for font.");
READ_F32(this->fTracking, ptr);
READ_F32(this->fSpacing, ptr);
READ_F32(this->fSpaceWidth, ptr);
/*
const char *file = NULL;
READ_STR(file, ptr);
ASSERT_NULL(file);
const char *ext = NULL;
READ_STR(ext, ptr);
*/
u32 file = 0;
READ_U32(file, ptr);
u32 ext = 0;
READ_U32(ext, ptr);
if (ext != SEED_INVALID_ID /*&& pSystem->GetLanguage() != Seed::en_US*/)
{
File extf;
if (pFileSystem->Open(_F(ext), &extf, pool))
{
extf.Close();
this->mFontExt.Load(_F(ext), res, pool);
this->pGlyphs = pDictionary->GetGlyphTable(&this->iTotalGlyphs);
}
}
this->mFont.Load(_F(file), res, pool);
this->fHeight = mFont.GetHeight();
this->fWidth = mFont.GetWidth();
this->bLoaded = TRUE;
}
return bLoaded;
}
static void sugar_defineTokenFunc(KonohaContext *kctx, kNameSpace *ns, int TY_Symbol, KTraceInfo *trace)
{
KDEFINE_METHOD MethodData[] = {
_Public, _F(String_AsciiAt), TY_int, TY_String, MN_("AsciiAt"), 1, TP_pos,
_Public, _F(Token_Parse), TY_int, TY_Token, MN_("parse"), 4, TP_kw, TP_source, TP_begin, TP_end,
_Public, _F(Token_error), TY_int, TY_Token, MN_("error"), 4, TP_message, TP_source, TP_begin, TP_end,
DEND,
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
}
static void sugar_defineMessageMethod(KonohaContext *kctx, kNameSpace *ns, int TY_Symbol, KTraceInfo *trace)
{
KDEFINE_METHOD MethodData[] = {
_Public, _F(Stmt_Message), TY_Expr, TY_Stmt, MN_("message"), 2, TP_level, TP_message,
_Public, _F(StmtToken_Message), TY_Expr, TY_Stmt, MN_("message"), 3, TP_level, TP_token, TP_message,
_Public, _F(StmtExpr_Message), TY_Expr, TY_Stmt, MN_("message"), 3, TP_level, TP_expr, TP_message,
DEND,
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
}
static void object_defineMethod(KonohaContext *kctx, kNameSpace *ns, KTraceInfo *trace)
{
KDEFINE_METHOD MethodData[] = {
_Public|_Im|_Const|_Final, _F(Object_getTypeId), TY_int, TY_Object, MN_("getTypeId"), 0,
_Public|_Hidden|_Im|_Const, _F(Object_instanceOf), TY_boolean, TY_Object, MN_("<:"), 1, TY_Object, FN_("type"),
_Public|_Hidden|_Im|_Const|kMethod_SmartReturn, _F(Object_as), TY_Object, TY_Object, MN_("as"), 0,
DEND,
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
}
static void namespace_defineMethod(KonohaContext *kctx, kNameSpace *ns, KTraceInfo *trace)
{
KDEFINE_METHOD MethodData[] = {
_Public|_Const|_Im, _F(NameSpace_GetNameSpace), KType_NameSpace, KType_NameSpace, KMethodName_("GetNameSpace"), 0,
_Public|_Const|_Im, _F(NameSpace_GetParentNameSpace), KType_NameSpace, KType_NameSpace, KMethodName_("GetParentNameSpace"), 0,
_Public, _F(NameSpace_DefineMacro2), KType_Boolean, KType_NameSpace, KMethodName_("DefineMacro"), 2, TP_name, TP_source,
_Public, _F(NameSpace_DefineMacro), KType_Boolean, KType_NameSpace, KMethodName_("DefineMacro"), 3, TP_name, TP_paramsize, TP_source,
DEND,
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
}
static void prototype_defineMethod(KonohaContext *kctx, kNameSpace *ns, KTraceInfo *trace)
{
int FN_key = KFieldName_("key"), FN_value = KFieldName_("value");
KDEFINE_METHOD MethodData[] = {
_Public|_Im|_Const|kMethod_SmartReturn|_Final, _F(Prototype_get), KType_Object, KType_Prototype, KMethodName_("get"), 1, KType_Symbol, FN_key,
_Public|_Final, _F(Prototype_SetObject), KType_void, KType_Prototype, KMethodName_("set"), 2, KType_Symbol, FN_key, KType_Object, FN_value,
_Public|_Final, _F(Prototype_SetInt), KType_void, KType_Prototype, KMethodName_("set"), 2, KType_Symbol, FN_key, KType_Int, FN_value,
DEND,
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
}
void ToolPageLayer::setLayerCount(int layer, int selected)
{
XOJ_CHECK_TYPE(ToolPageLayer);
this->inCbUpdate = true;
int count = gtk_tree_model_iter_n_children(gtk_combo_box_get_model(GTK_COMBO_BOX(this->layerComboBox)), NULL);
for (int i = count - 1; i >= 0; i--)
{
gtk_combo_box_remove_text(GTK_COMBO_BOX(this->layerComboBox), i);
}
gtk_combo_box_append_text(GTK_COMBO_BOX(this->layerComboBox), _C("Background"));
for (int i = 1; i <= layer; i++)
{
string text = FS(_F("Layer {1}") % i);
gtk_combo_box_prepend_text(GTK_COMBO_BOX(this->layerComboBox), text.c_str());
}
setSelectedLayer(selected);
this->layerCount = layer;
this->inCbUpdate = false;
}
std::string U2L(const std::string& string)
{
std::string locale_charset;
if(!Glib::get_charset(locale_charset))
{
try
{
return Glib::convert_with_fallback(string, locale_charset, MLIB_UTF_CHARSET_NAME);
}
catch(Glib::ConvertError&)
{
std::string broken_string;
for(size_t i = 0; i < string.size(); i++)
{
if(::isprint(string[i]))
broken_string += string[i];
else
broken_string += "%" + _F(std::hex, std::uppercase, (int) (unsigned char) string[i]);
}
return broken_string + " " + _("[[Invalid encoding]]");
}
}
else
return string;
}
void Get_feed_list::process_current_state(void)
{
MLIB_D("Getting Google Reader's %1 list...", this->state_list_name());
#if GROV_OFFLINE_DEVELOPMENT
QFile list(this->state_list_name() + ".list");
if(list.open(QIODevice::ReadOnly))
this->request_finished(NULL, "", list.readAll());
else
this->request_finished(NULL, _F("Error while reading '%1'.", list.fileName()), "");
#else
QString url;
switch(this->state)
{
case STATE_GETTING_TAG_LIST:
case STATE_GETTING_STREAM_PREFERENCE_LIST:
case STATE_GETTING_SUBSCRIPTION_LIST:
url = "https://www.google.com/reader/api/0/" + this->state_list_name() + "/list";
break;
default:
this->failed(tr("Logical error."));
return;
break;
}
this->get( url + "?output=xml&client=" + QUrl::toPercentEncoding(get_user_agent()) );
#endif
}
double model::deltaF(const char METHOD, const char FUNCTION, const double XK_1, const double XK, double EPS){
double ans;
switch(METHOD){
case 'n':
{
double denominator = _F(FUNCTION, XK);
if(fabs(denominator) <= EPS)
ans = 0.00001;
else
ans = F(FUNCTION, XK) / denominator;
break;
}
case 's':
{
double denominator = F(FUNCTION, XK) - F(FUNCTION, XK_1);
if(fabs(denominator) <= EPS)
ans = 0.00001;
else
ans = ( (XK - XK_1) * F(FUNCTION, XK) ) / denominator;
break;
}
}
return ans;
}
static bool begin_rule(const String & rulename, bool incremental, void *userContext)
{
AbnfContext *ctx = __CAST_USER_CTX(userContext);
if (incremental) {
AbnfRulesHash::iterator it = ctx->rules.find(rulename);
if (it == ctx->rules.end()) { // rule for incremental alternative not initialized before
Logger::error(_Fr("%s: rule for incremental alternative not initialized before") % rulename);
return false;
}
ctx->nodestack.push(it.value());
AbnfNode *alt = it.value()->m_nodes.first();
CWT_ASSERT(alt);
ctx->nodestack.push(alt);
ctx->isIncrementalAlternation = true;
} else {
AbnfNodeRule *rule = new AbnfNodeRule(rulename);
ctx->rules.insert(rulename, rule);
ctx->nodestack.push(rule);
AbnfRulesDefsHash::iterator it = ctx->rulesdefs.find(rulename);
if (it != ctx->rulesdefs.end()) {
it.value() = true;
} else {
ctx->rulesdefs.insert(rulename, false);
}
}
std::cout << String(_F("RN{%s}%s") % rulename % (incremental ? "=/" : "="));
return true;
}
void BaseTextureLoader::into(Loadable& resource, const LoaderOptions& options) {
Loadable* res_ptr = &resource;
Texture* tex = dynamic_cast<Texture*>(res_ptr);
assert(tex && "You passed a Resource that is not a texture to the texture loader");
std::vector<unsigned char> buffer(
(std::istreambuf_iterator<char>(*this->data_)),
std::istreambuf_iterator<char>()
);
auto result = do_load(buffer);
/* Respect the auto_upload option if it exists*/
bool auto_upload = true;
if(options.count("auto_upload")) {
auto_upload = smlt::any_cast<bool>(options.at("auto_upload"));
}
if (result.data.empty()) {
L_ERROR(_F("Unable to load texture with name: {0}").format(filename_));
throw std::runtime_error("Couldn't load the file: " + filename_.encode());
} else {
tex->set_source(filename_);
tex->set_format(result.format, result.texel_type);
tex->resize(result.width, result.height);
tex->data().assign(result.data.begin(), result.data.end());
tex->set_auto_upload(auto_upload);
if(format_stored_upside_down()) {
tex->flip_vertically();
}
}
}
void WINAPI GetOpenPanelInfoW(struct OpenPanelInfo *Info)
{
if(!Info->hPanel || INVALID_HANDLE_VALUE == Info->hPanel)
return;
fardroid * android = (fardroid *)Info->hPanel;
Info->StructSize=sizeof(*Info);
Info->Flags = OPIF_ADDDOTS | OPIF_SHOWPRESERVECASE;
Info->StartSortMode = (OPENPANELINFO_SORTMODES) conf.SortMode;
Info->StartSortOrder = conf.SortOrder;
Info->CurDir = NULL;
Info->Format= GetMsg(MTitle);
android->PreparePanel(Info);
Info->DescrFiles=NULL;
Info->DescrFilesNumber=0;
Info->StartPanelMode = _F('0')+conf.PanelMode;
Info->PanelModesArray=NULL;
Info->PanelModesNumber=0;
Info->KeyBar=&KeyBar;
}
static bool begin_repetition(int from, int to, void * userContext)
{
std::cout << String(_F("{%d*%d") % from % to);
AbnfContext *ctx = __CAST_USER_CTX(userContext);
ctx->nodestack.push(new AbnfNodeRpt(from, to));
return true;
}
inline double Normalize(int N, _F *X, int INCX) {
double norm = TwoNorm<double>(N,X,INCX);
Scale(N,_F(1.)/norm,X,INCX);
return norm;
}
static bool prose_val(const String & prose, void * userContext)
{
std::cout << String(_F("PV{%s}") % prose);
AbnfContext *ctx = __CAST_USER_CTX(userContext);
CWT_ASSERT(ctx->nodestack.size() > 0);
ctx->nodestack.top()->addNode(new AbnfNodeProseVal(prose));
return true;
}
static void class_defineMethod(KonohaContext *kctx, kNameSpace *ns, KTraceInfo *trace)
{
KDEFINE_METHOD MethodData[] = {
_Public|_Const|_Ignored, _F(NameSpace_AllowImplicitField), TY_void, TY_NameSpace, MN_("AllowImplicitField"), 1, TY_boolean, FN_("allow"),
DEND,
};
KLIB kNameSpace_LoadMethodData(kctx, ns, MethodData, trace);
}
bool Web_page::shouldInterruptJavaScript(void)
{
MLIB_SW(_F(
tr("A JavaScript program at '%1' is running for a long period of time. Interrupting it."),
this->mainFrame()->url().toString()
));
return true;
}
static bool num_val(const String & num, void * userContext)
{
std::cout << String(_F("NV{%s}") % num);
AbnfContext *ctx = __CAST_USER_CTX(userContext);
CWT_ASSERT(ctx->nodestack.size() > 0);
ctx->nodestack.top()->addNode(new AbnfNodeNumVal(num));
return true;
}
