std::string
CommandEventHandler::power()
{
std::ostringstream ret;
ret << "Power status:" << ENDL;
ret << "\tCurrent %: ";
ret << readTextFile("/sys/class/power_supply/battery/capacity");
ret << "\tStatus: ";
ret << readTextFile("/sys/class/power_supply/battery/status");
return ret.str();
}
/**
* Constructor
*/
Shader::Shader(const std::string& filename, GLenum shaderType)
: _handle (0)
{
std::string source = readTextFile(filename);
const GLchar* sourcePtr0 = source.c_str();
const GLchar** sourcePtr = &sourcePtr0;
// Set the source and attempt compilation
_handle = glCreateShader(shaderType);
GL_ERR_CHECK();
glShaderSource(_handle, 1, sourcePtr, NULL);
GL_ERR_CHECK();
glCompileShader(_handle);
GL_ERR_CHECK();
if(!getCompileStatus())
{
std::stringstream err;
err << "Failed to compile shader file: " << filename << std::endl;
err << getLog() << std::endl;
throw std::runtime_error(err.str());
}
}
VkShaderModule loadShaderGLSL(const char *fileName, VkDevice device, VkShaderStageFlagBits stage)
{
std::string shaderSrc = readTextFile(fileName);
const char *shaderCode = shaderSrc.c_str();
size_t size = strlen(shaderCode);
assert(size > 0);
VkShaderModule shaderModule;
VkShaderModuleCreateInfo moduleCreateInfo;
VkResult err;
moduleCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
moduleCreateInfo.pNext = NULL;
moduleCreateInfo.codeSize = 3 * sizeof(uint32_t) + size + 1;
moduleCreateInfo.pCode = (uint32_t*)malloc(moduleCreateInfo.codeSize);
moduleCreateInfo.flags = 0;
// Magic SPV number
((uint32_t *)moduleCreateInfo.pCode)[0] = 0x07230203;
((uint32_t *)moduleCreateInfo.pCode)[1] = 0;
((uint32_t *)moduleCreateInfo.pCode)[2] = stage;
memcpy(((uint32_t *)moduleCreateInfo.pCode + 3), shaderCode, size + 1);
err = vkCreateShaderModule(device, &moduleCreateInfo, NULL, &shaderModule);
assert(!err);
return shaderModule;
}
void WinImage::slotOpen()
{
//if ( maybeSave()) {
QString fileName = QFileDialog::getOpenFileName(this, "Open image or text file", ".", "*.bmp *.jpg *.txt");
_filenameStem = fileName.right(fileName.length() - fileName.lastIndexOf('/') - 1);
_filenameStem = _filenameStem.left(_filenameStem.lastIndexOf('.'));
qDebug() << fileName;
if (fileName.endsWith("txt"))
{
_data = readTextFile(fileName.toStdString().data(), &_count);
if (!_data) return;
_scale = _a_number->value();
_image = loadDataImage(_image, _data, _count, _scale);
//_imageOrig = QImage( _image);
update();
int H = _image.height(), W = _image.width();
resize (W + 2 * _offset.x(), H + 2 * _offset.y());
}
else if (!fileName.isEmpty()) loadImage(fileName);
//}
}
LumiFile::LumiFile(const char* FileName) :
_fileName(QFileInfo(FileName).fileName()),
_series(),
_error(),
_isCSFile(false)
{
ifstream in(FileName);
if (!in)
{
_error.append(new LumiError(QString("Could not open file %1").arg(fileName())));
return;
}
switch (in.peek())
{
case ('\0') : {readLumicycle (FileName); break;}
case (236) : {readChronostar(FileName); break;}
default : {readTextFile (in);}
}
in.close();
// if (nTimes() == 0) throw ZeroTimesInFile();
// if (nSeries() == 0) throw ZeroSeriesInFile();
// _td->makeTime24Data();
// double endTime = ceil(maxTime()*24.0)/24.0;
// for (unsigned int i = 0; i < nSeries(); i++)
// {
// TimeSeries *ts = series(i);
// if (ts->stopMean() < 0) ts->_stopMean = endTime;
// if (ts->stopTrend() < 0) ts->_stopTrend = endTime;
// if (ts->stopFit() < 0) ts->_stopFit = endTime;
// ts->setLog(defaultLog, true); // smooth, fit and calcMean are called by this function
// }
}
int editAppList(){
appList_add("app5");
appList_remove("app2");
char* str = readTextFile("/usr/lib/nwjs/appList"); //This is run in chroot environment, initializad by a previous test.
int result = strcmp(str, "app1\napp3\napp4\napp5\n") == 0;
free(str);
return result;
}
void
GLSLProgram::loadFromFiles(const char *vFilename, const char *gFilename, const char *fFilename,
GLenum gsInput, GLenum gsOutput, int maxVerts)
{
char *vsource = readTextFile(vFilename);
char *gsource = 0;
if (gFilename) {
gsource = readTextFile(gFilename);
}
char *fsource = readTextFile(fFilename);
mProg = compileProgram(vsource, gsource, fsource, gsInput, gsOutput, maxVerts);
delete [] vsource;
if (gsource) delete [] gsource;
delete [] fsource;
}
/* Create shader instance and read source from file system */
GLuint loadShader(const char * srcPath, GLenum shaderType)
{
GLuint shader = glCreateShader(shaderType);
FILE * fp = fopen(srcPath, "rb");
char *src = readTextFile(fp);
fclose(fp);
glShaderSource(shader,1,(const GLchar**)&src,NULL);
free(src);
return shader;
}
bool GLSLProgram::setIncludeFromFile(const char *includeName, const char* filename)
{
char tmpstr[200];
sprintf(tmpstr, "%s/%s", filename, includeName);
char * incStr = readTextFile(tmpstr);
if(!incStr)
return false;
sprintf(tmpstr, "/%s", includeName);
glNamedStringARB(GL_SHADER_INCLUDE_ARB, strlen(tmpstr), tmpstr, strlen(incStr), incStr);
return false;
}
// this is not cross platform
std::string
CommandEventHandler::uptimemillis()
{
std::string uptime_file = readTextFile("/proc/uptime");
double uptime;
sscanf(&uptime_file[0], "%lf", &uptime);
uptime *= 1000;
std::ostringstream out;
out << (int) uptime;
return out.str();
}
int main(uint32_t startloc) {
cpu_clock_init();
ssp_clock_init();
systickInit();
// cpu_clock_set(204);
SETUPgout(EN_VDD);
SETUPgout(MIXER_EN);
SETUPgout(MIC_AMP_DIS);
SETUPgout(LED1);
SETUPgout(LED2);
SETUPgout(LED3);
SETUPgout(LED4);
inputInit();
flashInit();
lcdInit();
fsInit();
lcdFill(0xff); /* Display BL Image here */
sli=startloc;
if (startloc != (uintptr_t)&_app_start){ /* not booted via DFU, do autoboot */
char filename[FLEN];
switch(getInputRaw()){
case BTN_LEFT:
getInputWaitRelease();
doRealExec(1);
break;
case BTN_UP:
doMSC();
default:
case BTN_NONE:
readTextFile(BOOTCFG, filename, FLEN);
lcdPrintln("Booting:");
lcdPrintln(filename);
bootFile(filename);
break;
};
};
static const struct MENU main={ "Bootloader", {
{ "Exec Firmware", &doExec},
{ "MSC", &doMSC},
{ "Flash Boot Ldr", &doFlash},
{ "Info", &doInfo},
{NULL,NULL}
}};
do {
handleMenu(&main);
}while(1);
}
QString Renderer::readShader(const QString &fileName)
{
QString newCode;
QString code = readTextFile(fileName);
QStringList lines = code.split("\n");
foreach (QString line, lines)
{
QString pragma = "#pragma include";
int i = line.indexOf(pragma);
if (i >= 0)
{
line = line.mid(pragma.size()).simplified();
line = line.remove("\"");
line = readTextFile(line);
}
newCode += line + "\n";
}
int writeReadTextFile(){
char *str = "this\nis\na\ntest\nstring";
int result = writeTextFile("testTextFile.txt", str);
if(!result)
return 0;
char *readStr = readTextFile("testTextFile.txt");
if(!readStr)
return 0;
result = strcmp(str, readStr);
free(readStr);
return result == 0;
}
GLuint
GLSLProgram::compileProgramFromFiles(const char *vFilename, const char *gFilename, const char *fFilename,
GLenum gsInput, GLenum gsOutput, int maxVerts)
{
char *vsource = readTextFile(vFilename);
char *gsource = 0;
if (gFilename) {
gsource = readTextFile(gFilename);
}
char *fsource = readTextFile(fFilename);
if(vsource)
{
GLSLProgram::setShaderNames(NULL, vFilename, gFilename, fFilename);
mProg = compileProgram(vsource, gsource, fsource, gsInput, gsOutput, maxVerts);
delete [] vsource;
if (gsource) delete [] gsource;
delete [] fsource;
return mProg;
}
return 0;
}
void createProgram() {
const GLchar* vertexShaderSource = readTextFile("tutorial08.vert");
int vertexShaderSourceLength = strlen(vertexShaderSource);
GLuint vertexShaderId = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertexShaderId, 1, &vertexShaderSource, &vertexShaderSourceLength);
glCompileShader(vertexShaderId);
checkShaderCompileStatus(vertexShaderId);
const GLchar* fragmentShaderSource = readTextFile("tutorial08.frag");
int fragmentShaderSourceLength = strlen(fragmentShaderSource);
GLuint fragmentShaderId = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShaderId, 1, &fragmentShaderSource, &fragmentShaderSourceLength);
glCompileShader(fragmentShaderId);
checkShaderCompileStatus(fragmentShaderId);
programId = glCreateProgram();
glAttachShader(programId, vertexShaderId);
glAttachShader(programId, fragmentShaderId);
glBindAttribLocation(programId, POSITION_ATTRIBUTE_INDEX, "vPosition");
glBindAttribLocation(programId, NORMAL_ATTRIBUTE_INDEX, "vNormal");
glLinkProgram(programId);
checkProgramLinkStatus(programId);
}
/**
* Creates the output HTML file.
**/
void writeOutput(const std::list<Event>& list, std::list<TimedBlock*>& blockResults, std::list<TimedBlock*>& functionResults)
{
msg("Generating the output file...\n");
std::string pluginDir = ::idadir("plugins");
std::string hotchDir = pluginDir + "/hotch";
char filename[40] = {0};
sprintf(filename, "results.html");
// sprintf(filename, "results-%d.html", currentTime);
std::string templateString;
if (!readTextFile(hotchDir + "/template.htm", templateString))
{
msg("Could not read template file\n");
return;
}
IdaFile file;
unsigned int functions = file.getNumberOfFunctions();
unsigned int hitFunctions = countHitBlocks(functionResults);
unsigned int unhitFunctions = functions - hitFunctions;
unsigned int blocks = file.getDebugger().getNumberOfBreakpoints();
unsigned int hitBlocks = countHitBlocks(blockResults);
unsigned int unhitBlocks = blocks - hitBlocks;
replaceString(templateString, "%FILENAME%", file.getInputfilePath());
replaceString(templateString, "%NUMBER_OF_FUNCTIONS%", toString(functions));
replaceString(templateString, "%NUMBER_OF_HIT_FUNCTIONS%", toString(hitFunctions));
replaceString(templateString, "%NUMBER_OF_HIT_FUNCTIONS_PERCENTAGE%", floatToString(100.0 * hitFunctions / functions));
replaceString(templateString, "%NUMBER_OF_NOT_HIT_FUNCTIONS%", toString(unhitFunctions));
replaceString(templateString, "%NUMBER_OF_NOT_HIT_FUNCTIONS_PERCENTAGE%", floatToString(100.0 * unhitFunctions / functions));
replaceString(templateString, "%NUMBER_OF_BLOCKS%", toString(blocks));
replaceString(templateString, "%NUMBER_OF_HIT_BLOCKS%", toString(hitBlocks));
replaceString(templateString, "%NUMBER_OF_HIT_BLOCKS_PERCENTAGE%", floatToString(100.0 * hitBlocks / blocks));
replaceString(templateString, "%NUMBER_OF_NOT_HIT_BLOCKS%", toString(unhitBlocks));
replaceString(templateString, "%NUMBER_OF_NOT_HIT_BLOCKS_PERCENTAGE%", floatToString(100.0 * unhitBlocks / blocks));
replaceString(templateString, "%FUNCTIONS_BY_HITS%", generateFunctionTable(functionResults, sortByHits));
replaceString(templateString, "%FUNCTIONS_BY_TIME%", generateFunctionTable(functionResults, sortByTime));
replaceString(templateString, "%FUNCTIONS_BY_AVERAGE_TIME%", generateFunctionTable(functionResults, sortByAverageTime));
replaceString(templateString, "%BLOCKS_BY_HITS%", generateBlocksTable(blockResults, sortByHits));
replaceString(templateString, "%BLOCKS_BY_TIME%", generateBlocksTable(blockResults, sortByTime));
replaceString(templateString, "%ALL_EVENTS%", generateEventsTable(list));
writeOutput(hotchDir + "/" + filename, templateString);
}
void FastXmlDocument::getXMLAsLines(string path, vector<FastXmlLine*> *lines) {
char *data = readTextFile(path);
char *head = data;
head = nextTag(head);
bool foundData = false;
while(head<end) {
head = nextData(head, foundData);
if(foundData) lines->push_back(new FastXmlLine(tagBuffer));
head = nextTag(head);
lines->push_back(new FastXmlLine(tagBuffer));
}
delete [] data;
}
int main(uint32_t startloc) {
cpu_clock_init();
ssp_clock_init();
systick_set_reload(208000);
systick_set_clocksource(0);
systick_interrupt_enable();
systick_counter_enable();
// cpu_clock_pll1_max_speed();
SETUPgout(EN_VDD);
SETUPgout(MIXER_EN);
SETUPgout(LED1);
SETUPgout(LED2);
SETUPgout(LED3);
SETUPgout(LED4);
inputInit();
flashInit();
lcdInit();
fsInit();
lcdFill(0xff); /* Display BL Image here */
sli=startloc;
if (startloc != (uintptr_t)&_app_start){ /* not booted via DFU, do autoboot */
if (getInputRaw()!=BTN_LEFT){
char filename[FLEN];
readTextFile(BOOTCFG, filename, FLEN);
lcdPrintln("Fname");
lcdPrintln(filename);
bootFile(filename,0);
};
};
static const struct MENU main={ "Bootloader", {
{ "Info", &doInfo},
{ "Exec", &doExec},
{ "Flash", &doFlash},
{NULL,NULL}
}};
handleMenu(&main);
return 0;
}
void MShaderRef::update(void)
{
MEngine * engine = MEngine::getInstance();
MLevel * level = engine->getLevel();
MRenderingContext * render = engine->getRenderingContext();
char * text = readTextFile(getFilename());
if(text)
{
// gen shader if null
if(m_shaderId == 0)
{
switch(m_type)
{
case M_SHADER_VERTEX:
render->createVertexShader(&m_shaderId);
break;
case M_SHADER_PIXEL:
render->createPixelShader(&m_shaderId);
break;
}
}
// send shader source
render->sendShaderSource(m_shaderId, text);
SAFE_FREE(text);
MFXManager * FXManager = level->getFXManager();
unsigned int i;
unsigned int size = FXManager->getFXRefsNumber();
for(i=0; i<size; i++)
{
MFXRef * FXRef = FXManager->getFXRef(i);
if((FXRef->getPixelShaderRef() == this) || (FXRef->getVertexShaderRef() == this))
{
unsigned int FXId = FXRef->getFXId();
render->updateFX(FXId);
}
}
}
}
void InitializeParameters::load() {
try {
InitializeParameters defaultValues;
RegistryKey key = getKey();
m_elementCount = key.getInt( _T("elementcount") , (UINT)defaultValues.m_elementCount);
m_elementSize = key.getInt( _T("elementsize") , defaultValues.m_elementSize );
String initMethodName = key.getString(_T("initmethod") , _T("random") );
m_initMethod = nameToInitMethod(initMethodName);
m_randomizationMethod = (RandomizationMethod)key.getInt( _T("randomize") , defaultValues.m_randomizationMethod);
m_seed = key.getUint( _T("seed") , defaultValues.m_seed );
m_periodCount = key.getUint( _T("periodcount") , defaultValues.m_periodCount );
m_fileName = key.getString( _T("filename") , defaultValues.m_fileName );
if(m_initMethod == IDC_RADIO_FILEDATA) {
readTextFile(m_fileName);
}
} catch(Exception e) {
setDefault();
}
}
void DelimitedFile::read(const std::string& fileName)
{
m_lines.clear();
m_lines.clear();
std::string s = readTextFile(fileName);
s += '\n';
std::string ss;
for(std::string::size_type i = 0;i < s.length();i++)
{
if (s[i] == '\r')
continue;
if (s[i] == '\n')
{
ss = cutComment(ss);
if (!trim(ss).empty())
m_lines.push_back(ss);
ss.erase();
continue;
} // if '\n';
ss+= s[i];
} // for;
}
// clipWatcherWndProc
//
static LRESULT CALLBACK clipWatcherWndProc(
HWND hWnd,
UINT uMsg,
WPARAM wParam,
LPARAM lParam)
{
//fwprintf(stderr, L"msg: %x, hWnd=%p, wParam=%p\n", uMsg, hWnd, wParam);
switch (uMsg) {
case WM_CREATE:
{
// Initialization.
CREATESTRUCT* cs = (CREATESTRUCT*)lParam;
ClipWatcher* watcher = (ClipWatcher*)(cs->lpCreateParams);
if (watcher != NULL) {
SetWindowLongPtr(hWnd, GWLP_USERDATA, (LONG_PTR)watcher);
if (logfp != NULL) {
fwprintf(logfp, L"watcher: %s\n", watcher->name);
}
// Start watching the clipboard content.
AddClipboardFormatListener(hWnd);
SetTimer(hWnd, watcher->blink_timer_id, ICON_BLINK_INTERVAL, NULL);
SetTimer(hWnd, watcher->check_timer_id, FILESYSTEM_INTERVAL, NULL);
SendMessage(hWnd, WM_TASKBAR_CREATED, 0, 0);
}
return FALSE;
}
case WM_DESTROY:
{
// Clean up.
LONG_PTR lp = GetWindowLongPtr(hWnd, GWLP_USERDATA);
ClipWatcher* watcher = (ClipWatcher*)lp;
if (watcher != NULL) {
KillTimer(hWnd, watcher->blink_timer_id);
KillTimer(hWnd, watcher->check_timer_id);
// Stop watching the clipboard content.
RemoveClipboardFormatListener(hWnd);
// Unregister the icon.
NOTIFYICONDATA nidata = {0};
nidata.cbSize = sizeof(nidata);
nidata.hWnd = hWnd;
nidata.uID = watcher->icon_id;
Shell_NotifyIcon(NIM_DELETE, &nidata);
}
PostQuitMessage(0);
return FALSE;
}
case WM_CLIPBOARDUPDATE:
{
// Clipboard change detected.
LONG_PTR lp = GetWindowLongPtr(hWnd, GWLP_USERDATA);
ClipWatcher* watcher = (ClipWatcher*)lp;
if (watcher != NULL) {
DWORD seqno = GetClipboardSequenceNumber();
if (watcher->seqno < seqno) {
watcher->seqno = seqno;
if (logfp != NULL) {
fwprintf(logfp, L"updated clipboard: seqno=%d\n", seqno);
}
for (int i = 0; i < CLIPBOARD_RETRY; i++) {
Sleep(CLIPBOARD_DELAY);
if (OpenClipboard(hWnd)) {
if (GetClipboardData(CF_ORIGIN) == NULL) {
WCHAR path[MAX_PATH];
StringCchPrintf(path, _countof(path), L"%s\\%s",
watcher->dstdir, watcher->name);
exportClipFile(path);
}
WCHAR text[256];
int filetype = getClipboardText(text, _countof(text));
if (0 <= filetype) {
NOTIFYICONDATA nidata = {0};
nidata.cbSize = sizeof(nidata);
nidata.hWnd = hWnd;
nidata.uID = watcher->icon_id;
nidata.uFlags = NIF_INFO;
nidata.dwInfoFlags = NIIF_INFO;
nidata.uTimeout = 1;
StringCchCopy(nidata.szInfoTitle,
_countof(nidata.szInfoTitle),
MESSAGE_UPDATED);
StringCchCopy(nidata.szInfo,
_countof(nidata.szInfo),
text);
Shell_NotifyIcon(NIM_MODIFY, &nidata);
watcher->icon_blinking = HICON_FILETYPE[filetype];
watcher->icon_blink_count = ICON_BLINK_COUNT;
}
CloseClipboard();
break;
}
}
}
}
return FALSE;
}
case WM_NOTIFY_FILE:
{
// File change detected.
LONG_PTR lp = GetWindowLongPtr(hWnd, GWLP_USERDATA);
ClipWatcher* watcher = (ClipWatcher*)lp;
if (watcher != NULL) {
FileEntry* entry = checkFileChanges(watcher);
if (entry != NULL) {
if (logfp != NULL) {
fwprintf(logfp, L"updated file: path=%s\n", entry->path);
}
int index = rindex(entry->path, L'.');
if (0 <= index) {
WCHAR* ext = &(entry->path[index]);
if (_wcsicmp(ext, FILE_EXT_TEXT) == 0) {
// CF_UNICODETEXT
int nchars;
LPWSTR text = readTextFile(entry->path, &nchars);
if (text != NULL) {
if (OpenClipboard(hWnd)) {
EmptyClipboard();
setClipboardOrigin(entry->path);
setClipboardText(text, nchars);
CloseClipboard();
}
free(text);
}
} else if (_wcsicmp(ext, FILE_EXT_BITMAP) == 0) {
// CF_DIB
BITMAPINFO* bmp = readBMPFile(entry->path);
if (bmp != NULL) {
if (OpenClipboard(hWnd)) {
EmptyClipboard();
setClipboardOrigin(entry->path);
setClipboardDIB(bmp);
CloseClipboard();
}
free(bmp);
}
}
}
}
}
return FALSE;
}
case WM_COMMAND:
{
// Command specified.
LONG_PTR lp = GetWindowLongPtr(hWnd, GWLP_USERDATA);
ClipWatcher* watcher = (ClipWatcher*)lp;
switch (LOWORD(wParam)) {
case IDM_OPEN:
if (watcher != NULL) {
if (OpenClipboard(hWnd)) {
openClipFile();
CloseClipboard();
}
}
break;
case IDM_EXIT:
SendMessage(hWnd, WM_CLOSE, 0, 0);
break;
}
return FALSE;
}
case WM_TIMECHANGE:
{
// Filesytem/Network share change detected.
// NOTICE: We wanted to check if wParam is DBT_DEVICEARRIVAL.
// But it doesn't work when the system is suspended.
LONG_PTR lp = GetWindowLongPtr(hWnd, GWLP_USERDATA);
ClipWatcher* watcher = (ClipWatcher*)lp;
if (watcher != NULL) {
// Re-initialize the watcher object.
StopClipWatcher(watcher);
}
return TRUE;
}
case WM_NOTIFY_ICON:
{
// UI event handling.
POINT pt;
HMENU menu = GetMenu(hWnd);
if (menu != NULL) {
menu = GetSubMenu(menu, 0);
}
switch (lParam) {
case WM_LBUTTONDBLCLK:
if (menu != NULL) {
UINT item = GetMenuDefaultItem(menu, FALSE, 0);
SendMessage(hWnd, WM_COMMAND, MAKEWPARAM(item, 1), NULL);
}
break;
case WM_LBUTTONUP:
break;
case WM_RBUTTONUP:
if (GetCursorPos(&pt)) {
SetForegroundWindow(hWnd);
if (menu != NULL) {
TrackPopupMenu(menu, TPM_LEFTALIGN,
pt.x, pt.y, 0, hWnd, NULL);
}
PostMessage(hWnd, WM_NULL, 0, 0);
}
break;
}
return FALSE;
}
case WM_TIMER:
{
LONG_PTR lp = GetWindowLongPtr(hWnd, GWLP_USERDATA);
ClipWatcher* watcher = (ClipWatcher*)lp;
if (watcher != NULL) {
UINT_PTR timer_id = wParam;
if (timer_id == watcher->blink_timer_id) {
// Blink the icon.
if (watcher->icon_blink_count) {
watcher->icon_blink_count--;
BOOL on = (watcher->icon_blink_count % 2);
NOTIFYICONDATA nidata = {0};
nidata.cbSize = sizeof(nidata);
nidata.hWnd = hWnd;
nidata.uID = watcher->icon_id;
nidata.uFlags = NIF_ICON;
nidata.hIcon = (on? watcher->icon_blinking : HICON_EMPTY);
Shell_NotifyIcon(NIM_MODIFY, &nidata);
}
} else if (timer_id == watcher->check_timer_id) {
// Check the filesystem.
StartClipWatcher(watcher);
}
}
return FALSE;
}
case WM_CLOSE:
DestroyWindow(hWnd);
return FALSE;
default:
if (uMsg == WM_TASKBAR_CREATED) {
LONG_PTR lp = GetWindowLongPtr(hWnd, GWLP_USERDATA);
ClipWatcher* watcher = (ClipWatcher*)lp;
if (watcher != NULL) {
// Register the icon.
NOTIFYICONDATA nidata = {0};
nidata.cbSize = sizeof(nidata);
nidata.hWnd = hWnd;
nidata.uID = watcher->icon_id;
nidata.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
nidata.uCallbackMessage = WM_NOTIFY_ICON;
nidata.hIcon = HICON_EMPTY;
StringCchPrintf(nidata.szTip, _countof(nidata.szTip),
MESSAGE_WATCHING, watcher->srcdir);
Shell_NotifyIcon(NIM_ADD, &nidata);
}
}
return DefWindowProc(hWnd, uMsg, wParam, lParam);
}
}
void init_nick(void){
readTextFile("nick.cfg",GLOBAL(nickname),MAXNICK);
readTextFile("font.cfg",GLOBAL(nickfont),FLEN);
readTextFile("l0nick.cfg",GLOBAL(nickl0),FLEN);
}
// need to figure a better way
std::string
CommandEventHandler::screen()
{
return readTextFile("/sys/devices/virtual/graphics/fb0/modes");
}
void init_rgbLeds(void) {
readTextFile("ledfile.cfg",GLOBAL(ledfile),FLEN);
readRgbLedFile();
}
GLuint createProgram(char const *vshFileName, char const *fshFileName)
{
GLint info;
char *log;
GLuint vsh, fsh, program;
char *vshCode, *fshCode;
vshCode = readTextFile(vshFileName);
if (vshCode == NULL)
{
//fprintf(stderr, "Nao foi possivel ler o arquivo \"%s\"\n", vshFileName);
return 0u;
}
fshCode = readTextFile(fshFileName);
if (fshCode == NULL)
{
//fprintf(stderr, "Nao foi possivel ler o arquivo \"%s\"\n", fshFileName);
return 0u;
}
vsh = createShader(vshCode, GL_VERTEX_SHADER);
free(vshCode);
if (vsh == 0u)
{
free(fshCode);
return 0u;
}
fsh = createShader(fshCode, GL_FRAGMENT_SHADER);
free(fshCode);
if (fsh == 0u)
{
return 0u;
}
program = glCreateProgram();
if (program == 0u)
{
//fprintf(stderr, "Nao foi possivel criar um objeto programa (shader).\n");
glDeleteShader(vsh);
glDeleteShader(fsh);
return 0u;
}
glAttachShader(program, vsh);
glAttachShader(program, fsh);
glLinkProgram(program);
glDeleteShader(vsh);
glDeleteShader(fsh);
glGetProgramiv(program, GL_LINK_STATUS, &info);
if (info == GL_FALSE)
{
//fprintf(stderr, "Nao foi possivel linkar um programa:\n");
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &info);
log = (char*)malloc(info);
glGetProgramInfoLog(program, info, &info, log);
printf("%s\n", log);
glDeleteProgram(program);
return 0u;
}
return program;
}
