MError MMysqlCommand::DoGetParam(std::string *p_param)
{
if (cur_col_ >= out_params_.size())
{
MLOG(MGetLibLogger(), MERR, "record have no more data");
return MError::NoData;
}
const MYSQL_BIND &bind = out_params_[cur_col_++];
if (!p_param)
{
return MError::No;
}
if (*(bind.is_null)
|| bind.buffer_type == MYSQL_TYPE_NULL)
{
*p_param = "";
return MError::No;
}
if (bind.buffer_type == MYSQL_TYPE_TINY_BLOB
|| bind.buffer_type == MYSQL_TYPE_MEDIUM_BLOB
|| bind.buffer_type == MYSQL_TYPE_LONG_BLOB
|| bind.buffer_type == MYSQL_TYPE_BLOB
|| bind.buffer_type == MYSQL_TYPE_STRING
|| bind.buffer_type == MYSQL_TYPE_VAR_STRING)
{
p_param->resize(*(bind.length));
memcpy(&((*p_param)[0]), bind.buffer, p_param->size());
return MError::No;
}
MLOG(MGetLibLogger(), MERR, "can't convert type:", bind.buffer_type, " to string");
return MError::ConvertFailed;
}
MError MMysqlCommand::DoGetParam(MBlob *p_param)
{
if (cur_col_ >= out_params_.size())
{
MLOG(MGetLibLogger(), MERR, "have no more data :", cur_col_+1);
return MError::NoData;
}
const MYSQL_BIND &bind = out_params_[cur_col_++];
if (!p_param)
{
return MError::No;
}
if (*(bind.is_null)
|| bind.buffer_type == MYSQL_TYPE_NULL)
{
p_param->Resize(0);
return MError::No;
}
if (bind.buffer_type == MYSQL_TYPE_TINY_BLOB
|| bind.buffer_type == MYSQL_TYPE_MEDIUM_BLOB
|| bind.buffer_type == MYSQL_TYPE_LONG_BLOB
|| bind.buffer_type == MYSQL_TYPE_BLOB
|| bind.buffer_type == MYSQL_TYPE_STRING
|| bind.buffer_type == MYSQL_TYPE_VAR_STRING)
{
p_param->Resize(*(bind.length));
memcpy(p_param->GetData(), bind.buffer, p_param->GetSize());
return MError::No;
}
MLOG(MGetLibLogger(), MERR, "can't convert type:", bind.buffer_type, " to MBlob");
return MError::ConvertFailed;
}
static void drawingPumpUpdate(FskWindow win)
{
FskTimeRecord delta, now;
FskTimeGetNow(&now);
gKplScreen->unlocked = false;
FskTimeCopy(&delta, &now);
FskTimeSub(&gKplScreen->lastUpdateTime, &delta);
FskTimeCopy(&gKplScreen->lastUpdateTime, &now);
MLOG("[%s] called %d ms after last update\n", threadName, FskTimeInMS(&delta));
// estimate next flip time by adding vSync interval to previous flip time
FskTimeCopy(&gKplScreen->nextFlipTime, &gKplScreen->lastFlipTime);
FskTimeAdd(&gKplScreen->vSyncIntervalTime, &gKplScreen->nextFlipTime);
while (FskTimeCompare(&gKplScreen->nextFlipTime, &now) > 0)
FskTimeAdd(&gKplScreen->vSyncIntervalTime, &gKplScreen->nextFlipTime);
MLOG("Next flip time %ld.%06ld \n", gKplScreen->nextFlipTime.seconds, gKplScreen->nextFlipTime.useconds);
FskWindowCheckEventQueue(win);
FskWindowUpdate(win, &gKplScreen->nextFlipTime);
if (!gKplScreen->unlocked)
FskSemaphoreRelease(gKplScreen->flipSemaphore);
MLOG("[%s] Finished callback %ld, nextFlipTime %1d.%03d\n", threadName, gKplScreen->callbackFiredCount, gKplScreen->nextFlipTime.seconds, gKplScreen->nextFlipTime.useconds / 1000);
}
MError MMysqlCommand::BindResult()
{
if (mysql_stmt_store_result(p_stmt_) != 0)
{
MLOG(MGetLibLogger(), MERR, "store result failed errno:", mysql_stmt_errno(p_stmt_), " error:", mysql_stmt_error(p_stmt_));
return MError::Unknown;
}
MYSQL_RES *p_meta_res = mysql_stmt_result_metadata(p_stmt_);
if (!p_meta_res)
{
MLOG(MGetLibLogger(), MERR, "have not meta res errno:", mysql_stmt_errno(p_stmt_), " error:", mysql_stmt_error(p_stmt_));
return MError::Unknown;
}
MError err = MError::No;
do
{
MYSQL_FIELD *p_field_list = mysql_fetch_fields(p_meta_res);
if (!p_field_list)
{
MLOG(MGetLibLogger(), MERR, "mysql_fetch_fields is null unknown error");
err = MError::Unknown;
break;
}
unsigned long field_count = mysql_num_fields(p_meta_res);
if (field_count == 0)
{
MLOG(MGetLibLogger(), MERR, "mysql field_count is 0");
err = MError::Unknown;
break;
}
out_params_.resize(field_count);
out_datas_.resize(field_count);
out_lengths_.resize(field_count);
out_is_nulls_.resize(field_count);
for (size_t i = 0; i < field_count; ++i)
{
MBlob &out_data = out_datas_[i];
out_data.Resize(p_field_list[i].max_length);
memset(&(out_params_[i]), 0, sizeof(out_params_[i]));
out_params_[i].buffer_type = p_field_list[i].type;
out_params_[i].buffer = out_data.GetData();
out_params_[i].buffer_length = out_data.GetSize();
out_params_[i].length = &(out_lengths_[i]);
out_params_[i].is_null = &(out_is_nulls_[i]);
out_params_[i].is_unsigned = (p_field_list[i].flags & UNSIGNED_FLAG);
out_params_[i].error = nullptr;
}
if (mysql_stmt_bind_result(p_stmt_, &out_params_[0]) != 0)
{
MLOG(MGetLibLogger(), MERR, "bind result failed errno:", mysql_stmt_errno(p_stmt_), " error:", mysql_stmt_error(p_stmt_));
err = MError::Unknown;
break;
}
err = MError::No;
} while (0);
mysql_free_result(p_meta_res);
return err;
}
void Polynomial::Print()
{
for (auto node = data_.First(); node != nullptr; node = node->Next())
{
MLOG("%d^%d", node->Get()->coefficient, node->Get()->exponent);
if (node->Next())
{
MLOG(" + ");
}
}
MLOG("\n");
}
bool os_GaussianFeH::construct(const Config &cfg, otable &t, opipeline &pipe)
{
read_component_map(applyToComponents, cfg);
mean = cfg.get("mean");
sigma = cfg.get("sigma");
// Output model parameters
MLOG(verb1) << "Metallicity: Gaussian for components " << applyToComponents << " ## " << instanceName();
MLOG(verb2) << " : (mu, sigma) = " << mean << ", " << sigma;
return true;
}
void TestFunction()
{
char puzzle_board_data[] =
{
't', 'h', 'i', 's',
'w', 'a', 't', 's',
'o', 'a', 'h', 'g',
'f', 'g', 'd', 't'
};
char* dictionary[] =
{
"this", "two", "fat", "that"
};
Array words, ret;
int i;
size_t index, count;
PuzzleBoard puzzle_board = { puzzle_board_data, 4, 4 };
ArrayInit(&words, 4, sizeof(char*));
for (i = 0; i < 4; ++i)
{
ArrayPush(&words, &dictionary[i]);
}
// solution1
ret = solution1_Function(&puzzle_board, &words);
count = ArrayUsed(&ret);
MLOG("solution 1:\n");
for (index = 0; index < count; ++index)
{
RetWord* word = (RetWord*)ArrayGet(&ret, index);
MLOG("%s (%d, %d) - (%d, %d)\n", word->word, word->start_x, word->start_y, word->end_x, word->end_y);
}
ArrayDestroy(&ret);
// solution2
ret = solution2_Function(&puzzle_board, &words);
count = ArrayUsed(&ret);
MLOG("solution 2:\n");
for (index = 0; index < count; ++index)
{
RetWord* word = (RetWord*)ArrayGet(&ret, index);
MLOG("%s (%d, %d) - (%d, %d)\n", word->word, word->start_x, word->start_y, word->end_x, word->end_y);
}
ArrayDestroy(&ret);
ArrayDestroy(&words);
}
void powerLawEllipsoid::load(host_state_t &hstate, const peyton::system::Config &cfg)
{
// turn off density truncation
rminSq = rmaxSq = 0.f;
load_geometry(hstate, cfg);
// radial functional dependence
cfg.get(n, "n", -3.f); // power law index
// component ID
int userComp = cfg.get("comp");
comp = componentMap.seqIdx(userComp);
// Load luminosity function
std::string lffile;
hstate.lf = load_lf(*this, cfg, lffile);
// limits (\rho = 0 for d < rminSq || d > rmaxSq)
// NOTE: This is intentionally after LF normalization computation, so
// that normalizing to the values of the profile in the regions
// excluded by this cut would still be possible.
cfg.get(rminSq, "rmin", 0.f); rminSq *= rminSq;
cfg.get(rmaxSq, "rmax", 0.f); rmaxSq *= rmaxSq;
if(lffile.empty()) { lffile = "-"; }
MLOG(verb1) << "Component " << userComp << " : " << "power law ellipsoid {" << n << ", " << ca << ", " << ba << ", " << lffile << "}";
}
void ScopeTimeManager::Print()
{
for (auto it = record_.begin(); it != record_.end(); ++it)
{
MLOG("%s\n", it->c_str());
}
}
CString CInfoChannel::MakeUsrLvFile(LPTSTR sExtTitle)
{
CSettings::Item* pItem = Settings.GetSetting( _T(".PathUsr") );
CString xVbDirect = *pItem->m_pString;
CHAR* pptr;
CHAR* sptr = PageNumber;
int nLength = GetNextBuffer( sptr, pptr );
CHAR szFdTel[MAX_PHONE + 1];
nLength = min( nLength, MAX_PHONE );
CopyMemory( szFdTel, sptr, nLength ); szFdTel[nLength] = '\0';
if ( (nLength = _tcslen(szFdTel)) > 4 )
{
xVbDirect += '\\';
for ( int i = 0; i < 4; i++ ) xVbDirect += szFdTel[i];
CreateDirectory( xVbDirect, NULL );
}
CString xUsrFile;
SYSTEMTIME pTime;
GetLocalTime( &pTime );
xUsrFile.Format( "%s\\%04i%02i%02i%02i%02i%02i%03i.%s",
xVbDirect, pTime.wYear, pTime.wMonth, pTime.wDay,
pTime.wHour, pTime.wMinute, pTime.wSecond, pTime.wMilliseconds,
sExtTitle );
MLOG( xUsrFile );
return xUsrFile;
}
bool Simple_Shader::crearFS(std::string codigo)
{
_fsID = glCreateShader(GL_FRAGMENT_SHADER);
const char* cod =codigo.c_str();
glShaderSource(_fsID,1,&cod,NULL);
glCompileShader(_fsID);
GLint exito;
GLchar log[512];
glGetShaderiv(_fsID,GL_COMPILE_STATUS,&exito);
if(!exito)
{
MERROR("ERROR COMPILANDO FRAGMENT SHADER");
MERROR("No se pudo compilar:");
MERROR(cod);
MERROR("\nError:");
MERROR(log);
return false;
}
else
{
MLOG("Fragment shader cargado correctamente");
return true;
}
}
void flipThread(void *refcon)
{
KplScreen screen = refcon;
FskThread mainThread = FskThreadGetMain();
FskTimeRecord later;
SInt32 ms;
FskThreadInitializationComplete(FskThreadGetCurrent());
while (!gQuitting) {
//Save the last Flip time
FskTimeGetNow(&gKplScreen->lastFlipTime);
FskTimeCopy(&later, &gKplScreen->nextFlipTime);
FskTimeSub(&gKplScreen->lastFlipTime, &later);
ms = FskTimeInMS(&later);
if (ms > 0) {
FskDelay(ms);
MLOG("[%s] delay %d ms\n", threadName, ms);
}
// Kick off the next cycle
if (gKplScreen->drawingPumpEnabled) {
FskSemaphoreAcquire(screen->flipSemaphore);
gKplScreen->callbackPostedCount++;
FskThreadPostCallback(mainThread, drawingPumpCallback, (void*)gKplScreen->callbackPostedCount, NULL, NULL, NULL);
}
}
}
void Renderer_OpenGL::Destroy()
{
MLOG("## Destroy OpenGL\n");
#if MG_PLATFORM_WINDOWS
Destroy_Windows();
#endif
}
MError MMysqlConnection::DoCheckAndReconnect()
{
if (mysql_ping(p_mysql_) != 0)
{
MLOG(MGetLibLogger(), MERR, "reconnect failed errno:", mysql_errno(p_mysql_), " error:", mysql_error(p_mysql_));
return MError::Disconnect;
}
return MError::No;
}
MError MMysqlCommand::DoGotoNextResult()
{
int ret = mysql_stmt_next_result(p_stmt_);
if (ret == 0)
{
return BindResult();
}
else if (ret < 0)
{
MLOG(MGetLibLogger(), MWARN, "next result ret is ", ret);
return MError::Unknown;
}
else
{
MLOG(MGetLibLogger(), MWARN, "next result errno:", mysql_stmt_errno(p_stmt_), " error:", mysql_stmt_error(p_stmt_));
return MError::Unknown;
}
}
GL_Contexto::GL_Contexto(int ancho,int alto,std::string titulo)
{
_titulo=titulo;
_ancho=ancho;
_alto=alto;
_colorFondo=Color(COLOR_Purple);
MLOG("Ventana creada :: "<<_titulo<<" "<<_ancho<<"x"<<_alto<<" Color: "<<_colorFondo.aCharArray());
}
bool GL_Contexto::iniciar()
{
glfwInit();
#if 0
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_ANY_PROFILE);
glfwWindowHint(GLFW_RESIZABLE, GL_TRUE);
glfwWindowHint(GLFW_REFRESH_RATE,GLFW_DONT_CARE);
#endif
_ventana = glfwCreateWindow(_ancho, _alto,_titulo.c_str() , NULL,
NULL);
if (_ventana == NULL)
{
MERROR("No se pudo crear la ventana GLFW");
glfwTerminate();
return false;
}
glfwMakeContextCurrent(_ventana);
glewExperimental=GL_TRUE;
if (glewInit() != GLEW_OK)
{
MERROR("No se pudo iniciar GLEW");
glfwTerminate();
return false;
}
/*glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);*/
MLOG(glGetString(GL_VENDOR));
MLOG(glGetString(GL_VERSION));
GLint numext;
glGetIntegerv(GL_NUM_EXTENSIONS,&numext);
#if LOG_EXT
for(int i=0;i<numext;i++)
MLOG(glGetStringi(GL_EXTENSIONS,i));
#endif
return true;;
}
MError MMysqlCommand::DoGotoNextRecord()
{
int ret = mysql_stmt_fetch(p_stmt_);
if (ret == 0)
{
cur_col_ = 0;
return MError::No;
}
else if (ret == MYSQL_NO_DATA)
{
MLOG(MGetLibLogger(), MINFO, "have no more data");
return MError::NoData;
}
else
{
MLOG(MGetLibLogger(), MINFO, "next record errno:", mysql_stmt_errno(p_stmt_), " error:", mysql_stmt_error(p_stmt_));
return MError::Unknown;
}
}
MError MMysqlConnection::DoSelectDb(const std::string &db)
{
int ret = mysql_select_db(p_mysql_, db.c_str());
if (ret != 0)
{
MLOG(MGetLibLogger(), MERR, "select db failed error:", ret);
return MError::Unknown;
}
return MError::No;
}
MError MMysqlCommand::DoPrepair(const std::string &command)
{
if (p_stmt_)
{
mysql_stmt_close(p_stmt_);
p_stmt_ = nullptr;
}
p_stmt_ = mysql_stmt_init(conn_.GetConnection());
if (!p_stmt_)
{
MLOG(MGetLibLogger(), MERR, "init stmt failed errno:", mysql_errno(conn_.GetConnection()), " error:", mysql_error(conn_.GetConnection()));
return MError::Unknown;
}
if (mysql_stmt_prepare(p_stmt_, command.c_str(), command.size()) != 0)
{
MLOG(MGetLibLogger(), MERR, "mysql prepare:", command, " failed errno:", mysql_stmt_errno(p_stmt_), " error:", mysql_stmt_error(p_stmt_));
return MError::Unknown;
}
return MError::No;
}
FskErr KplScreenSetContinuousDrawing(void *state, void *obj, UInt32 propertyID, FskMediaPropertyValue property)
{
Boolean on = property->value.b;
if (on) {
if (!gKplScreen->drawingPumpEnabled) {
gKplScreen->drawingPumpEnabled = true;
MLOG("[%s] ** Pi START drawing pump **\n", threadName);
FskThreadPostCallback(FskThreadGetMain(), drawingPumpCallback, (void*)gKplScreen->callbackPostedCount, NULL, NULL, NULL);
}
}
else {
if (gKplScreen->drawingPumpEnabled) {
gKplScreen->drawingPumpEnabled = false;
MLOG("[%s] ** Pi STOP drawing pump **\n", threadName);
}
}
return kFskErrNone;
}
FskErr KplScreenSetUpdateInterval(void *state, void *obj, UInt32 propertyID, FskMediaPropertyValue property)
{
UInt32 i, updateRate;
// We set the actual interval based on the vsync interval
updateRate = (UInt32)floor(((double)property->value.integer / gKplScreen->vSyncInterval + 0.5));
if (!updateRate) updateRate = 1;
gKplScreen->updateInterval = updateRate * gKplScreen->vSyncInterval;
MLOG("Setting update interval to %ld ms", gKplScreen->updateInterval);
FskTimeClear(&gKplScreen->updateIntervalTime);
for (i = 0; i < updateRate; ++i)
FskTimeAdd(&gKplScreen->vSyncIntervalTime, &gKplScreen->updateIntervalTime);
MLOG("Setting update interval time to %ld.%06lds", gKplScreen->updateIntervalTime.seconds, gKplScreen->updateIntervalTime.useconds);
return kFskErrNone;
}
void expDisk::load(host_state_t &hstate, const peyton::system::Config &cfg)
{
// density distribution parameters
l = cfg.get("l");
h = cfg.get("h");
assert(l > 0);
assert(h > 0);
#if 0
float z0 = cfg.get("z0"); // Solar offset from the Galactic plane
Rg = cfg.get("Rg"); // Distance to the Galactic center (assumed to be in l=0, b=0 direction)
// compute the rotation of the Galactic plane, and cylindrical
// coordinates of the Sun
zsun = z0;
rsun = sqrt(double(Rg*Rg) - double(z0*z0));
asin = zsun / Rg;
acos = rsun / Rg;
#else
std::string ctr, orient;
cfg.get(ctr, "center", "galplane");
cfg.get(orient, "orientation", "galplane");
load_transform(&T.x, M, ctr, orient, cfg);
#if 0
std::cout << "translation = " << std::setprecision(10) << T.x << " " << T.y << " " << T.z << "\n";
print_matrix(M);
// Do some testing here...
float3 v = { 0.f, 0.f, 0.f };
v = transform(v, T, M);
std::cout << std::setprecision(10) << v.x << " " << v.y << " " << v.z << "\n";
abort();
#endif
#endif
int userComp = cfg.get("comp");
comp = componentMap.seqIdx(userComp);
// set this to 0. for now, to allow LF normalization
// even beyond the user-specified model cutoff
r_cut2 = 0.f;
// Load luminosity function
std::string lffile;
hstate.lf = load_lf(*this, cfg, lffile);
// cutoff radius (default: no cutoff)
cfg.get(r_cut2, "rcut", 0.f);
r_cut2 *= r_cut2;
if(lffile.empty()) { lffile = "-"; }
MLOG(verb1) << "Component " << userComp << " : " << "exponential disk {" << l << ", " << h << ", " << lffile << "}";
}
std::pair<unsigned, MError> MMysqlCommand::DoExecuteNonQuery()
{
int param_count = mysql_stmt_param_count(p_stmt_);
if (static_cast<size_t>(param_count) != in_params_.size())
{
MLOG(MGetLibLogger(), MERR, "param count is not match need:", param_count, " actual is:", in_params_.size());
return std::pair<unsigned, MError>(0, MError::NotMatch);
}
if (mysql_stmt_bind_param(p_stmt_, &in_params_[0]) != 0)
{
MLOG(MGetLibLogger(), MERR, "bind failed errno:", mysql_stmt_errno(p_stmt_), " error:", mysql_stmt_error(p_stmt_));
return std::pair<unsigned, MError>(0, MError::Unknown);
}
if (mysql_stmt_execute(p_stmt_) != 0)
{
MLOG(MGetLibLogger(), MERR, "execute failed errorno:", mysql_stmt_errno(p_stmt_), " error:", mysql_stmt_error(p_stmt_));
return std::pair<unsigned, MError>(0, MError::Unknown);
}
unsigned affect = mysql_stmt_affected_rows(p_stmt_);
return std::make_pair(affect, MError::No);
}
bool os_gal2other::construct(const Config &cfg, otable &t, opipeline &pipe)
{
//if(!cfg.count("FeH")) { THROW(EAny, "Keyword 'filename' must exist in config file"); }
std::string cs, msg;
cfg.get(cs, "coordsys", "gal");
if(cs == "gal") { coordsys = GAL; /* -- noop -- */; msg = "Galactic coordinates in column lb"; }
else if(cs == "equ") { coordsys = EQU; prov.insert("radec[2]"); msg = "Equatorial coordinates in column radec"; }
else { THROW(EAny, "Unknown coordinate system (" + cs + ") requested."); }
MLOG(verb1) << "Astrometry: " << msg << " ## " << instanceName();
return true;
}
MError MMysqlCommand::DoExecuteReader()
{
int param_count = mysql_stmt_param_count(p_stmt_);
if (static_cast<size_t>(param_count) != in_params_.size())
{
MLOG(MGetLibLogger(), MERR, "param count is not match need:", param_count, " actual is :", in_params_.size());
return MError::NotMatch;
}
if (mysql_stmt_bind_param(p_stmt_, &in_params_[0]) != 0)
{
MLOG(MGetLibLogger(), MERR, "bind failed errno:", mysql_stmt_errno(p_stmt_), " error:", mysql_stmt_error(p_stmt_));
return MError::Unknown;
}
my_bool update_max_length = 1;
mysql_stmt_attr_set(p_stmt_, STMT_ATTR_UPDATE_MAX_LENGTH, static_cast<void*>(&update_max_length));
if (mysql_stmt_execute(p_stmt_) != 0)
{
MLOG(MGetLibLogger(), MERR, "execute failed errno:", mysql_stmt_errno(p_stmt_), " error:", mysql_stmt_error(p_stmt_));
return MError::Unknown;
}
return BindResult();
}
void GraphicsLayerAndroid::setOpacity(float opacity)
{
LOG("(%x) setOpacity: %.2f", this, opacity);
float clampedOpacity = max(0.0f, min(opacity, 1.0f));
if (clampedOpacity == m_opacity)
return;
MLOG("(%x) setFinalOpacity: %.2f=>%.2f (%.2f)", this,
opacity, clampedOpacity, m_opacity);
GraphicsLayer::setOpacity(clampedOpacity);
m_contentLayer->setOpacity(clampedOpacity);
askForSync();
}
MError MMysqlConnection::DoCheckConnect()
{
if (mysql_query(p_mysql_, "select 1+1") != 0)
{
MLOG(MGetLibLogger(), MWARN, "select 1+1 failed errno:", mysql_errno(p_mysql_), " error:", mysql_error(p_mysql_));
return MError::Disconnect;
}
MError err = MError::No;
#if 1 //test code, need set zero
MYSQL_RES *p_res = mysql_store_result(p_mysql_);
if (!p_res)
{
MLOG(MGetLibLogger(), MERR, "get res failed errno:", mysql_errno(p_mysql_), " error:", mysql_error(p_mysql_));
return MError::Unknown;
}
do
{
MYSQL_ROW row = mysql_fetch_row(p_res);
if (!row)
{
MLOG(MGetLibLogger(), MERR, "get row failed errno:", mysql_errno(p_mysql_), " error:", mysql_error(p_mysql_));
err = MError::Unknown;
break;
}
if (mysql_num_fields(p_res) != 1)
{
MLOG(MGetLibLogger(), MERR, "fields is not 1");
err = MError::Unknown;
break;
}
unsigned long *p_lengths = mysql_fetch_lengths(p_res);
if (!p_lengths)
{
MLOG(MGetLibLogger(), MERR, "lengths is null");
err = MError::Unknown;
break;
}
int result = 0;
if (!MConvertTo(std::string(row[0], p_lengths[0]), result)
|| result != 2)
{
MLOG(MGetLibLogger(), MERR, "result is wrong");
err = MError::Unknown;
break;
}
err = MError::No;
} while(0);
if (err != MError::No)
{
mysql_free_result(p_res);
p_res = nullptr;
}
#endif
return err;
}
void Simple_Shader::link()
{
_shaderID = glCreateProgram();
glAttachShader(_shaderID, _vsID);
glAttachShader(_shaderID, _fsID);
glLinkProgram(_shaderID);
GLint exito;
GLchar log[512];
glGetProgramiv(_shaderID, GL_LINK_STATUS, &exito);
if(!exito)
{
glGetProgramInfoLog(_shaderID, 512, NULL, log);
MLOG("ERROR al linkear shader\n" << log );
}
}
gchar * ModuleRegister(const gchar * appPath)
{
gchar * uiPath = g_strdup_printf("%s/modules/res/"MODULE_UI_FILE,appPath);
mBuilder = gtk_builder_new ();
if(uiPath && mBuilder)
{
guint ret = gtk_builder_add_from_file (mBuilder, uiPath, NULL);
g_free(uiPath);
if(ret == 0)
{
MLOG ("Couldn't load builder file: %d",ret);
return NULL;
}
return (MODULE_NAME);
}
return NULL;
}
