bool CGLImageData::LoadTexture(const char *filename)
{
if (!LoadBMP(filename))
if(!LoadPNG(filename))
{
sLog(DEFAULT_LOG_NAME, LOG_WARNING_EV, "Can't load image->");
return false;
}
else
{
if (!MakeTexture())
{
sLog(DEFAULT_LOG_NAME, LOG_WARNING_EV, "Can't load texture in video adapter.");
return false;
}
}
else
{
if(!MakeRGBA())
{
sLog(DEFAULT_LOG_NAME, LOG_WARNING_EV, "Can't load texture.");
return false;
}
if (!MakeTexture())
{
sLog(DEFAULT_LOG_NAME, LOG_WARNING_EV, "Can't load texture in video memory.");
return false;
}
}
{
delete [] data;
data = NULL;
}
return true;
}
int onHeadersComplete(http_parser *parser)
{
TcpSocket *socket = static_cast<TcpSocket*>(parser->data);
#ifndef NO_LOG
sLog(LogEndpoint::LogLevel::DEBUG) << " === parsed header ====";
const QHash<QString, QSharedPointer<QString>> &headers = socket->getHeader().getHeaderInfo();
QHash<QString, QSharedPointer<QString>>::const_iterator i = headers.constBegin();
while (i != headers.constEnd())
{
sLog(LogEndpoint::LogLevel::DEBUG) << i.key() << *(i.value().data());
++i;
}
sLog(LogEndpoint::LogLevel::DEBUG) << " === ============= ====";
sLogFlush();
#endif
QWeakPointer<QString> host = socket->getHeader().getHeaderInfo("Host");
if (!host.isNull())
{
socket->getHeader().setHost(*host.data());
}
return 0;
}
int sAltonaMain()
{
sAltonaInit();
sLog("sys","calling Main()");
Main();
sLog("sys","Main() returned");
return sAltonaExit();
}
IDE_RC iduTable::addValue( UInt aColumn,
const UChar* aValue )
{
iduTableColumn* sColumn;
for( sColumn = mColumns.next;
sColumn != NULL;
sColumn = sColumn->next )
{
if( aColumn == 0 )
{
if( sColumn->valueAllocated <= sColumn->valueCount )
{
sColumn->valueAllocated = sColumn->valueCount + 10;
sColumn->values = (UChar**)idlOS::realloc( sColumn->values,
sColumn->valueAllocated * sizeof(UChar*) );
IDE_TEST_RAISE( sColumn->values == NULL,
ERR_MEMORY_ALLOCATION );
}
sColumn->values[sColumn->valueCount] =
(UChar*)iduMemMgr::mallocRaw( idlOS::strlen( (char*)aValue ) + 1 );
IDE_TEST_RAISE( sColumn->values[sColumn->valueCount] == NULL,
ERR_MEMORY_ALLOCATION );
idlOS::strcpy( (char*)sColumn->values[sColumn->valueCount],
(char*)aValue );
sColumn->valueCount++;
break;
}
aColumn--;
}
IDE_TEST_RAISE( sColumn == NULL, ERR_COLUMN_NOT_FOUND );
return IDE_SUCCESS;
IDE_EXCEPTION( ERR_COLUMN_NOT_FOUND );
{
ideLogEntry sLog(IDE_SERVER_0);
sLog.append( "Column not found.\n" );
sLog.write();
}
IDE_EXCEPTION( ERR_MEMORY_ALLOCATION );
{
ideLogEntry sLog(IDE_SERVER_0);
sLog.append( "Memory allocation failure.\n" );
sLog.write();
}
IDE_EXCEPTION_END;
return IDE_FAILURE;
}
void UserManagementAPI::mailSent(QString status)
{
qDebug() << status;
SmtpManager *smtp = (SmtpManager*)QObject::sender();
smtp->deleteLater();
sLog() << "Email sent!";
}
LRESULT YSkinWindow::OnCreate(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
sLog("YSkinWindow::OnCreate");
ModifyStyle(WS_CAPTION,WS_CLIPSIBLINGS | WS_CLIPCHILDREN);
if(!RegisterSkin(_T("changeskinwin.xml"),0,this))
return 0;
GetPaintMgr()->AddNotifier(this);
RECT rcClient;
::GetClientRect(*this, &rcClient);
::SetWindowPos(*this, NULL, rcClient.left, rcClient.top, rcClient.right - rcClient.left, \
rcClient.bottom - rcClient.top, SWP_FRAMECHANGED);
FindControl(_pSkinLayout,_T("tabs"));
FindControl(_pSysSkinLayout,_T("SysSkinLayout"));
FindControl(_pMySkinLayout,_T("MySkinLayout"));
FindControl(_pWebSkin,_T("web_skin"));
ASSERT(_pWebSkin&&_pSysSkinLayout&&_pSkinLayout&&_pMySkinLayout);
_pSkinJsHandler = new CSkinJsHandler(_pWebSkin);
this->InitJsHandler(_pSkinJsHandler);
_pWebSkin->SetWebBrowserEventHandler(_pSkinJsHandler);
theMainWin->BroadCast();
LoadSysSkin();
LoadMySkin();
return 0;
}
BOOL CLoginWindow::Receive(SkinChangedParam param)
{
try
{
if(!IsWindow()) return FALSE;
sLog("CLoginWindow::Receive");
CDuiString bgimage_ = param.bgimage;
DWORD bkcolor_ = param.bkcolor;
CControlUI* background = GetPaintMgr()->GetRoot();
if (background != NULL&&0!=bgimage_.Compare(background->GetBkImage()))
{
if (!param.bgimage.IsEmpty())
{
CDuiString sBkImage = bgimage_;
background->SetBkImage(sBkImage);
}
else
background->SetBkImage(_T(""));
background->SetBkColor(param.bkcolor);
}
return TRUE;
}
catch (...)
{
sLogError("CLoginWindow::Receive");
throw _T("CLoginWindow::Receive");
return FALSE;
}
}
int Mode(std::list<R_type *> a)
{
if (a.empty())
{
throw "Function Mode must have >1 arguments";
}
std::string sNull("NULL");
std::string sLog("Logical");
std::string sNum("Numeric");
std:: string sChar("Character");
int ind = TTV.put(Character);
for (std::list<R_type *>::iterator i = a.begin(); i != a.end(); i++)
{
kind_of_type t = (*i)->get_type();
switch(t)
{
case Nulltype:
TTV[ind]->add(sNull);
break;
case Logical:
TTV[ind]->add(sLog);
break;
case Numeric:
TTV[ind]->add(sNum);
break;
case Character:
TTV[ind]->add(sChar);
break;
}
}
return ind;
}
void CLoginWindow::LoginWithToken(const CString& token)
{
CString sToken = token;
assert(!token.IsEmpty());
sLog("loginWithToken:%s",sToken.GetBuffer());
sToken.ReleaseBuffer();
theWebServiceMgr->AsynSendRequest(m_hWnd,url::Requester::MakeLogin(token));
// EnableWindow(FALSE);
}
bool GridManager::RemoveMachineJob(Machine* machine, uint jobId)
{
if (!machine)
{
sLog(Console)->Log("GridManager::RemoveMachineJob: Tried to remove machine with machine null pointer");
return false;
}
return machine->RemoveJob(jobId);
}
PriorityMachine* GridManager::GetPriorityMachine( uint id ) const
{
PriorityMachine m(id);
auto it = _priorityMachines.find(&m);
if (it == _priorityMachines.end())
{
sLog(Console)->Log("GridManager::GetPriorityMachine: Could not find priority machine with id %u in GridManager", id);
return NULL;
}
return *it;
}
bool GridManager::AddJob(Job* job)
{
if (!job)
{
sLog(Console)->Log("GridManager::AddJob: Tried to added a Job with null pointer");
return false;
}
_waitingJobs.push(job);
return true;
}
void Init()
{
sASSERT(Active==0);
Active = 2;
MemLeakLock = new sThreadLock();
Free = 0;
LeakCount = 0;
sClear(Hash);
FirstBlock = 0;
atexit(Exit);
Active = 1;
sLog("sys","leak tracking activated");
}
void Worker::run()
{
#ifndef NO_LOG
qDebug() << m_name<<"'s thread id"<<thread()->currentThreadId();
sLog() << m_name << "'s thread id" << thread()->currentThreadId();
#endif
m_socketWatchDog = new WorkerSocketWatchDog(this);
m_socketWatchDog->start();
m_socketWatchDog->setPriority(QThread::HighestPriority);
connect(m_socketWatchDog, SIGNAL(finished()), this, SLOT(watchDogFinished()));
exec();
}
void Worker::discardClient()
{
TcpSocket* socket = static_cast<TcpSocket*>(sender());
#ifndef NO_LOG
qDebug() << "thread id" << thread()->currentThreadId();
qDebug() << "release socket" << socket << socket->m_id;
//qDebug() << "finish serving client inside" << m_name;
sLog() << m_name << "finished request.";
sLogFlush();
#endif
socket->deleteLater();
m_idleSemaphore.release();
}
User* GridManager::GetUser(uint id) const
{
AcademicUser usr(id);
auto it = _users.find(&usr);
if (it == _users.end())
{
sLog(Console)->Log("GridManager::GetUser: Could not find user with id %u in GridManager", id);
return NULL;
}
return *it;
}
void Worker::newSocket(qintptr socket)
{
//qDebug() << m_name << " is handling a new request; thread id" << thread()->currentThreadId();
TcpSocket* s = new TcpSocket(this);
s->m_id = static_cast<unsigned int>(rand());
connect(s, SIGNAL(readyRead()), this, SLOT(readClient()));
connect(s, SIGNAL(disconnected()), this, SLOT(discardClient()));
s->setSocketDescriptor(socket);
s->setTimeout(1000*60*2);
#ifndef NO_LOG
sLog() << m_name << " receive a new request from ip:" << s->peerAddress().toString();
#endif
}
bool GridManager::RemovePriorityMachine(const PriorityMachine* machine)
{
auto it = std::find_if(_priorityMachines.begin(), _priorityMachines.end(), [machine] (PriorityMachine* mach) { return mach == machine; });
if (it == _priorityMachines.end())
{
sLog(Console)->Log("GridManager::RemovePriorityMachine(PriorityMachine*): Could not find priority machine %s in GridManager", machine->GetName().c_str());
return false;
}
delete *it;
_priorityMachines.erase(it);
return true;
}
IDE_RC iduFitManager::hitServer( iduFitAction *aFitAction )
{
/* BUG-39414 */
ideLogEntry sLog(IDE_FIT_0);
sLog.append( "HDB server was hitted.\n" );
sLog.appendFormat( "[%s:%"ID_UINT32_FMT":\"%s\"]\n",
aFitAction->mFileName,
aFitAction->mCodeLine,
aFitAction->mTID );
sLog.write();
return IDE_SUCCESS;
}
//------------------------------------------------------------------
DWORD WINAPI down_http_file::httpfileload_proc(void* p_param)
{
down_task* p_task = (down_task*)p_param;
assert(p_task);
if(!p_task) return 0;
// CurlData* pdata = new CurlData();
// pdata->SetURL(mci::unicode_2_utf8(p_task->s_url).c_str());
// pdata->SetFileName(mci::unicode_2_ansi(p_task->s_local_file_down).c_str());
// pdata->h_notify_wnd = p_task->h_notify_wnd;
// pdata->n_notify_msg = p_task->n_notify_msg;
// pdata->n_lparam = p_task->n_lparam;
// pdata->n_wparam = p_task->n_wparam;
// pdata->bshowprogress = true;
//
// int e_result = HttpManagerProto::Instance()->DoHttpGet(pdata);
down_result_e e_result = http_file_down(p_task->s_url, p_task->s_local_file_down);
if(e_result == dr_success)
{
switch (p_task->task_type)
{
case TT_NORMAL:
{
}
break;
default:
break;
}
if(!p_task->s_local_file_normal.IsEmpty())
{
BOOL bResult = ::MoveFile(p_task->s_local_file_down,p_task->s_local_file_normal);
bResult ? sLog("::MoveFile[%s ---> %s]",
mci::unicode_2_ansi(p_task->s_local_file_down).c_str(),
mci::unicode_2_ansi(p_task->s_local_file_normal).c_str()) : sLogError("::MoveFile[%s--->%s]",
mci::unicode_2_ansi(p_task->s_local_file_down).c_str(),
mci::unicode_2_ansi(p_task->s_local_file_normal).c_str());
}
if (p_task->h_notify_wnd != NULL && p_task->n_notify_msg > 0)
{
::PostMessage(p_task->h_notify_wnd,p_task->n_notify_msg,WPARAM(p_task->n_wparam),WP_LOAD_FINISH);
}
}//end if (e_result == dr_success)
delete p_task;
p_task = NULL;
// delete param;
return 0;
}
void Shader::handleShaderCompilerError( GLuint shaderID, const char* fileName, const std::string& shaderBuffer )
{
GLint length = 0;
GLchar* log;
glGetShaderiv( shaderID, GL_INFO_LOG_LENGTH, &length );
log = new char[ length + 1 ];
glGetShaderInfoLog( shaderID, length, &length, log );
std::string sLog( log );
std::vector< std::string > errorTokens;
stringTokenizer( sLog, errorTokens, "\n" );
std::string popupOutputMessage;
for( size_t i = 0; i < errorTokens.size() && errorTokens[i].size() > 0; ++i )
{
size_t lineIndexStart = errorTokens[i].find( "(" );
size_t lineIndexEnd = errorTokens[i].find( ")" );
std::string lineNumber =
errorTokens[i].substr( lineIndexStart + 1, lineIndexEnd - lineIndexStart - 1 );
std::string errorMessage( "Error on line: " + lineNumber );
std::vector< std::string > lineTokens;
stringTokenizer( shaderBuffer, lineTokens, "\n" );
int lineNum = atoi( lineNumber.c_str() );
errorMessage += "\n>";
if( lineNum != 0 )
{
errorMessage += lineTokens[ lineNum - 1 ] + "\n";
}
else
{
errorMessage += lineTokens[ 0 ] + "\n";
}
errorMessage += errorTokens[i];
std::string consoleOutput( "./" );
consoleOutput += fileName;
consoleOutput += "(" + lineNumber + "): " + errorTokens[i] + "\n";
MonkyException::printToCompilerOutputConsole( consoleOutput.c_str() );
popupOutputMessage += errorMessage + "\n\n";
}
MonkyException::fatalErrorMessageBox( "Shader Error", popupOutputMessage.c_str() );
}
bool GridManager::RemovePriorityMachine(uint id)
{
PriorityMachine m(id);
auto it = _priorityMachines.find(&m);
if (it == _priorityMachines.end())
{
sLog(Console)->Log("GridManager::RemovePriorityMachine(uint): Could not find priority machine with id %u in GridManager", id);
return false;
}
delete *it;
_priorityMachines.erase(it);
return true;
}
bool GridManager::AddJobByUser(User* user, Job* job)
{
if (!user)
{
sLog(Console)->Log("GridManager::AddJobByUser: Tried to added a Job with user null pointer");
return false;
}
if (!job)
{
sLog(Console)->Log("GridManager::AddJobByUser: Tried to added a Job with job null pointer");
return false;
}
if (!user->CanCreateJob(job))
throw std::runtime_error("Can't create Job because User doesn't have enough budget.");
if (!AddJob(job))
return false;
user->CreatedJob(job);
return true;
}
// get texture by name
Texture* TextureByName(const char* texture_name)
{
if(texture_name)
{
for(UINT i = 0; i < texture_count; i++)
{
if(strcmp(textures[i].name, texture_name) == 0)
{
return &textures[i];
}
}
}
sLog(DEFAULT_LOG_NAME, "Error", "Попытка получить текстуру по имени не увенчалась успехом");
return NULL;
}
void IdleUserContainer::Update(uint32 diff)
{
for (std::unordered_map<uint, IdleUser*>::iterator it = _hashTable.begin(); it != _hashTable.end();)
{
it->second->Update(diff);
if (it->second->GetElapsedTime() > REMOVAL_TIME_SECS)
{
sLog(Console)->Log("IdleUser %s (id: %u) removed due to extended inactivity.", it->second->GetName(), it->first);
delete it->second;
it = _hashTable.erase(it);
}
else
++it;
}
}
IDE_RC iduFitManager::abortServer( iduFitAction *aFitAction )
{
/* BUG-39414 */
ideLogEntry sLog(IDE_FIT_0);
sLog.setTailless(ACP_TRUE);
sLog.append( "HDB server was aborted.\n" );
sLog.appendFormat( "[%s:%"ID_UINT32_FMT":\"%s\"]\n",
aFitAction->mFileName,
aFitAction->mCodeLine,
aFitAction->mTID );
sLog.append( "IDU_FIT_POINT_JUMP\n" );
sLog.write();
return IDE_SUCCESS;
}
int sAltonaExit()
{
#if sConfigShell && sConfigDebug
sPrint("*** press any key ***\n");
getchar();
#endif
sGC->CollectNow();
sDPrint("/****************************************************************************/\n");
sSubsystem::SetRunlevel(0x00);
sDPrint("/****************************************************************************/\n");
Private::ExitGfx();
sLog("sys","Altona2 is done");
return sExitCode;
}
bool GridManager::RemoveUser(uint id)
{
AcademicUser usr(id);
auto it = _users.find(&usr);
if (it == _users.end())
{
sLog(Console)->Log("GridManager::RemoveUser(uint): Could not find user with id %u in GridManager", id);
return false;
}
_idleUsers.InsertUser(IdleUser::FromUser(*it));
delete *it;
_users.erase(it);
return true;
}
void Exit()
{
sLog("sys","leak tracking deactivated");
sASSERT(Active==1);
sDumpMemory();
Active=2;
LeakBlock *b = FirstBlock;
LeakBlock *n;
sDelete(MemLeakLock);
while(b)
{
n = b->Next;
sFreeMemSystem(b);
b = n;
}
}
bool GridManager::RemoveUser(const User* user)
{
if (!user) return NULL;
auto it = std::find_if(_users.begin(), _users.end(), [user] (User* usr) { return usr == user; });
if (it == _users.end())
{
sLog(Console)->Log("GridManager::RemoveUser(User*): Could not find user %s in GridManager", user->GetName().c_str());
return false;
}
_idleUsers.InsertUser(IdleUser::FromUser(*it));
delete *it;
_users.erase(it);
return true;
}
