void CShader::InitShaders(string strVertex, string strFragment)
{
// These will hold the shader's text file data
string strVShader, strFShader;
// Make sure the user passed in a vertex and fragment shader file
if(!strVertex.length() || !strFragment.length())
return;
// If any of our shader pointers are set, let's free them first.
if(m_hVertexShader || m_hFragmentShader || m_hProgramObject)
Release();
// Here we get a pointer to our vertex and fragment shaders
m_hVertexShader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
m_hFragmentShader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
// Now we load the shaders from the respective files and store it in a string.
strVShader = LoadTextFile(strVertex.c_str());
strFShader = LoadTextFile(strFragment.c_str());
// Do a quick switch so we can do a double pointer below
const char *szVShader = strVShader.c_str();
const char *szFShader = strFShader.c_str();
// Now this assigns the shader text file to each shader pointer
glShaderSourceARB(m_hVertexShader, 1, &szVShader, NULL);
glShaderSourceARB(m_hFragmentShader, 1, &szFShader, NULL);
// Now we actually compile the shader's code
glCompileShaderARB(m_hVertexShader);
glCompileShaderARB(m_hFragmentShader);
// Next we create a program object to represent our shaders
m_hProgramObject = glCreateProgramObjectARB();
// We attach each shader we just loaded to our program object
glAttachObjectARB(m_hProgramObject, m_hVertexShader);
glAttachObjectARB(m_hProgramObject, m_hFragmentShader);
// Our last init function is to link our program object with OpenGL
glLinkProgramARB(m_hProgramObject);
int logLength = 0;
glGetObjectParameterivARB(m_hProgramObject, GL_OBJECT_INFO_LOG_LENGTH_ARB, &logLength);
if (logLength > 1)
{
char *szLog = (char*)malloc(logLength);
int writtenLength = 0;
glGetInfoLogARB(m_hProgramObject, logLength, &writtenLength, szLog);
MessageBox(g_hWnd, szLog, "GLSL Error", MB_OK);
free(szLog);
}
// Now, let's turn off the shader initially.
glUseProgramObjectARB(0);
}
uint LoadFragmentProgram(string fn)
{
int len;
char* buf=LoadTextFile (fn, len);
if(!buf) return 0;
uint ret;
glGenProgramsARB( 1, &ret );
glBindProgramARB( GL_FRAGMENT_PROGRAM_ARB,ret);
glProgramStringARB( GL_FRAGMENT_PROGRAM_ARB,GL_PROGRAM_FORMAT_ASCII_ARB,len,buf);
if ( GL_INVALID_OPERATION == glGetError() )
{
// Find the error position
GLint errPos;
glGetIntegerv( GL_PROGRAM_ERROR_POSITION_ARB,&errPos );
// Print implementation-dependent program
// errors and warnings string.
const GLubyte *errString=glGetString( GL_PROGRAM_ERROR_STRING_ARB);
fltk::message("Error at position %d when loading fragment program file %s:\n%s",errPos,fn.c_str(),errString);
return 0;
}
return ret;
}
void RegexpWindow::readSettings(){
QSettings settings;
inputText_ = settings.value(TEXT_OPT, "").toString();
fileName_ = settings.value(FILENAME_OPT, "").toString();
regExpText_ = settings.value(REGEXP_OPT, "").toString();
if(!regExpText_.isEmpty()&&(!regExpText_.isNull())){
ui->RegExp->setText(regExpText_);
}
if(!fileName_.isEmpty()){
if (QFile::exists(fileName_)) {
ui->fileName->setText(fileName_);
inputText_ = LoadTextFile(fileName_);
ui->inputText->setPlainText(inputText_);
QFileInfo fi(fileName_);
dir_ = fi.absolutePath();
}
}
else{
if(!inputText_.isEmpty()&&(!inputText_.isNull())){
ui->inputText->setPlainText(inputText_);
}
}
ui->unquotebox->setChecked(settings.value(ISQTSTYLE_OPT, false).toBool());
ui->iscase->setChecked(settings.value(ISCASE_OPT, false).toBool());
ui->dontcapture->setChecked(settings.value(DONTCAP_OPT, false).toBool());
ui->isminimal->setChecked(settings.value(ISMINIMAL_OPT, false).toBool());
ui->multiline->setChecked(settings.value(MULTIL_OPT, false).toBool());
ui->isextpattern->setChecked(settings.value(ISEXTPAT_OPT, false).toBool());
ui->dotMatchEverithing->setChecked(settings.value(DOTME_OPT, false).toBool());
ui->iswildcard->setChecked(settings.value(ISWILDCARD_OPT, false).toBool());
ui->isinvgreed->setChecked(settings.value(ISINVGREED_OPT, false).toBool());
}
// Checks whether there is a ".agent.db". If yes, the function
// sets "szRootPath" and "szDataPath" in the storage structure
// and returns ERROR_SUCCESS
int CheckGameDirectory(TCascStorage * hs, TCHAR * szDirectory)
{
QUERY_KEY AgentFile;
TCHAR * szFilePath;
size_t nLength = 0;
char * szValue;
int nError = ERROR_FILE_NOT_FOUND;
// Create the full name of the .agent.db file
szFilePath = CombinePath(szDirectory, _T(".agent.db"));
if(szFilePath != NULL)
{
// Load the file to memory
nError = LoadTextFile(szFilePath, &AgentFile);
if(nError == ERROR_SUCCESS)
{
// Extract the data directory from the ".agent.db" file
szValue = ExtractStringVariable(&AgentFile, "data_dir", &nLength);
if(szValue != NULL)
{
hs->szRootPath = CascNewStr(szDirectory, 0);
hs->szDataPath = CombinePathAndString(szDirectory, szValue, nLength);
nError = (hs->szDataPath != NULL) ? ERROR_SUCCESS : ERROR_NOT_ENOUGH_MEMORY;
}
// Free the loaded blob
FreeCascBlob(&AgentFile);
}
// Freee the file path
CASC_FREE(szFilePath);
}
return nError;
}
void CBatchTextDlg::OnDblClkCtrlVariables(NMHDR *pNMHDR, LRESULT *pResult)
{
LPNMITEMACTIVATE pNMItemActivate = reinterpret_cast<LPNMITEMACTIVATE>(pNMHDR);
CString strFile;
if (SelectTextFile(strFile))
{
m_VarTbl.clear();
CStringW strContent;
LoadTextFile(strFile, CODEPAGE_GB2312, strContent);
ParseVarArray(strContent, m_VarTbl);
for (STRTABLE::iterator i = m_VarTbl.begin(); i != m_VarTbl.end();)
{
if (i->empty())
{
i = m_VarTbl.erase(i);
}
else
{
++i;
}
}
UpdateVarTbl();
}
*pResult = 0;
}
bool CHTMLSection::SetHTMLFile( LPCTSTR pcszFilename )
{
bool bRetVal = false;
LPTSTR pcszHTML = NULL;
UINT uLength = 0;
if( LoadTextFile( pcszFilename, pcszHTML, uLength ) )
{
TCHAR drive[_MAX_DRIVE];
TCHAR dir[_MAX_DIR];
TCHAR fname[_MAX_FNAME];
TCHAR ext[_MAX_EXT];
_tsplitpath( pcszFilename, drive, dir, fname, ext );
TCHAR path_buffer[_MAX_PATH];
_tmakepath( path_buffer, drive, dir, NULL, NULL );
SetHTML( pcszHTML, uLength, path_buffer );
bRetVal = true;
delete[] pcszHTML;
}
return bRetVal;
}
static int FetchAndVerifyConfigFile(TCascStorage * hs, PQUERY_KEY pFileKey, PQUERY_KEY pFileBlob)
{
TCHAR * szFileName;
int nError;
// Construct the local file name
szFileName = NewStr(hs->szDataPath, 8 + 3 + 3 + 32);
if(szFileName == NULL)
return ERROR_NOT_ENOUGH_MEMORY;
// Add the part where the config file path is
AppendConfigFilePath(szFileName, pFileKey);
// Load the config file
nError = LoadTextFile(szFileName, pFileBlob);
if(nError == ERROR_SUCCESS)
{
// Verify the blob's MD5
if(!VerifyDataBlockHash(pFileBlob->pbData, pFileBlob->cbData, pFileKey->pbData))
{
FreeCascBlob(pFileBlob);
nError = ERROR_BAD_FORMAT;
}
}
CASC_FREE(szFileName);
return nError;
}
void CShader::InitShaders(string strVertex, string strFragment)
{
// These will hold the shader's text file data
string strVShader, strFShader;
// Make sure the user passed in a vertex and fragment shader file
if(!strVertex.length() || !strFragment.length())
return;
// If any of our shader pointers are set, let's free them first.
if(m_hVertexShader || m_hFragmentShader || m_hProgramObject)
Release();
// Here we get a pointer to our vertex and fragment shaders
m_hVertexShader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
m_hFragmentShader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
// Now we load the shaders from the respective files and store it in a string.
strVShader = LoadTextFile(strVertex.c_str());
strFShader = LoadTextFile(strFragment.c_str());
// Do a quick switch so we can do a double pointer below
const char *szVShader = strVShader.c_str();
const char *szFShader = strFShader.c_str();
// Now this assigns the shader text file to each shader pointer
glShaderSourceARB(m_hVertexShader, 1, &szVShader, NULL);
glShaderSourceARB(m_hFragmentShader, 1, &szFShader, NULL);
// Now we actually compile the shader's code
glCompileShaderARB(m_hVertexShader);
glCompileShaderARB(m_hFragmentShader);
// Next we create a program object to represent our shaders
m_hProgramObject = glCreateProgramObjectARB();
// We attach each shader we just loaded to our program object
glAttachObjectARB(m_hProgramObject, m_hVertexShader);
glAttachObjectARB(m_hProgramObject, m_hFragmentShader);
// Our last init function is to link our program object with OpenGL
glLinkProgramARB(m_hProgramObject);
// Now, let's turn on our current shader. Passing 0 will turn OFF a shader.
glUseProgramObjectARB(m_hProgramObject);
}
void CGUIStaticText::CreateItem()
{
m_pStaticText->SetScreenMasks(m_szNorm, m_szNorm, m_szNorm, m_szNorm);
m_pStaticText->ShowTexture(!m_bHideTexture);
m_pStaticText->SetTextColors(m_iNormFontColor, m_iHighFontColor, m_iSelectFontColor, m_iGrayFontColor);
m_pStaticText->SetTextPos(m_iTextOffSetX, m_iTextOffSetY);
if (m_bUseLanguageEntry)
{
UpdateLanguageEntryText();
}
else
{
if (!m_bLoadFromFile)
{
if(!m_szFont.empty() && !m_szText.empty())
{
m_pStaticText->SetText(m_szFont, "", m_szText, m_szText, m_szText, m_szText, m_iFontsize);
}
else
{
m_pStaticText->SetText(m_szFont, "", "", "", "", "", 0);
}
}
else
{
LoadTextFile(m_szFilename);
if(!m_szFont.empty() && !m_szText.empty())
{
m_pStaticText->SetText(m_szFont, "", m_szText, m_szText, m_szText, m_szText, m_iFontsize);
}
else
{
m_pStaticText->SetText(m_szFont, "", "", "", "", "", 0);
}
}
}
m_pStaticText->CenterText(m_bCenterText);
m_pStaticText->SetSmartScale(true);
if (m_bUseFontShadow)
{
DWORD color = 0xff000000;
color += m_iFontShadowColor;
m_pStaticText->EnableFontShadow(true);
m_pStaticText->SetFontShadowVals(color, m_iFontShadowXScale, m_iFontShadowYScale, m_iFontShadowXOffset, m_iFontShadowYOffset);
}
else
{
m_pStaticText->EnableFontShadow(false);
}
}
FileViewDialog::FileViewDialog(const QString &file,
const QString &title,
QWidget *parent)
: QDialog(parent)
{
mUI.setupUi(this);
setWindowTitle(title);
connect(mUI.mButtons, SIGNAL(accepted()), this, SLOT(accept()));
LoadTextFile(file, mUI.mText);
}
bool LoadJsonFromFile(const TCHAR* filename, Json::Value& root)
{
bool ret = false;
buffer file;
Json::Reader reader;
CHECK(LoadTextFile(file, filename) && file.size() > 0);
if (!reader.parse(file.ptr(), root))
{
//log(reader.getFormatedErrorMessages().c_str());
CHECK(false);
}
ret = true;
Exit0:
return ret;
}
DWORD CGUIStaticText::OnSetTextFile(DWORD size, void *param)
{
VERIFY_MESSAGE_SIZE(size, sizeof(IHashString));
IHashString *filename = (IHashString*) param;
if (m_bUseLanguageEntry)
{
m_ToolBox->Log(LOGWARNING, _T("Set to use language entry; use alternate message for updating variables in string\n"));
return MSG_NOT_HANDLED;
}
else
{
m_bLoadFromFile = true;
LoadTextFile(filename->GetString());
m_pStaticText->SetText(m_szFont, "", m_szText, m_szText, m_szText, m_szText, m_iFontsize);
return MSG_HANDLED_STOP;
}
}
void GenTextFromPat(const STRARRAY &Pat, const STRARRAY &Var, CStringW &strOut)
{
if (!Pat.empty() || Pat.size() % 2 != 1)
{
strOut.Empty();
STRARRAY::const_iterator i = Pat.begin();
strOut.Append(*i++);
for (; i != Pat.end(); ++i)
{
BOOL bFile = FALSE;
CStringW strCurVar = *i;
if (strCurVar[0] == _T('f') || strCurVar[0] == _T('F'))
{
bFile = TRUE;
strCurVar.Delete(0, 1);
}
UINT nNum = atoi(CStringA(strCurVar));
if (nNum < Var.size())
{
if (bFile)
{
CStringW strFile;
if (0 == LoadTextFile(CString(Var[nNum]),
CODEPAGE_GB2312, strFile))
{
strOut.Append(strFile);
}
}
else
{
strOut.Append(Var[nNum]);
}
}
strOut.Append(*++i);
}
}
}
bool LoadTextRes(const string& dir, bool sync)
{
Log4c::Trace(ROOT_MODULE,"[TEXTRES] Load TextRes (%s) ...",dir.c_str());
list<string> files;
FindFile(dir.c_str(), ".xml", &files);
if (files.empty())
{
Log4c::Warn(ROOT_MODULE,"[TEXTRES] Load TextRes (%s) +++ FAILED +++, no files found",dir.c_str());
return false;
}
s_texts.clear();
list<string>::iterator itr = files.begin();
for(; itr != files.end(); ++itr)
{
if (!LoadTextFile(*itr, sync))
{
Log4c::Warn(ROOT_MODULE,"[TEXTRES] Load TextRes (%s) +++ FAILED +++",dir.c_str());
return false;
}
}
return true;
}
int LoadBuildInfo(TCascStorage * hs)
{
PARSEINFOFILE PfnParseProc = NULL;
int nError = ERROR_NOT_SUPPORTED;
// We support either ".build.info" or ".build.db"
switch (hs->BuildFileType)
{
case CascBuildInfo:
PfnParseProc = ParseFile_BuildInfo;
break;
case CascBuildDb:
PfnParseProc = ParseFile_BuildDb;
break;
default:
nError = ERROR_NOT_SUPPORTED;
break;
}
return LoadTextFile(hs, PfnParseProc);
}
/// This function compiles a shader and check the log
bool GLSLShader::CompileShader(GLint target, const std::string& fileName, const std::string& header)
{
std::string source = LoadTextFile(fileName);
std::string shaderStage = GetShaderStageName(target);
source = CombineHeaders(header, shaderStage + std::string("Shader"), source);
GLhandleARB shader = glCreateShaderObjectARB(target);
const char* src = source.c_str();
glShaderSourceARB(shader, 1, &src, NULL);
glCompileShaderARB(shader);
GLint compiled = 0, length = 0, laux = 0;
glGetObjectParameterivARB(shader, GL_OBJECT_COMPILE_STATUS_ARB, &compiled);
if (!compiled) std::cerr << "ERROR: Compilation of "<<shaderStage<<" shader failed:"<<std::endl;
// else std::cout << "Compilation of "<<shaderStage<<" shader OK" << std::endl;
glGetObjectParameterivARB(shader, GL_OBJECT_INFO_LOG_LENGTH_ARB, &length);
if (length > 1)
{
std::cerr << "File: " << fileName << std::endl;
if (!header.empty()) std::cerr << "Header:\n" << header << std::endl;
GLcharARB *logString = (GLcharARB *)malloc((length+1) * sizeof(GLcharARB));
glGetInfoLogARB(shader, length, &laux, logString);
std::cerr << logString << std::endl;
free(logString);
}
if (compiled)
m_hShaders[target] = shader;
else
glDeleteObjectARB(shader);
return (compiled!=0);
}
void InterpretCommand(MenuInstanceData * pMenuData, const char *pszScript) {
char szCmd[31], szParam1[51], szParam2[51];
char szTempScript[ 255 ];
memset(szTempScript, 0, sizeof(szTempScript));
strncpy(szTempScript, pszScript, 250);
if (pszScript[0] == 0) {
return;
}
char* pszScriptPointer = szTempScript;
while (pszScriptPointer && !hangup) {
pszScriptPointer = MenuParseLine(pszScriptPointer, szCmd, szParam1, szParam2);
if (szCmd[0] == 0) { // || !pszScriptPointer || !*pszScriptPointer
break;
}
// -------------------------
// Run a new menu instance
int nCmdID = GetMenuIndex(szCmd);
switch (nCmdID) {
case 0: {
// "MENU"
// Spawn a new menu
MenuInstanceData *pNewMenuData = static_cast<MenuInstanceData *>(malloc(sizeof(MenuInstanceData)));
memset(pNewMenuData, 0, sizeof(MenuInstanceData));
pNewMenuData->nFinished = 0;
pNewMenuData->nReload = 0;
Menus(pNewMenuData, pMenuData->szPath, szParam1);
free(pNewMenuData);
}
break;
case 1: {
// -------------------------
// Exit out of this instance
// of the menu
// -------------------------
// "ReturnFromMenu"
InterpretCommand(pMenuData, pMenuData->header.szExitScript);
pMenuData->nFinished = 1;
}
break;
case 2: {
// "EditMenuSet"
EditMenus(); // flag if we are editing this menu
pMenuData->nFinished = 1;
pMenuData->nReload = 1;
}
break;
case 3: {
// "DLFreeFile"
align(szParam2);
MenuDownload(szParam1, szParam2, true, true);
}
break;
case 4: {
// "DLFile"
align(szParam2);
MenuDownload(szParam1, szParam2, false, true);
}
break;
case 5: {
// "RunDoor"
MenuRunDoorName(szParam1, false);
}
break;
case 6: {
// "RunDoorFree"
MenuRunDoorName(szParam1, true);
}
break;
case 7: {
// "RunDoorNumber"
int nTemp = atoi(szParam1);
MenuRunDoorNumber(nTemp, false);
}
break;
case 8: {
// "RunDoorNumberFree"
int nTemp = atoi(szParam1);
MenuRunDoorNumber(nTemp, true);
}
break;
case 9: {
// "PrintFile"
printfile(szParam1, true);
}
break;
case 10: {
// "PrintFileNA"
printfile(szParam1, false);
}
break;
case 11: {
// "SetSubNumber"
SetSubNumber(szParam1);
}
break;
case 12: {
// "SetDirNumber"
SetDirNumber(szParam1);
}
break;
case 13: {
// "SetMsgConf"
SetMsgConf(szParam1[0]);
}
break;
case 14: {
// "SetDirConf"
SetDirConf(szParam1[0]);
}
break;
case 15: {
// "EnableConf"
EnableConf();
}
break;
case 16: {
// "DisableConf"
DisableConf();
}
break;
case 17: {
// "Pause"
pausescr();
}
break;
case 18: {
// "ConfigUserMenuSet"
ConfigUserMenuSet();
pMenuData->nFinished = 1;
pMenuData->nReload = 1;
}
break;
case 19: {
// "DisplayHelp"
if (GetSession()->GetCurrentUser()->IsExpert()) {
AMDisplayHelp(pMenuData);
}
}
break;
case 20: {
// "SelectSub"
ChangeSubNumber();
}
break;
case 21: {
// "SelectDir"
ChangeDirNumber();
}
break;
case 22: {
// "SubList"
SubList();
}
break;
case 23: {
// "UpSubConf"
UpSubConf();
}
break;
case 24: {
// "DownSubConf"
DownSubConf();
}
break;
case 25: {
// "UpSub"
UpSub();
}
break;
case 26: {
// "DownSub"
DownSub();
}
break;
case 27: {
// "ValidateUser"
ValidateUser();
}
break;
case 28: {
// "Doors"
Chains();
}
break;
case 29: {
// "TimeBank"
TimeBank();
}
break;
case 30: {
// "AutoMessage"
AutoMessage();
}
break;
case 31: {
// "BBSList"
BBSList();
}
break;
case 32: {
// "RequestChat"
RequestChat();
}
break;
case 33: {
// "Defaults"
Defaults(pMenuData);
}
break;
case 34: {
// "SendEMail"
SendEMail();
}
break;
case 35: {
// "Feedback"
FeedBack();
}
break;
case 36: {
// "Bulletins"
Bulletins();
}
break;
case 37: {
// "HopSub"
HopSub();
}
break;
case 38: {
// "SystemInfo"
SystemInfo();
}
break;
case 39: {
// "JumpSubConf"
JumpSubConf();
}
break;
case 40: {
// "KillEMail"
KillEMail();
}
break;
case 41: {
// "LastCallers"
LastCallers();
}
break;
case 42: {
// "ReadEMail"
ReadEMail();
}
break;
case 43: {
// "NewMessageScan"
NewMessageScan();
}
break;
case 44: {
// "Goodbye"
GoodBye();
}
break;
case 45: {
// "PostMessage"
WWIV_PostMessage();
}
break;
case 46: {
// "NewMsgScanCurSub"
ScanSub();
}
break;
case 47: {
// "RemovePost"
RemovePost();
}
break;
case 48: {
// "TitleScan"
TitleScan();
}
break;
case 49: {
// "ListUsers"
ListUsers();
}
break;
case 50: {
// "Vote"
Vote();
}
break;
case 51: {
// "ToggleExpert"
ToggleExpert();
}
break;
case 52: {
// "YourInfo"
YourInfo();
}
break;
case 53: {
// "ExpressScan"
ExpressScan();
}
break;
case 54: {
// "WWIVVer"
WWIVVersion();
}
break;
case 55: {
// "InstanceEdit"
InstanceEdit();
}
break;
case 56: {
// "ConferenceEdit"
JumpEdit();
}
break;
case 57: {
// "SubEdit"
BoardEdit();
}
break;
case 58: {
// "ChainEdit"
ChainEdit();
}
break;
case 59: {
// "ToggleAvailable"
ToggleChat();
}
break;
case 60: {
// "ChangeUser"
ChangeUser();
}
break;
case 61: {
// "CLOUT"
CallOut();
}
break;
case 62: {
// "Debug"
Debug();
}
break;
case 63: {
// "DirEdit"
DirEdit();
}
break;
case 65: {
// "Edit"
EditText();
}
break;
case 66: {
// "BulletinEdit"
EditBulletins();
}
break;
case 67: {
// "LoadText"
// LoadText and LoadTextFile are the same, so they are now merged.
LoadTextFile();
}
break;
case 68: {
// "ReadAllMail"
ReadAllMail();
}
break;
case 69: {
// "Reboot"
RebootComputer();
}
break;
case 70: {
// "ReloadMenus"
ReloadMenus();
}
break;
case 71: {
// "ResetUserIndex"
ResetFiles();
}
break;
case 72: {
// "ResetQScan"
ResetQscan();
}
break;
case 73: {
// "MemStat"
MemoryStatus();
}
break;
case 74: {
// "PackMsgs"
PackMessages();
}
break;
case 75: {
// "VoteEdit"
InitVotes();
}
break;
case 76: {
// "Log"
ReadLog();
}
break;
case 77: {
// "NetLog"
ReadNetLog();
}
break;
case 78: {
// "Pending"
PrintPending();
}
break;
case 79: {
// "Status"
PrintStatus();
}
break;
case 80: {
// "TextEdit"
TextEdit();
}
break;
case 81: {
// "UserEdit"
UserEdit();
}
break;
case 82: {
// "VotePrint"
VotePrint();
}
break;
case 83: {
// "YLog"
YesturdaysLog();
}
break;
case 84: {
// "ZLog"
ZLog();
}
break;
case 85: {
// "ViewNetDataLog"
ViewNetDataLog();
}
break;
case 86: {
// "UploadPost"
UploadPost();
}
break;
case 87: {
// "ClearScreen"
GetSession()->bout.ClearScreen();
}
break;
case 88: {
// "NetListing"
NetListing();
}
break;
case 89: {
// "WHO"
WhoIsOnline();
}
break;
case 90: {
// /A "NewMsgsAllConfs"
NewMsgsAllConfs();
}
break;
case 91: {
// /E "MultiEMail"
MultiEmail();
}
break;
case 92: {
// "NewMsgScanFromHere"
NewMsgScanFromHere();
}
break;
case 93: {
// "ValidatePosts"
ValidateScan();
}
break;
case 94: {
// "ChatRoom"
ChatRoom();
}
break;
case 95: {
// "DownloadPosts"
DownloadPosts();
}
break;
case 96: {
// "DownloadFileList"
DownloadFileList();
}
break;
case 97: {
// "ClearQScan"
ClearQScan();
}
break;
case 98: {
// "FastGoodBye"
FastGoodBye();
}
break;
case 99: {
// "NewFilesAllConfs"
NewFilesAllConfs();
}
break;
case 100: {
// "ReadIDZ"
ReadIDZ();
}
break;
case 101: {
// "UploadAllDirs"
UploadAllDirs();
}
break;
case 102: {
// "UploadCurDir"
UploadCurDir();
}
break;
case 103: {
// "RenameFiles"
RenameFiles();
}
break;
case 104: {
// "MoveFiles"
MoveFiles();
}
break;
case 105: {
// "SortDirs"
SortDirs();
}
break;
case 106: {
// "ReverseSortDirs"
ReverseSort();
}
break;
case 107: {
// "AllowEdit"
AllowEdit();
}
break;
case 109: {
// "UploadFilesBBS"
UploadFilesBBS();
}
break;
case 110: {
// "DirList"
DirList();
}
break;
case 111: {
// "UpDirConf"
UpDirConf();
}
break;
case 112: {
// "UpDir"
UpDir();
}
break;
case 113: {
// "DownDirConf"
DownDirConf();
}
break;
case 114: {
// "DownDir"
DownDir();
}
break;
case 115: {
// "ListUsersDL"
ListUsersDL();
}
break;
case 116: {
// "PrintDSZLog"
PrintDSZLog();
}
break;
case 117: {
// "PrintDevices"
PrintDevices();
}
break;
case 118: {
// "ViewArchive"
ViewArchive();
}
break;
case 119: {
// "BatchMenu"
BatchMenu();
}
break;
case 120: {
// "Download"
Download();
}
break;
case 121: {
// "TempExtract"
TempExtract();
}
break;
case 122: {
// "FindDescription"
FindDescription();
}
break;
case 123: {
// "ArchiveMenu"
TemporaryStuff();
}
break;
case 124: {
// "HopDir"
HopDir();
}
break;
case 125: {
// "JumpDirConf"
JumpDirConf();
}
break;
case 126: {
// "ListFiles"
ListFiles();
}
break;
case 127: {
// "NewFileScan"
NewFileScan();
}
break;
case 128: {
// "SetNewFileScanDate"
SetNewFileScanDate();
}
break;
case 129: {
// "RemoveFiles"
RemoveFiles();
}
break;
case 130: {
// "SearchAllFiles"
SearchAllFiles();
}
break;
case 131: {
// "XferDefaults"
XferDefaults();
}
break;
case 132: {
// "Upload"
Upload();
}
break;
case 133: {
// "YourInfoDL"
YourInfoDL();
}
break;
case 134: {
// "UploadToSysop"
UploadToSysop();
}
break;
case 135: {
// "ReadAutoMessage"
ReadAutoMessage();
}
break;
case 136: {
// "SetNewScanMsg"
SetNewScanMsg();
}
break;
case 137: {
// "ReadMessages"
ReadMessages();
}
break;
/*
case 138:
{ // "RUN"
ExecuteBasic(szParam1);
} break;
*/
case 139: {
// "EventEdit"
EventEdit();
}
break;
case 140: {
// "LoadTextFile"
LoadTextFile();
}
break;
case 141: {
// "GuestApply"
GuestApply();
}
break;
case 142: {
// "ConfigFileList"
ConfigFileList();
}
break;
case 143: {
// "ListAllColors"
ListAllColors();
}
break;
#ifdef QUESTIONS
case 144: {
// "EditQuestions"
EditQuestions();
}
break;
case 145: {
// "Questions"
Questions();
}
break;
#endif
case 146: {
// "RemoveNotThere"
RemoveNotThere();
}
break;
case 147: {
// "AttachFile"
AttachFile();
}
break;
case 148: {
// "InternetEmail"
InternetEmail();
}
break;
case 149: {
// "UnQScan"
UnQScan();
}
break;
// ppMenuStringsIndex[150] thru ppMenuStringsIndex[153] not used.....
case 154: {
// "Packers"
Packers();
}
break;
case 155: {
// Color_Config
color_config();
}
break;
//------------------------------------------------------------------
// ppMenuStringsIndex[156] and [157] are reserved for SDS Systems and systems
// that distribute modifications. DO NOT reuse these strings for
// other menu options.
//------------------------------------------------------------------
// case 156:
// { // ModAccess
// ModsAccess();
// } break;
// case 157:
// { // SDSAccess
// SDSAccess();
// } break;
//------------------------------------------------------------------
case 158: {
// InitVotes
InitVotes();
}
break;
case 161: {
// TurnMCIOn
TurnMCIOn();
}
break;
case 162: {
// TurnMCIOff
TurnMCIOff();
}
break;
default: {
MenuSysopLog("The following command was not recognized");
MenuSysopLog(szCmd);
}
break;
}
}
}
void GuiResourceFolder::LoadResourceFolderFromXml(DelayLoadingList& delayLoadings, const WString& containingFolder, Ptr<parsing::xml::XmlElement> folderXml, collections::List<WString>& errors)
{
ClearItems();
ClearFolders();
FOREACH(Ptr<XmlElement>, element, XmlGetElements(folderXml))
{
WString name;
if(Ptr<XmlAttribute> nameAtt=XmlGetAttribute(element, L"name"))
{
name=nameAtt->value.value;
}
if(element->name.value==L"Folder")
{
if (name == L"")
{
errors.Add(L"A resource folder should have a name.");
errors.Add(
L"Format: RESOURCE, Row: " + itow(element->codeRange.start.row + 1) +
L", Column: " + itow(element->codeRange.start.column + 1) +
L", Message: A resource folder should have a name.");
}
else
{
Ptr<GuiResourceFolder> folder=new GuiResourceFolder;
if(AddFolder(name, folder))
{
WString newContainingFolder=containingFolder;
Ptr<XmlElement> newFolderXml=element;
if(Ptr<XmlAttribute> contentAtt=XmlGetAttribute(element, L"content"))
{
if(contentAtt->value.value==L"Link")
{
folder->SetFileContentPath(XmlGetValue(element));
WString filePath = containingFolder + folder->GetFileContentPath();
WString text;
if(LoadTextFile(filePath, text))
{
if(auto parser=GetParserManager()->GetParser<XmlDocument>(L"XML"))
{
if(auto xml=parser->TypedParse(text, errors))
{
newContainingFolder=GetFolderPath(filePath);
newFolderXml=xml->rootElement;
}
}
}
else
{
errors.Add(L"Failed to load file \"" + filePath + L"\".");
}
}
}
folder->LoadResourceFolderFromXml(delayLoadings, newContainingFolder, newFolderXml, errors);
}
else
{
errors.Add(L"Duplicated resource folder name \"" + name + L"\".");
}
}
}
else if(element->name.value.Length() <= 3 || element->name.value.Sub(0, 4) != L"ref.")
{
WString relativeFilePath;
WString filePath;
if(Ptr<XmlAttribute> contentAtt=XmlGetAttribute(element, L"content"))
{
if(contentAtt->value.value==L"File")
{
relativeFilePath = XmlGetValue(element);
filePath = containingFolder + relativeFilePath;
if(name==L"")
{
name=GetFileName(filePath);
}
}
}
Ptr<GuiResourceItem> item = new GuiResourceItem;
if(AddItem(name, item))
{
WString type = element->name.value;
IGuiResourceTypeResolver* typeResolver = GetResourceResolverManager()->GetTypeResolver(type);
IGuiResourceTypeResolver* preloadResolver = typeResolver;
if(typeResolver)
{
if (!typeResolver->DirectLoadXml())
{
WString preloadType = typeResolver->IndirectLoad()->GetPreloadType();
if (preloadType != L"")
{
preloadResolver = GetResourceResolverManager()->GetTypeResolver(preloadType);
if (!preloadResolver)
{
errors.Add(L"Unknown resource resolver \"" + preloadType + L"\" of resource type \"" + type + L"\".");
}
}
}
}
else
{
errors.Add(L"Unknown resource type \"" + type + L"\".");
}
if(typeResolver && preloadResolver)
{
if (auto directLoad = preloadResolver->DirectLoadXml())
{
Ptr<DescriptableObject> resource;
WString itemType = preloadResolver->GetType();
if (filePath == L"")
{
resource = directLoad->ResolveResource(element, errors);
}
else
{
item->SetFileContentPath(relativeFilePath);
resource = directLoad->ResolveResource(filePath, errors);
}
if (typeResolver != preloadResolver)
{
if (auto indirectLoad = typeResolver->IndirectLoad())
{
if(indirectLoad->IsDelayLoad())
{
DelayLoading delayLoading;
delayLoading.type = type;
delayLoading.workingDirectory = containingFolder;
delayLoading.preloadResource = item;
delayLoadings.Add(delayLoading);
}
else if(resource)
{
resource = indirectLoad->ResolveResource(resource, 0, errors);
itemType = typeResolver->GetType();
}
}
else
{
resource = 0;
errors.Add(L"Resource type \"" + typeResolver->GetType() + L"\" is not a indirect load resource type.");
}
}
item->SetContent(itemType, resource);
}
else
{
errors.Add(L"Resource type \"" + preloadResolver->GetType() + L"\" is not a direct load resource type.");
}
}
if(!item->GetContent())
{
RemoveItem(name);
}
}
else
{
errors.Add(L"Duplicated resource item name \"" + name + L"\".");
}
}
}
int LoadBuildInfo(TCascStorage * hs)
{
QUERY_KEY InfoFile = {NULL, 0};
QUERY_KEY FileData = {NULL, 0};
TCHAR * szAgentFile;
TCHAR * szInfoFile;
bool bBuildConfigComplete = false;
int nError = ERROR_SUCCESS;
// Since HOTS build 30027, the game uses build.info file for storage info
if(bBuildConfigComplete == false)
{
szInfoFile = CombinePath(hs->szRootPath, _T(".build.info"));
if(szInfoFile != NULL)
{
nError = LoadTextFile(szInfoFile, &InfoFile);
if(nError == ERROR_SUCCESS)
{
// Parse the info file
nError = ParseInfoFile(hs, &InfoFile);
if(nError == ERROR_SUCCESS)
bBuildConfigComplete = true;
// Free the loaded blob
FreeCascBlob(&InfoFile);
}
CASC_FREE(szInfoFile);
}
}
// If the info file has not been loaded, try the legacy .build.db
if(bBuildConfigComplete == false)
{
szAgentFile = CombinePath(hs->szRootPath, _T(".build.db"));
if(szAgentFile != NULL)
{
nError = LoadTextFile(szAgentFile, &FileData);
if(nError == ERROR_SUCCESS)
{
nError = ParseAgentFile(hs, &FileData);
if(nError == ERROR_SUCCESS)
bBuildConfigComplete = true;
FreeCascBlob(&FileData);
}
CASC_FREE(szAgentFile);
}
}
// If the .build.info and .build.db file hasn't been loaded,
if(nError == ERROR_SUCCESS && bBuildConfigComplete == false)
{
nError = ERROR_FILE_CORRUPT;
}
// Load the configuration file
if(nError == ERROR_SUCCESS)
{
nError = FetchAndVerifyConfigFile(hs, &hs->CdnConfigKey, &FileData);
if(nError == ERROR_SUCCESS)
{
nError = LoadCdnConfigFile(hs, &FileData);
FreeCascBlob(&FileData);
}
}
// Load the build file
if(nError == ERROR_SUCCESS)
{
nError = FetchAndVerifyConfigFile(hs, &hs->CdnBuildKey, &FileData);
if(nError == ERROR_SUCCESS)
{
nError = LoadCdnBuildFile(hs, &FileData);
FreeCascBlob(&FileData);
}
}
// Fill the index directory
if(nError == ERROR_SUCCESS)
{
// First, check for more common "data" subdirectory
if((hs->szIndexPath = CheckForIndexDirectory(hs, _T("data"))) != NULL)
return ERROR_SUCCESS;
// Second, try the "darch" subdirectory (older builds of HOTS - Alpha)
if((hs->szIndexPath = CheckForIndexDirectory(hs, _T("darch"))) != NULL)
return ERROR_SUCCESS;
nError = ERROR_FILE_NOT_FOUND;
}
return nError;
}
int WINAPI WinMain(HINSTANCE hinstance, HINSTANCE hprev, PSTR cmdline, int ishow)
{
HWND hwnd;
MSG msg;
WNDCLASSEX wndclassex = {0};
// Fill the WNDCLASSEX fields we care about
wndclassex.cbSize = sizeof(WNDCLASSEX);
wndclassex.style = CS_HREDRAW | CS_VREDRAW; // Redraw the window if it's position or size changes
wndclassex.lpfnWndProc = WinProc;
wndclassex.hInstance = hinstance;
wndclassex.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH); // Make the window background white
wndclassex.lpszClassName = kClassName;
wndclassex.hCursor = (HCURSOR)LoadImage(NULL, MAKEINTRESOURCE(IDC_ARROW), IMAGE_CURSOR,
0, 0, LR_SHARED); // Load the default arrow cursor
RegisterClassEx(&wndclassex); // Register the WNDCLASSEX with the OS
// Here we set the style of the window
// Notice how we use the style WS_VSCROLL, this creates the window with a
// vertical scroll bar
DWORD style = WS_SYSMENU | WS_VSCROLL;
// Create the window
hwnd = CreateWindowEx(WS_EX_CLIENTEDGE, // Our Window has a border with a sunken edge
kClassName,
"www.GameTutorials.com -- Vertical Scroll Bar",
style, // Style of window
CW_USEDEFAULT, // Windows picks upper-left X-pos of window
CW_USEDEFAULT, // Windows picks upper-left Y-pos of window
kWinWid,
kWinHgt,
NULL,
NULL,
hinstance,
NULL);
// Error Check
if(hwnd == NULL)
return EXIT_FAILURE; // Couldn't create the window
// Load a the text file for displaying
if(!LoadTextFile("VerticalText.txt"))
return EXIT_FAILURE; // No text file, no tutorial
// Show and update the window
ShowWindow(hwnd, ishow);
UpdateWindow(hwnd);
while(1)
{
// Checking for window messages -- If we get one we'll deal with it
if(PeekMessage(&msg,NULL,0,0,PM_REMOVE))
{
if(msg.message == WM_QUIT)
break;
TranslateMessage(&msg);
DispatchMessage(&msg);
}
else
{
// This is where the core of our application would go if we were writing one...
}
} // end of while(1)
UnregisterClass(kClassName,hinstance); // Free up memory
return msg.wParam;
}
bool Shader::CreateFromFile(GLenum shaderType, const char* filename) {
std::string sourceCode = LoadTextFile(filename);
bool success = CreateFromSourceCode(shaderType, sourceCode.c_str());
return success;
}
VOID DoWM_CREATE(HWND hwnd)
{
//Icons ;)
SendMessage(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)LoadIcon(NULL, MAKEINTRESOURCE(IDI_ICON1)));
SendMessage(hwnd, WM_SETICON, ICON_BIG, (LPARAM)LoadIcon(NULL, MAKEINTRESOURCE(IDI_ICON1)));
// Create Status bar
hStatus = CreateWindowEx(
0,
STATUSCLASSNAME,
NULL,
WS_CHILD | WS_VISIBLE | SBARS_SIZEGRIP,
0, 0, 0, 0,
hwnd,
(HMENU)IDC_MAIN_STATUS,
GetModuleHandle(NULL),
NULL);
if (hStatus == NULL)
MessageBox(hwnd, "Could not create edit box.", "Error", MB_OK | MB_ICONERROR);
else
SendMessage(hStatus, SB_SETTEXT, 0, (LPARAM)"I'm a status bar!");
//Create Edit Control
hEdit = CreateWindowEx(
WS_EX_CLIENTEDGE,
"EDIT", "",
WS_CHILD |
WS_VISIBLE |
WS_VSCROLL |
WS_HSCROLL |
ES_MULTILINE |
ES_AUTOVSCROLL |
ES_AUTOHSCROLL,
0, 0, 0, 0,
hwnd,
(HMENU)IDC_MAIN_EDIT,
GetModuleHandle(NULL),
NULL);
if (hEdit == NULL)
MessageBox(hwnd, "Could not create edit box.", "Error", MB_OK | MB_ICONERROR);
//create backup window
hOriginalDataWindow = CreateWindowEx(
WS_EX_CLIENTEDGE,
"EDIT", "",
WS_CHILD |
WS_VISIBLE |
WS_VSCROLL |
WS_HSCROLL |
ES_MULTILINE |
ES_AUTOVSCROLL |
ES_AUTOHSCROLL |
ES_READONLY,
0, 0, 0, 0,
hwnd,
(HMENU)IDC_MAIN_EDIT,
GetModuleHandle(NULL),
NULL);
if (hOriginalDataWindow == NULL)
MessageBox(hwnd, "Could not create edit box.", "Error", MB_OK | MB_ICONERROR);
SetFont(hwnd, 0);
//create 'open folder' button
hOpenFolderButton = CreateWindowEx(
NULL,
"Button",
"Open Folder",
WS_BORDER | WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
0, 0, 0, 0,
hwnd,
(HMENU)BTN_OPENFOLDER,
GetModuleHandle(NULL),
NULL);
//create 'revert' button
hRevertButton = CreateWindowEx(
NULL,
"Button",
"Revert",
WS_BORDER | WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
0, 0, 0, 0,
hwnd,
(HMENU)BTN_REVERT,
GetModuleHandle(NULL),
NULL);
//create 'Open File' button
hOpenButton = CreateWindowEx(
NULL,
"Button",
"Open File",
WS_BORDER | WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON,
0, 0, 0, 0,
hwnd,
(HMENU)BTN_OPENFILE,
GetModuleHandle(NULL),
NULL);
if (hOpenFolderButton == NULL || hRevertButton == NULL || hOpenButton == NULL)
MessageBox(hwnd, "Could not create one of the buttons.", "Error", MB_OK | MB_ICONERROR);
if (cmdlinearg_path_set) {
//remove quotes from the file path
if (cmdlinearg_path[0] == '"') {
int len = strlen(cmdlinearg_path);
memcpy(cmdlinearg_path, cmdlinearg_path + 1, len - 2);
cmdlinearg_path[len - 2] = 0;
}
//use given path to load the initial file
LoadTextFile(hwnd, hEdit, (LPSTR)cmdlinearg_path);
}
}
VCMaterial* VCMaterial::GetMaterial( std::string fullPath )
{
auto iter = m_loadedMaterial.find(fullPath);
if (iter != m_loadedMaterial.end())
return iter->second;
// Load a new Material
std::string materialJson = LoadTextFile(fullPath);
Json::Value root;
Json::Reader reader;
bool parsingSuccessful = reader.parse( materialJson, root );
if ( !parsingSuccessful )
{
VC_ERROR("Failed to parse material JSON file: " << fullPath);
}
VCMaterial* mat = new VCMaterial();
// Name
mat->Name = root.get("Name", "").asString();
// Shader
mat->Shader = VCResourceManager::GetShader(root.get("Shader", "").asString());
// Values
const Json::Value values = root["UniformValues"];
int currentTexUnit = 0;
for ( int i = 0; i < values.size(); i++ )
{
std::string valueType = values[i].get("Type", "").asString();
std::string valueName = values[i].get("Name", "").asString();
std::string valueData = values[i].get("Value", "").asString();
int typeID = VCShaderUniform::GetID(valueType);
VCShaderValue* uniformValue;
switch (typeID)
{
case VCShaderUniform::Float: uniformValue = VCShaderFloat::FromJson(valueName, mat->Shader->GetUniformID(valueName), valueData); break;
case VCShaderUniform::Int: uniformValue = VCShaderInt::FromJson(valueName, mat->Shader->GetUniformID(valueName), valueData); break;
case VCShaderUniform::Vector2: uniformValue = VCShaderVector2::FromJson(valueName, mat->Shader->GetUniformID(valueName), valueData); break;
case VCShaderUniform::Vector3: uniformValue = VCShaderVector3::FromJson(valueName, mat->Shader->GetUniformID(valueName), valueData); break;
case VCShaderUniform::Vector4: uniformValue = VCShaderVector4::FromJson(valueName, mat->Shader->GetUniformID(valueName), valueData); break;
case VCShaderUniform::Matrix3: uniformValue = VCShaderMatrix3::FromJson(valueName, mat->Shader->GetUniformID(valueName), valueData); break;
case VCShaderUniform::Matrix4: uniformValue = VCShaderMatrix4::FromJson(valueName, mat->Shader->GetUniformID(valueName), valueData); break;
case VCShaderUniform::ColorRGBA: uniformValue = VCShaderColorRGBA::FromJson(valueName, mat->Shader->GetUniformID(valueName), valueData); break;
case VCShaderUniform::Sampler2D: uniformValue = VCShaderSampler2D::FromJson(valueName, mat->Shader->GetUniformID(valueName), GL_TEXTURE0 + currentTexUnit++, valueData); break;
case VCShaderUniform::Sampler3D: uniformValue = VCShaderSampler3D::FromJson(valueName, mat->Shader->GetUniformID(valueName), GL_TEXTURE0 + currentTexUnit++, valueData); break;
default: throw std::exception("Unhanded VCShaderUniform value type");
}
mat->Values.push_back(uniformValue);
}
m_loadedMaterial.insert(std::unordered_map<std::string, VCMaterial*>::value_type(fullPath, mat));
return mat;
}
