DWORD __stdcall RunExternalToolThread(void *p)
{
int i;
int id = (int)p;
TOOL *curTools = tools;
for (i=0; i < id - ID_EXTERNALTOOLS &&curTools; curTools = curTools->next, i++) ;
if (curTools)
{
if (curTools->CommandWindow)
{
char buf[MAX_PATH];
sprintf(buf, "%s\\hi", curTools->wd);
DosWindow(buf, curTools->cmd, curTools->args, curTools->name, "Command Complete.");
}
else
{
DWORD bRet;
char name[256];
STARTUPINFO stStartInfo;
PROCESS_INFORMATION stProcessInfo;
DWORD retCode;
char cmd[10000];
strcpy(name, curTools->name);
sprintf(cmd, "\"%s\" %s", curTools->cmd, curTools->args);
memset(&stStartInfo, 0, sizeof(STARTUPINFO));
memset(&stProcessInfo, 0, sizeof(PROCESS_INFORMATION));
stStartInfo.cb = sizeof(STARTUPINFO);
bRet = CreateProcess(NULL, cmd, NULL, NULL, TRUE, 0, 0,
curTools->wd, &stStartInfo, &stProcessInfo);
if (!bRet)
{
ExtendedMessageBox("Command Execution", MB_SETFOREGROUND | MB_SYSTEMMODAL,
"Could not execute %s.", cmd);
return 0;
}
WaitForSingleObject(stProcessInfo.hProcess, INFINITE);
GetExitCodeProcess(stProcessInfo.hProcess, &retCode);
if (retCode)
{
ExtendedMessageBox("Command Execution", MB_SETFOREGROUND | MB_SYSTEMMODAL,
"Command %s returned %d", name, retCode);
}
CloseHandle(stProcessInfo.hProcess);
CloseHandle(stProcessInfo.hThread);
}
}
return 0;
}
//-------------------------------------------------------------------------
void SaveProject(PROJECTITEM *project)
{
FILE *out ;
char name[MAX_PATH];
sprintf(name, "%s.cpj", project->realName);
if (PropGetBool(NULL, "BACKUP_PROJECTS"))
backup(name);
out = fopen(name, "w");
if (!out)
{
ExtendedMessageBox("Save Error", 0, "Could not save project %s", project->displayName);
return;
}
fprintf(out, "<CC386PROJECT>\n");
fprintf(out, "\t<VERSION ID=\"%d\"/>\n", PROJVERS);
fprintf(out, "\t<WORKAREA NAME=\"%s\"/>\n", workArea->realName);
fprintf(out, "\t<TARGET TITLE=\"%s\">\n", project->displayName);
SaveProfiles(out, project, 2);
fprintf(out, "\t\t<FILES>\n");
SaveFiles(out, project, project->children,3);
fprintf(out, "\t\t</FILES>\n");
fprintf(out, "\t</TARGET>\n");
fprintf(out, "</CC386PROJECT>\n");
fclose(out);
project->changed = FALSE;
}
void AddItem(DEBUG_INFO *dbg, VARINFO *var,
int cursoreip, int page)
{
WATCHINFO *x = MatchItem(var, page);
if (x)
{
FreeVarInfo(var);
}
else
{
HTREEITEM previous = 0;
if (watchinfo_count[page] >= watchinfo_max[page])
{
if (watchinfo_max[page] >= 128)
{
ExtendedMessageBox("Watch Error", MB_SETFOREGROUND |
MB_SYSTEMMODAL,
"There are too many items in the watch window\nNot adding the current selection");
return ;
}
watchinfo_max[page] += 64;
watchinfo_list[page] = realloc(watchinfo_list[page], watchinfo_max[page] *sizeof
(WATCHINFO));
}
if (watchinfo_count[page])
previous = watchinfo_list[page][watchinfo_count[page] - 1].info->hTreeItem;
memset(&watchinfo_list[page][watchinfo_count[page]], 0, sizeof(watchinfo_list[page][0]));
watchinfo_list[page][watchinfo_count[page]].info = var;
watchinfo_list[page][watchinfo_count[page]].dbg_info = dbg;
watchinfo_list[page][watchinfo_count[page]++].cursoreip = cursoreip;
RefreshItem(&watchinfo_list[page][watchinfo_count[page] - 1], var->address, NULL);
InsertSubTree(0, previous, var, watchinfo_count[page] - 1, page);
}
}
int VerifyPath(char *path)
{
char err[MAX_PATH+100];
WIN32_FIND_DATA aa;
HANDLE ff;
ff = FindFirstFile(path, &aa);
if (ff != INVALID_HANDLE_VALUE)
{
FindClose(ff);
return 1;
}
else
{
// try to create it...
FILE *fil = fopen(path,"wb");
if (fil)
{
fclose(fil);
unlink(path);
return 1;
}
}
sprintf(err, "Could not create file %s", path);
ExtendedMessageBox("Invalid file", MB_OK, "Could not create file %s", path);
return 0;
}
static void AddItem(DEBUG_INFO *dbg, VARINFO *var,
int cursoreip, WATCHDATA *ptr)
{
WATCHINFO *x = MatchItem(var, ptr);
if (x)
{
x->marked = FALSE;
FreeVarInfo(var);
}
else
{
HTREEITEM previous = 0;
if (ptr->watchinfo_count >= ptr->watchinfo_max)
{
if (ptr->watchinfo_max >= 128)
{
ExtendedMessageBox("Watch Error", MB_SETFOREGROUND |
MB_SYSTEMMODAL,
"There are too many items in the watch window\nNot adding the current selection");
return ;
}
ptr->watchinfo_max += 64;
ptr->watchinfo_list = realloc(ptr->watchinfo_list, ptr->watchinfo_max *sizeof
(WATCHINFO));
}
if (ptr->watchinfo_count)
previous = ptr->watchinfo_list[ptr->watchinfo_count - 1].info->hTreeItem;
memset(&ptr->watchinfo_list[ptr->watchinfo_count], 0, sizeof(ptr->watchinfo_list[0]));
ptr->watchinfo_list[ptr->watchinfo_count].info = var;
ptr->watchinfo_list[ptr->watchinfo_count].dbg_info = dbg;
ptr->watchinfo_list[ptr->watchinfo_count++].cursoreip = cursoreip;
RefreshItem(ptr, &ptr->watchinfo_list[ptr->watchinfo_count - 1], var->address, NULL, TRUE);
InsertSubTree(0, previous, var, ptr->watchinfo_count - 1, ptr);
}
}
// used after BP are restored from data file
void TagRegenBreakPoints(void)
{
struct tagfile *l = tagFileList;
struct tag *t;
int flag = FALSE;
while (l)
{
t = l->tagArray[TAG_BP];
while (t)
{
if (t->enabled == TAGF_ENABLED && !t->disable)
{
int tl;
tl = GetBreakpointNearestLine(l->name, t->debugLineno, TRUE);
if (!dbgSetBreakPoint(l->name,tl, t->extra))
{
flag = TRUE;
t->enabled |= TAGF_GRAYED;
InvalidateByName(l->name);
}
}
t = t->next;
}
l = l->next;
}
if (flag)
ExtendedMessageBox("Breakpoints", 0,
"One or more breakpoints were not positioned on valid lines and were disabled");
}
/* called when bp are setting */
void hbpSetBP(void)
{
int xdr0 = 0, xdr1 = 0, xdr2 = 0, xdr3 = 0, xdr6 = 0, xdr7 = 0x0000;
int i, offset;
THREAD *t;
int flag = FALSE;
for (i = 0; i < 4; i++)
if (hdwebp[i].active)
{
if (!resolvenametoaddr(i, FALSE))
{
ExtendedMessageBox("Hardware Breakpoint", 0,
"Could not locate symbol %s, resetting hardware BP",
hdwebp[i].name);
hdwebp[i].active = FALSE;
}
}
{
// proj && (proj->buildFlags & BF_HWBP)) {
if ((hdwebp[0].active) && !hdwebp[0].disable)
{
xdr0 = hdwebp[0].address;
xdr7 |= 1+(((hdwebp[0].size << 2) + hdwebp[0].mode) << 16);
}
if ((hdwebp[1].active) && !hdwebp[1].disable)
{
xdr1 = hdwebp[1].address;
xdr7 |= 4+(((hdwebp[1].size << 2) + hdwebp[1].mode) << 20);
}
if ((hdwebp[2].active) && !hdwebp[2].disable)
{
xdr2 = hdwebp[2].address;
xdr7 |= 16+(((hdwebp[2].size << 2) + hdwebp[2].mode) << 24);
}
if ((hdwebp[3].active) && !hdwebp[3].disable)
{
xdr3 = hdwebp[3].address;
xdr7 |= 64+(((hdwebp[3].size << 2) + hdwebp[3].mode) << 28);
}
}
t = activeProcess->threads;
while (t)
{
t->regs.Dr0 = xdr0;
t->regs.Dr1 = xdr1;
t->regs.Dr2 = xdr2;
t->regs.Dr3 = xdr3;
t->regs.Dr6 = xdr6;
t->regs.Dr7 = xdr7;
t = t->next;
}
}
void ProjectNewFile(void)
{
PROJECTITEM *data = GetItemInfo(prjSelectedItem);
if (data && (data->type == PJ_PROJ || data->type == PJ_FOLDER))
{
if (DialogBox(hInstance, "IDD_NEWFILE", hwndFrame, (DLGPROC)NewFileProc) == IDOK)
{
char *p;
char buf[MAX_PATH];
PROJECTITEM *pj = data;
BOOL writeFile = FALSE;
FILE *fil;
while (pj->type == PJ_FOLDER)
pj = pj->parent;
strcpy(buf, pj->realName);
p = strrchr(buf, '\\');
if (!p)
p = buf;
else
p++;
strcpy(p, newTitle);
strcat(p, extensionMap[newMode][0]);
fil = fopen(buf, "rb");
if (fil)
{
if (ExtendedMessageBox("Add New File", MB_YESNO, "File exists. Overwrite?") == IDYES)
writeFile = TRUE;
}
else
{
writeFile = VerifyPath(buf);
}
if(writeFile)
{
if (!stricmp(p + strlen(p)-3,".rc"))
{
CreateNewResourceFile(data, buf, TRUE);
}
else
{
fil = fopen(buf,"wb");
if (fil)
fclose(fil);
AddFile(data, buf, TRUE);
}
}
}
}
}
void WriteBreakPoint(HANDLE hProcess, int address, int value)
{
int bf = value;
MEMORY_BASIC_INFORMATION mbi;
DWORD dwOldProtect;
// if (!IsNT() && address >= 0x80000000)
// return ;
if (!VirtualQueryEx(hProcess, (LPVOID)address, &mbi, sizeof(mbi)))
ExtendedMessageBox("Debugger", MB_SYSTEMMODAL, "Could not query pages %d",
GetLastError());
// the following fails on win98
VirtualProtectEx(hProcess, mbi.BaseAddress, mbi.RegionSize,
PAGE_EXECUTE_WRITECOPY, &mbi.Protect);
if (!WriteProcessMemory(hProcess, (LPVOID)address, (LPVOID) &bf, 1, 0))
ExtendedMessageBox("Debugger", MB_SYSTEMMODAL,
"Could not write breakpoint address %x %d", address, GetLastError())
;
VirtualProtectEx(hProcess, mbi.BaseAddress, mbi.RegionSize, mbi.Protect,
&dwOldProtect);
FlushInstructionCache(hProcess, (LPVOID)address, 1);
}
void fatal(char *fmt, ...)
{
char buf[256];
va_list argptr;
va_start(argptr, fmt);
#ifdef GUI
vsprintf(buf, fmt, argptr);
ExtendedMessageBox("Fatal RC File error", 0, buf);
#else
printf("Fatal error: ");
vprintf(fmt, argptr);
fputc('\n',stdout);
#endif
va_end(argptr);
longjmp(errjump,1);
}
/* called from int1 handler, returns true if a hardware breakpoint was triggered in the current task */
int hbpCheck(THREAD *tThread)
{
CONTEXT ctx;
if (!tThread)
return 0;
ctx.ContextFlags = CONTEXT_DEBUG_REGISTERS;
GetThreadContext(tThread->hThread, &ctx);
if (ctx.Dr6 &15)
{
int i;
for (i = 0; i < 4; i++)
if (ctx.Dr6 &(1 << i))
ExtendedMessageBox("Hardware Breakpoint", MB_SYSTEMMODAL |
MB_SETFOREGROUND, "Hardware breakpoint for %s triggered",
hdwebp[i].name);
}
return ctx.Dr6 &15;
}
static void StringTableDelete(struct resRes *stringTableData, int index)
{
if (index != -1)
{
int origIndex = index;
if (ExtendedMessageBox("String Delete", MB_OKCANCEL, "This will delete the string from the table") == IDOK)
{
STRINGS **p = &stringTableData->resource->u.stringtable;
for ( ; index && *p; index--, p = &(*p)->next);
if (*p)
{
STRINGS *old = *p;
// we don't need to free the data because it is on a heap that will be freed later
(*p) = (*p)->next;
ListView_DeleteItem(stringTableData->gd.childWindow, origIndex);
StringTableSetDeleted(stringTableData, origIndex, old);
}
}
}
}
static int ParseNewFileData(HWND hwnd)
{
int rv = 1;
GetWindowText(GetDlgItem(hwnd, IDC_FILENEWFILE), newTitle, sizeof(newTitle));
if (newTitle[0] == 0)
{
ExtendedMessageBox("Add New File", 0, "Please specify a new file name");
rv = 0;
}
else
{
LVITEM item;
memset(&item, 0, sizeof(item));
item.mask = LVIF_PARAM;
item.iItem = ListView_GetSelectionMark(GetDlgItem(hwnd, IDC_LVNEWFILE));
ListView_GetItem(GetDlgItem(hwnd, IDC_LVNEWFILE), &item);
newMode = item.lParam;
}
return rv;
}
void basicerror(int n, void *data)
/*
* standard routine for putting out an error
*/
{
char buf[512];
int errlvl;
;
errlvl = printerr(buf, n, data);
if (!(errlvl &1))
{
errline = lineno;
#ifdef GUI
ExtendedMessageBox("Fatal RC File error", 0, "Error %s(%d): %s", errfile, errlineno, buf);
#else
fprintf(stdout, "Error %s(%d): %s", errfile, errlineno, buf);
#endif
total_errors++;
}
if (total_errors)
{
longjmp(errjump,1);
}
}
LRESULT CALLBACK ProjectProc(HWND hwnd, UINT iMessage, WPARAM wParam,
LPARAM lParam)
{
int i;
RECT rs;
NM_TREEVIEW *nm;
DWINFO info;
LPNMTVKEYDOWN key;
PROJECTITEM *data;
TVHITTESTINFO hittest;
HWND win;
HTREEITEM oldSel;
static HCURSOR origCurs;
static BOOL dragging;
static BOOL inView;
static HTREEITEM srcItem, dstItem;
switch (iMessage)
{
LOGFONT lf;
case WM_SYSCOMMAND:
if (wParam == SC_CLOSE)
SendMessage(hwnd, WM_CLOSE, 0, 0);
break;
// case WM_SETTEXT:
// return SendMessage(hwndTab, iMessage, wParam, lParam);
case WM_LBUTTONDOWN:
case WM_RBUTTONDOWN:
SetFocus(hwnd);
break;
case WM_NOTIFY:
nm = (NM_TREEVIEW*)lParam;
switch (nm->hdr.code)
{
case NM_CUSTOMDRAW:
return CustomDraw(hwnd, (LPNMTVCUSTOMDRAW)nm);
case N_EDITDONE:
DoneRenaming();
break;
case TVN_BEGINDRAG:
GetCursorPos(&hittest.pt);
ScreenToClient(prjTreeWindow, &hittest.pt);
srcItem = TreeView_HitTest(prjTreeWindow, &hittest);
data = GetItemInfo(srcItem);
if (data && (data->type == PJ_FILE || data->type == PJ_FOLDER))
{
dragging = TRUE;
SetCapture(hwnd);
origCurs = SetCursor(dragCur);
inView = TRUE;
}
break;
case TVN_KEYDOWN:
key = (LPNMTVKEYDOWN)lParam;
switch (key->wVKey)
{
case VK_INSERT:
if (GetKeyState(VK_CONTROL) &0x80000000)
{
data = GetItemInfo(prjSelectedItem);
if (data)
{
int msg = -1;
switch (data->type)
{
case PJ_WS:
msg = IDM_EXISTINGPROJECT;
break;
case PJ_PROJ:
msg = IDM_NEWFOLDER;
break;
case PJ_FOLDER:
msg = IDM_EXISTINGFILE;
break;
}
if (msg != -1)
PostMessage(hwnd, WM_COMMAND, msg, 0);
}
}
else if (GetKeyState(VK_SHIFT) &0x80000000)
{
data = GetItemInfo(prjSelectedItem);
if (data)
{
int msg = -1;
switch (data->type)
{
case PJ_WS:
msg = IDM_NEWPROJECT;
break;
case PJ_PROJ:
msg = IDM_NEWFOLDER;
break;
case PJ_FOLDER:
msg = IDM_NEWFILE_P;
break;
}
if (msg != -1)
PostMessage(hwnd, WM_COMMAND, msg, 0);
}
}
else
{
data = GetItemInfo(prjSelectedItem);
if (data && (data->type != PJ_WS))
PostMessage(hwnd, WM_COMMAND, IDM_RENAME, 0);
}
break;
case VK_DELETE:
if (!(GetKeyState(VK_CONTROL) &0x80000000) && !(GetKeyState(VK_SHIFT) &0x8000000))
{
data = GetItemInfo(prjSelectedItem);
if (data && (data->type == PJ_FOLDER || data->type == PJ_FILE))
PostMessage(hwnd, WM_COMMAND, IDM_REMOVE, 0);
}
break;
case VK_RETURN:
SendMessage(hwnd, WM_COMMAND, IDM_OPENFILES, 0);
break;
}
break;
case NM_DBLCLK:
oldSel = prjSelectedItem;
GetCursorPos(&hittest.pt);
ScreenToClient(prjTreeWindow, &hittest.pt);
prjSelectedItem = TreeView_HitTest(prjTreeWindow, &hittest);
if (prjSelectedItem)
PostMessage(hwnd, WM_COMMAND, IDM_OPENFILES, 0);
prjSelectedItem = oldSel;
return 0;
case NM_RCLICK:
GetCursorPos(&hittest.pt);
ScreenToClient(prjTreeWindow, &hittest.pt);
prjSelectedItem = TreeView_HitTest(prjTreeWindow, &hittest);
if (prjSelectedItem)
{
TreeView_SelectItem(prjTreeWindow, prjSelectedItem);
}
CreateProjectMenu();
break;
case TVN_SELCHANGED:
nm = (NM_TREEVIEW*)lParam;
prjSelectedItem = nm->itemNew.hItem;
if (prjSelectedItem == 0)
prjSelectedItem = workArea->hTreeItem;
break;
case TVN_ITEMEXPANDED:
nm = (NM_TREEVIEW *)lParam;
data = GetItemInfo(nm->itemNew.hItem);
if (data)
{
if (data->type == PJ_FOLDER)
{
TV_ITEM setitem;
memset(&setitem, 0, sizeof(setitem));
setitem.mask = TVIF_IMAGE | TVIF_SELECTEDIMAGE;
setitem.iImage = setitem.iSelectedImage =
nm->action == TVE_EXPAND ? ilfolderOpen : ilfolderClose;
setitem.hItem = nm->itemNew.hItem;
TreeView_SetItem(prjTreeWindow, &setitem);
}
if (nm->action == TVE_EXPAND)
{
data->expanded = TRUE;
}
else
data->expanded = FALSE;
return 0;
}
break;
case TVN_DELETEITEM:
nm = (NM_TREEVIEW *)lParam;
if (nm->itemOld.hItem == prjSelectedItem)
prjSelectedItem = TreeView_GetSelection(prjTreeWindow);
break;
}
break;
case WM_COMMAND:
switch (LOWORD(wParam))
{
case ID_TBPROFILE:
if (HIWORD(wParam) == CBN_SELENDOK)
{
int i = SendMessage(hwndTbProfile, CB_GETCURSEL, 0 , 0);
if (i != CB_ERR)
{
if (i == 0)
{
strcpy(currentProfileName, sysProfileName);
}
else
{
PROFILENAMELIST *pf = profileNames;
while (pf && --i)
pf = pf->next;
if (pf)
{
strcpy(currentProfileName, pf->name);
}
}
MarkChanged(workArea, TRUE);
}
}
break;
case ID_TBBUILDTYPE:
if (HIWORD(wParam) == CBN_SELENDOK)
{
int i = SendMessage(hwndTbBuildType, CB_GETCURSEL, 0 , 0);
if (i != CB_ERR)
{
profileDebugMode = i == 0 ? 1 : 0;
MarkChanged(workArea, TRUE);
}
}
break;
case IDM_RESETPROFILECOMBOS:
{
HWND htemp;
PROFILENAMELIST *pf;
int selected,n;
int count;
POINT pt;
pf = profileNames;
selected = 0;
count = 0;
SendMessage(hwndTbProfile, CB_RESETCONTENT, 0, 0);
SendMessage(hwndTbProfile, CB_ADDSTRING, 0, (LPARAM)sysProfileName);
while (pf)
{
count++;
if (!strcmp(pf->name,currentProfileName))
selected = count;
SendMessage(hwndTbProfile, CB_ADDSTRING, 0, (LPARAM)pf->name);
pf = pf->next;
}
SendMessage(hwndTbProfile, CB_SETCURSEL, selected, 0);
SendMessage(hwndTbBuildType, CB_RESETCONTENT, 0, 0);
SendMessage(hwndTbBuildType, CB_ADDSTRING, 0, (LPARAM)"Debug");
SendMessage(hwndTbBuildType, CB_ADDSTRING, 0, (LPARAM)"Release");
SendMessage(hwndTbBuildType, CB_SETCURSEL, profileDebugMode ? 0 : 1, 0);
pt.x = 5;
pt.y = 5;
htemp = ChildWindowFromPoint(hwndTbProfile, pt);
SendMessage(htemp, EM_SETREADONLY, 1, 0);
htemp = ChildWindowFromPoint(hwndTbBuildType, pt);
SendMessage(htemp, EM_SETREADONLY, 1, 0);
EnableWindow(hwndTbProfile, TRUE);
EnableWindow(hwndTbBuildType, TRUE);
break;
}
case IDM_IMPORT_CWS:
ImportProject(FALSE);
break;
case IDM_IMPORT_CTG:
ImportProject(TRUE);
break;
case IDM_DOSWINDOW:
{
DosWindow(activeProject ? activeProject->realName : NULL, NULL, NULL, NULL, NULL);
}
break;
case IDM_MAKEWINDOW:
{
char exec[MAX_PATH];
sprintf(exec, "%s\\bin\\imake.exe", szInstallPath);
DosWindow(activeProject ? activeProject->realName : NULL, exec, "", "Custom Make", "Make Is Complete.");
}
break;
case IDM_RUN:
SaveWorkArea(workArea);
dbgRebuildMain(wParam);
break;
case IDM_SETACTIVEPROJECT:
ProjectSetActive();
break;
case IDM_NEWFILE_P:
ProjectNewFile();
PostMessage(hwndFrame, WM_REDRAWTOOLBAR, 0, 0);
break;
case IDM_EXISTINGFILE:
ProjectExistingFile();
PostMessage(hwndFrame, WM_REDRAWTOOLBAR, 0, 0);
break;
case IDM_NEWPROJECT:
ProjectNewProject();
PostMessage(hwndFrame, WM_REDRAWTOOLBAR, 0, 0);
break;
case IDM_EXISTINGPROJECT:
ProjectExistingProject();
PostMessage(hwndFrame, WM_REDRAWTOOLBAR, 0, 0);
break ;
case IDM_REMOVE:
ProjectRemove();
PostMessage(hwndFrame, WM_REDRAWTOOLBAR, 0, 0);
break;
case IDM_RENAME:
ProjectRename();
break;
case IDM_NEWFOLDER:
ProjectNewFolder();
PostMessage(hwndFrame, WM_REDRAWTOOLBAR, 0, 0);
break;
case IDM_NEWWS:
if (uState != notDebugging)
{
if (ExtendedMessageBox("WorkArea", MB_OKCANCEL,
"This action requires the debugger to be stopped.") != IDOK)
{
break;
}
abortDebug();
}
SelectWindow(DID_PROJWND);
ProjectNewWorkArea();
break;
case IDM_OPENWS:
if (uState != notDebugging)
{
if (ExtendedMessageBox("WorkArea", MB_OKCANCEL,
"This action requires the debugger to be stopped.") != IDOK)
{
break;
}
abortDebug();
}
SelectWindow(DID_PROJWND);
ProjectExistingWorkArea();
break;
case IDM_CLOSEWS:
if (making)
break;
if (uState != notDebugging)
{
if (ExtendedMessageBox("WorkArea", MB_OKCANCEL,
"This action requires the debugger to be stopped.") != IDOK)
{
break;
}
abortDebug();
}
CloseWorkArea();
break;
case IDM_SAVEWS:
SaveAllProjects(workArea, TRUE);
break;
case IDM_COMPILEFILEFROMTREE:
{
PROJECTITEM *data = GetItemInfo(prjSelectedItem);
if (data && data->type == PJ_FILE)
{
unlink(data->outputName);
Maker(data, TRUE);
}
}
break;
case IDM_COMPILEFILE:
win = (HWND)SendMessage(hwndClient, WM_MDIGETACTIVE, 0, 0);
if (IsWindow(win) && IsEditWindow(win))
{
HTREEITEM item = FindItemByWind(win);
PROJECTITEM *data = GetItemInfo(item);
if (data) {
unlink(data->outputName);
Maker(data, TRUE);
}
}
break;
case IDM_GENMAKE:
if (workArea && workArea->children)
{
genMakeFile(workArea);
}
else
{
ExtendedMessageBox("Makefile Generation", MB_SETFOREGROUND |
MB_SYSTEMMODAL,
"You need at least one project to generate a make file");
}
break;
case IDM_MAKE:
if (HIWORD(wParam))
if (GetKeyState(VK_CONTROL) &0x80000000)
SendMessage(hwnd, WM_COMMAND, IDM_COMPILEFILE, 0);
else if (GetKeyState(VK_SHIFT) &0x80000000)
Maker(activeProject, FALSE);
else
Maker(workArea, FALSE);
else
Maker(workArea, FALSE);
break;
case IDM_MAKE_RIGHTCLICK:
if (HIWORD(wParam))
if (GetKeyState(VK_CONTROL) &0x80000000)
SendMessage(hwnd, WM_COMMAND, IDM_COMPILEFILE, 0);
else if (GetKeyState(VK_SHIFT) &0x80000000)
Maker(activeProject, FALSE);
else
Maker(workArea, FALSE);
else
{
if (prjSelectedItem)
{
PROJECTITEM *data = GetItemInfo(prjSelectedItem);
if (data)
{
Maker(data, FALSE);
break;
}
}
Maker(workArea, FALSE);
}
break;
case IDM_BUILDALL:
Maker(workArea, TRUE);
break;
case IDM_BUILDALL_RIGHTCLICK:
if (prjSelectedItem)
{
PROJECTITEM *data = GetItemInfo(prjSelectedItem);
if (data)
{
Maker(data, TRUE);
break;
}
}
Maker(workArea, TRUE);
break;
case IDM_BUILDSELECTED:
Maker(activeProject, FALSE);
break;
case IDM_STOPBUILD:
StopBuild();
break;
case IDM_CALCULATEDEPENDS:
CalculateProjectDepends(GetItemInfo(prjSelectedItem));
break;
case IDM_RUNNODEBUG:
{
SaveWorkArea(workArea);
RunProgram(activeProject);
break;
}
case IDM_SELECTPROFILE:
SelectProfileDialog();
break;
case IDM_ACTIVEPROJECTPROPERTIES:
if (activeProject)
prjSelectedItem = activeProject->hTreeItem;
// fall through
case IDM_PROJECTPROPERTIES:
data = GetItemInfo(prjSelectedItem);
ShowBuildProperties(data);
break;
case IDM_PROJECTDEPENDS:
data = GetItemInfo(prjSelectedItem);
EditProjectDependencies(data);
break;
case IDM_OPENFILES:
data = GetItemInfo(prjSelectedItem);
if (data)
if (data->type == PJ_FILE)
{
if (strlen(data->realName) >= 3 && !stricmp(data->realName + strlen(data->realName) -3, ".rc"))
{
NavigateToResource(data);
}
else
{
strcpy(info.dwName, data->realName);
strcpy(info.dwTitle, data->displayName);
info.dwLineNo = - 1;
info.logMRU = FALSE;
info.newFile = FALSE;
CreateDrawWindow(&info, TRUE);
}
}
break;
case IDM_CLOSE:
SendMessage(hwnd, WM_CLOSE, 0, 0);
break;
default:
return DefWindowProc(hwnd, iMessage, wParam, lParam);
}
break;
case WM_LBUTTONUP:
if (dragging)
{
SetCursor(origCurs);
ReleaseCapture();
dragging = FALSE;
TreeView_SelectDropTarget(prjTreeWindow, NULL);
if (inView && dstItem != srcItem && srcItem && dstItem)
{
DragTo(dstItem, srcItem);
}
}
break;
case WM_MOUSEMOVE:
if (dragging)
{
hittest.pt.x = (long)(short)LOWORD(lParam);
hittest.pt.y = (long)(short)HIWORD(lParam);
dstItem = TreeView_HitTest(prjTreeWindow, &hittest);
if (dstItem && dstItem != srcItem)
{
PROJECTITEM *srcData = GetItemInfo(srcItem);
data = GetItemInfo(dstItem);
if (srcData && data)
{
PROJECTITEM *p = data->parent;
while (p)
if (p == srcData)
break;
else
p = p->parent;
if (p)
{
if (inView)
{
inView = FALSE;
SetCursor(noCur);
TreeView_SelectDropTarget(prjTreeWindow, NULL);
}
break;
}
}
if (data && (data->type == PJ_PROJ || data->type == PJ_FOLDER))
{
if (!inView)
{
inView = TRUE;
SetCursor(dragCur);
}
TreeView_SelectDropTarget(prjTreeWindow, dstItem);
}
else
{
if (inView)
{
inView = FALSE;
SetCursor(noCur);
TreeView_SelectDropTarget(prjTreeWindow, NULL);
}
}
}
else
{
if (inView)
{
inView = FALSE;
SetCursor(noCur);
TreeView_SelectDropTarget(prjTreeWindow, NULL);
}
}
}
break;
case WM_SETFOCUS:
PostMessage(hwndFrame, WM_REDRAWTOOLBAR, 0, 0);
SetFocus(prjTreeWindow);
break;
case WM_CREATE:
hwndProject = hwnd;
GetClientRect(hwnd, &rs);
treeViewSelected = 0;
dragCur = LoadCursor(hInstance, "ID_DRAGCUR");
noCur = LoadCursor(hInstance, "ID_NODRAGCUR");
folderClose = LoadBitmap(hInstance, "ID_FOLDERCLOSE");
folderOpen = LoadBitmap(hInstance, "ID_FOLDEROPEN");
treeIml = ImageList_Create(16, 16, ILC_COLOR24, IL_IMAGECOUNT+2, 0);
mainIml = LoadBitmap(hInstance, "ID_FILES");
ChangeBitmapColor(mainIml, 0xffffff, RetrieveSysColor(COLOR_WINDOW));
ImageList_Add(treeIml, mainIml, NULL);
ilfolderClose = ImageList_Add(treeIml, folderClose, 0);
ilfolderOpen = ImageList_Add(treeIml, folderOpen, 0);
DeleteObject(folderClose);
DeleteObject(folderOpen);
DeleteObject(mainIml);
prjTreeWindow = CreateWindowEx(0, sztreeDoubleBufferName, "", WS_VISIBLE |
WS_CHILD | TVS_HASLINES | TVS_LINESATROOT | TVS_HASBUTTONS | TVS_TRACKSELECT,
0, 0, rs.right, rs.bottom, hwnd, (HMENU)ID_TREEVIEW,
hInstance, NULL);
TreeView_SetImageList(prjTreeWindow, treeIml, TVSIL_NORMAL);
lf = systemDialogFont;
projFont = CreateFontIndirect(&lf);
lf.lfItalic = TRUE;
italicProjFont = CreateFontIndirect(&lf);
lf.lfItalic = FALSE;
lf.lfWeight = FW_BOLD;
boldProjFont = CreateFontIndirect(&lf);
SendMessage(prjTreeWindow, WM_SETFONT, (WPARAM)boldProjFont, 0);
return 0;
case WM_CLOSE:
SaveAllProjects(workArea, FALSE);
break;
case WM_DESTROY:
FreeSubTree(workArea, FALSE);
DestroyWindow(prjTreeWindow);
DeleteObject(projFont);
DeleteObject(boldProjFont);
DeleteObject(italicProjFont);
DestroyCursor(dragCur);
DestroyCursor(noCur);
hwndProject = 0;
break;
case WM_SIZE:
MoveWindow(prjTreeWindow, 0, 0, LOWORD(lParam), HIWORD(lParam), 0);
break;
default:
break;
}
return DefWindowProc(hwnd, iMessage, wParam, lParam);
}
void BrowseTo(HWND hwnd, char *msg)
{
static char name[256];
int ofs;
if (defaultWorkArea)
return ;
if (!browsing)
{
if (msg)
{
strcpy(name, msg);
browsing = TRUE;
}
else
browsing = SendMessage(hwnd, WM_WORDUNDERCURSOR, 0, (LPARAM)name);
if (!PropGetBool(NULL, "BROWSE_INFORMATION") && browsing)
{
ExtendedMessageBox("Browse Info Alert", MB_OK,
"Browse information not enabled");
browsing = FALSE;
return ;
}
}
else
{
SendMessage(hwnd, WM_WORDUNDERCURSOR, 0, (LPARAM)name);
}
if (browsing)
{
sqlite3 *db = NULL;
DWINFO info;
CHARRANGE charrange;
int curline;
char *filname;
PROJECTITEM *pj;
if (msg)
{
curline = - 2;
filname = "";
}
else
{
SendDlgItemMessage(hwnd, ID_EDITCHILD, EM_EXGETSEL, (WPARAM)0,
(LPARAM) &charrange);
curline = SendDlgItemMessage(hwnd, ID_EDITCHILD, EM_EXLINEFROMCHAR,
0, (LPARAM)charrange.cpMin) + 1;
filname = (char*)SendMessage(hwnd, WM_FILENAME, 0, 0);
}
memset(&info, 0, sizeof(info));
db = BrowseOpenDBByHWND(hwnd, &pj);
if (!db)
{
return ;
}
if (FindLine(db, filname, curline, name, info.dwName, &info.dwLineNo))
{
char *p = strrchr(info.dwName, '\\');
if (p)
strcpy(info.dwTitle, p + 1);
info.logMRU = FALSE;
info.newFile = FALSE;
InsertBrowse(name, curline);
CreateDrawWindow(&info, TRUE);
}
DBClose(db);
}
browsing = FALSE;
}
LRESULT CALLBACK WatchWndProc(HWND hwnd, UINT iMessage, WPARAM wParam,
LPARAM lParam)
{
WATCHDATA *ptr;
static POINT menupos;
static char buf[256];
RECT r, *pr;
WINDOWPOS wp;
HD_ITEM hie;
HD_LAYOUT hdl;
NMHDR *h;
DRAWITEMSTRUCT *dr;
HBITMAP hbmp;
HDC hMemDC;
TCHeader tch;
TV_ITEM item;
TV_INSERTSTRUCT t;
static int sizingbottom;
int offset;
DEBUG_INFO *dbg;
NM_TREEVIEW *nmt;
VARINFO *var;
HWND win;
int level;
int offset1;
int doit;
int i;
CHARRANGE charrange;
switch (iMessage)
{
case WM_SYSCOMMAND:
if (wParam == SC_CLOSE)
{
PostMessage(hwnd, WM_CLOSE, 0, 0);
return 0;
}
break;
case WM_NOTIFY:
ptr = (WATCHDATA *)GetWindowLong(hwnd, 0);
h = (NMHDR*)lParam;
switch (h->code)
{
case NM_RCLICK:
{
if (ptr->DID != DID_LOCALSWND)
{
HMENU menu = LoadMenuGeneric(hInstance, "WATCHMENU");
HMENU popup = GetSubMenu(menu, 0);
TV_HITTESTINFO t;
HTREEITEM titem;
GetCursorPos(&t.pt);
ScreenToClient(ptr->hwndWatchTree, &t.pt);
titem = TreeView_HitTest(ptr->hwndWatchTree, &t);
if (!titem || TreeView_GetParent(ptr->hwndWatchTree, titem))
{
EnableMenuItem(popup, IDM_DELETEWATCH, MF_GRAYED);
}
InsertBitmapsInMenu(popup);
GetCursorPos(&menupos);
TrackPopupMenuEx(popup, TPM_BOTTOMALIGN | TPM_LEFTBUTTON,
menupos.x, menupos.y, hwndFrame, NULL);
DestroyMenu(menu);
lastWatch = ptr->DID;
}
SetFocus(ptr->hwndWatchTree);
}
return 0;
case TVN_ITEMEXPANDING:
nmt = (LPNMTREEVIEW)h;
if (nmt->action)
{
ExpandPointer((VARINFO*)nmt->itemNew.lParam, nmt->action, ptr);
}
return 0;
case TCN_EDITQUERY:
nmt = (LPNMTREEVIEW)h;
item.mask = TVIF_PARAM;
item.hItem = (HTREEITEM)nmt->itemNew.hItem;
TreeView_GetItem(ptr->hwndWatchTree, &item);
var = (VARINFO*)item.lParam;
if (var->editable)
{
WatchValue(ptr->watchinfo_list[var->watchindex].dbg_info, buf,
var, TRUE);
return buf;
}
return 0;
case TCN_EDITDONE:
nmt = (LPNMTREEVIEW)h;
item.mask = TVIF_PARAM;
item.hItem = (HTREEITEM)nmt->itemNew.hItem;
TreeView_GetItem(ptr->hwndWatchTree, &item);
var = (VARINFO*)item.lParam;
ChangeData(var, nmt->itemNew.pszText, ptr);
RefreshItems(ptr);
return 0;
}
break;
case WM_CREATE:
ptr = (WATCHDATA *)calloc(sizeof(WATCHDATA),1);
SetWindowLong(hwnd, 0, (long)ptr);
GetClientRect(hwnd, &r);
tch.colText1 = "Item";
tch.colText2 = "Value";
tch.colBmp1 = itemBitmap;
tch.colBmp2 = valueBitmap;
ptr->hwndWatchTree = CreateextTreeWindow(hwnd, WS_DLGFRAME | TCS_LINE | WS_VISIBLE, &r, &tch);
return 0;
case WM_ADDWATCHINDIRECT:
ptr = (WATCHDATA *)GetWindowLong(hwnd, 0);
win = (HWND)wParam;
doit = FALSE;
SendMessage(win, EM_EXGETSEL, (WPARAM)0, (LPARAM) &charrange);
if (charrange.cpMin == charrange.cpMax)
{
doit = SendMessage(win, WM_WORDUNDERPOINT, (WPARAM)&rightclickPos, (LPARAM)buf);
if (!doit)
{
PostMessage(hwndFrame, WM_COMMAND, IDM_ADDWATCH, 0);
break;
}
}
else
{
if (charrange.cpMax - charrange.cpMin < sizeof(buf) ||charrange.cpMin - charrange.cpMax < sizeof(buf))
{
SendMessage(win, EM_GETSELTEXT, 0, (LPARAM)buf);
doit = TRUE ;
}
}
if (doit)
{
var = EvalExpr(&dbg, activeScope, (char*) buf, TRUE);
if (var)
{
AddItem(dbg, var, activeScope->address, ptr);
SelectWindow(ptr->DID);
break ;
}
}
ExtendedMessageBox("Error", MB_SETFOREGROUND |
MB_SYSTEMMODAL, "Symbol does not exist in this scope");
break;
case WM_ADDWATCH:
ptr = (WATCHDATA *)GetWindowLong(hwnd, 0);
offset = wParam;
if (!offset)
{
DeleteAllItems(ptr);
}
else
{
var = EvalExpr(&dbg, activeScope, (char*)
lParam, TRUE);
if (var)
{
AddItem(dbg, var, activeScope->address, ptr);
SelectWindow(ptr->DID);
}
}
break;
case WM_INITIALSTACK:
ptr = (WATCHDATA *)GetWindowLong(hwnd, 0);
ptr->refreshNeeded = TRUE;
break;
case WM_COMMAND:
ptr = (WATCHDATA *)GetWindowLong(hwnd, 0);
switch (wParam)
{
case ID_SETADDRESS:
if (ptr->DID == DID_LOCALSWND)
LoadLocals(ptr);
if (ptr->refreshNeeded)
ReloadVars(ptr);
else
RefreshItems(ptr);
ptr->refreshNeeded = FALSE;
InvalidateRect(ptr->hwndWatchTree, 0, 0);
break;
case IDM_DELETEWATCH:
DeleteItem(&menupos, ptr);
break;
case IDM_DELETEALLWATCH:
DeleteAllItems(ptr);
break;
}
break;
case WM_DESTROY:
ptr = (WATCHDATA *)GetWindowLong(hwnd, 0);
TreeView_DeleteAllItems(ptr->hwndWatchTree);
DestroyWindow(ptr->hwndWatchTree);
DeleteObject(valueBitmap);
DeleteObject(itemBitmap);
break;
case WM_SIZE:
ptr = (WATCHDATA *)GetWindowLong(hwnd, 0);
r.left = 0;
r.right = LOWORD(lParam);
r.top = 0;
r.bottom = HIWORD(lParam);
MoveWindow(ptr->hwndWatchTree, r.left, r.top, r.right - r.left, r.bottom -
r.top, 0);
return 0;
case WM_CLOSE:
break;
case WM_ACTIVATEME:
ptr = (WATCHDATA *)GetWindowLong(hwnd, 0);
if (ptr->DID != DID_LOCALSWND)
lastWatch = ptr->DID;
SendMessage(GetParent(hwnd), WM_ACTIVATEME, 0, 0);
break;
}
return DefWindowProc(hwnd, iMessage, wParam, lParam);
}
DWORD CALLBACK DosWindowThread(void *xx)
{
struct _varData *vdata = (struct _varData *)xx;
char *xcmd = GetCmd();
if (xcmd)
{
BOOL bSeenInitialBP = FALSE;
BOOL bContinue = TRUE;
DWORD dwContinueStatus;
BOOL bShownExitCode = FALSE;
DEBUG_EVENT stDE;
LPTCH env = GetEnv();
BOOL bRet;
STARTUPINFO stStartInfo;
PROCESS_INFORMATION stProcessInfo;
DWORD exitCode;
char wd[MAX_PATH], *p, cmd[MAX_PATH];
if (vdata->path)
{
strcpy(wd, vdata->path);
p = strrchr(wd, '\\');
if (p)
if (p[-1] == ':')
p[1] = 0;
else
p[0] = 0;
else
wd[0] = 0;
}
else
GetCurrentDirectory(sizeof(wd), wd);
if (vdata->exec)
{
sprintf(cmd,"\"%s\" %s", vdata->exec, vdata->args);
}
else
{
sprintf(cmd, "\"%s\"", xcmd);
}
memset(&stStartInfo, 0, sizeof(STARTUPINFO));
memset(&stProcessInfo, 0, sizeof(PROCESS_INFORMATION));
stStartInfo.cb = sizeof(STARTUPINFO);
bRet = CreateProcess(NULL, cmd, NULL, NULL, TRUE, DEBUG_PROCESS | DEBUG_ONLY_THIS_PROCESS | CREATE_NEW_CONSOLE, env,
wd, &stStartInfo, &stProcessInfo);
if (!bRet)
{
FreeEnv(env);
ExtendedMessageBox("Command Execution", MB_SETFOREGROUND | MB_SYSTEMMODAL,
"Could not execute %s.", cmd);
return 0;
}
ProcessToTop(stProcessInfo.dwProcessId);
while (TRUE == bContinue)
{
// Pause until a debug event notification happens.
bContinue = WaitForDebugEvent(&stDE, 500);
if (bContinue)
{
switch (stDE.dwDebugEventCode)
{
case CREATE_PROCESS_DEBUG_EVENT:
CloseHandle(stDE.u.CreateProcessInfo.hFile);
dwContinueStatus = DBG_CONTINUE;
break;
case CREATE_THREAD_DEBUG_EVENT:
case LOAD_DLL_DEBUG_EVENT:
case UNLOAD_DLL_DEBUG_EVENT:
case OUTPUT_DEBUG_STRING_EVENT:
case RIP_EVENT:
dwContinueStatus = DBG_CONTINUE;
break;
case EXIT_THREAD_DEBUG_EVENT:
// this catches the X button at the top right of the window.
// if it was pressed we do the dialog here to prevent the original window
// from auto-closing before we show it.
if (stDE.u.ExitThread.dwExitCode == STATUS_CONTROL_C_EXIT)
{
if (!bShownExitCode)
{
if (vdata->rvTitle)
{
ProcessToTop(stProcessInfo.dwProcessId);
ExtendedMessageBox(vdata->rvTitle, MB_SETFOREGROUND | MB_SYSTEMMODAL, vdata->rvBody, stDE.u.ExitProcess.dwExitCode);
bShownExitCode = TRUE;
}
}
}
dwContinueStatus = DBG_CONTINUE;
break;
case EXIT_PROCESS_DEBUG_EVENT:
if (!bShownExitCode)
{
if (vdata->rvTitle)
{
ProcessToTop(stProcessInfo.dwProcessId);
ExtendedMessageBox(vdata->rvTitle, MB_SETFOREGROUND | MB_SYSTEMMODAL, vdata->rvBody, stDE.u.ExitProcess.dwExitCode);
bShownExitCode = TRUE;
}
}
dwContinueStatus = DBG_CONTINUE;
bContinue = FALSE;
break;
case EXCEPTION_DEBUG_EVENT:
switch (stDE.u.Exception.ExceptionRecord.ExceptionCode)
{
default:
dwContinueStatus = DBG_EXCEPTION_NOT_HANDLED;
break;
case EXCEPTION_BREAKPOINT:
if (!bSeenInitialBP)
{
bSeenInitialBP = TRUE;
dwContinueStatus = DBG_CONTINUE;
}
else
{
dwContinueStatus = DBG_EXCEPTION_NOT_HANDLED;
}
break;
}
break;
// For any other events, just continue on.
default:
dwContinueStatus = DBG_EXCEPTION_NOT_HANDLED;
break;
}
}
else
{
dwContinueStatus = DBG_CONTINUE;
bContinue = TRUE;
}
// Pass on to the operating system.
ContinueDebugEvent(stDE.dwProcessId, stDE.dwThreadId, dwContinueStatus);
}
CloseHandle(stProcessInfo.hProcess);
CloseHandle(stProcessInfo.hThread);
FreeEnv(env);
}
free(vdata->rvTitle);
free(vdata->rvBody);
free(vdata->path);
free(vdata->exec);
free(vdata->args);
free(vdata);
return 0;
}
LRESULT CALLBACK WatchWndProc(HWND hwnd, UINT iMessage, WPARAM wParam,
LPARAM lParam)
{
static int selected;
static POINT menupos;
static char buf[256];
RECT r, *pr;
WINDOWPOS wp;
HD_ITEM hie;
HD_LAYOUT hdl;
NMHDR *h;
DRAWITEMSTRUCT *dr;
HBITMAP hbmp;
HDC hMemDC;
TCHeader tch;
TV_ITEM item;
TV_INSERTSTRUCT t;
static int sizingbottom;
int offset;
DEBUG_INFO *dbg;
NM_TREEVIEW *nmt;
VARINFO *var;
HWND win;
int level;
int offset1;
int doit;
int i;
CHARRANGE charrange;
switch (iMessage)
{
case WM_SYSCOMMAND:
if (wParam == SC_CLOSE)
{
PostMessage(hwnd, WM_CLOSE, 0, 0);
return 0;
}
break;
case WM_NOTIFY:
h = (NMHDR*)lParam;
switch (h->code)
{
case TABN_SELECTED:
{
LSTABNOTIFY *p = (LSTABNOTIFY *)h;
ShowWindow(hwndTree[selected], SW_HIDE);
for (i=0; i < 4; i++)
if (p->lParam == (LPARAM)hwndTree[i])
selected = i;
ShowWindow(hwndTree[selected], SW_SHOW);
break;
}
case NM_RCLICK:
{
HMENU menu = LoadMenuGeneric(hInstance, "WATCHMENU");
HMENU popup = GetSubMenu(menu, 0);
InsertBitmapsInMenu(popup);
GetCursorPos(&menupos);
TrackPopupMenuEx(popup, TPM_BOTTOMALIGN | TPM_LEFTBUTTON,
menupos.x, menupos.y, hwndFrame, NULL);
DestroyMenu(menu);
SetFocus(hwndTree[selected]);
}
return 0;
case TVN_ITEMEXPANDING:
nmt = h;
if (nmt->action)
{
ExpandPointer((VARINFO*)nmt->itemNew.lParam, nmt->action, selected);
}
return 0;
case TCN_EDITQUERY:
nmt = h;
item.mask = TVIF_PARAM;
item.hItem = (HTREEITEM)nmt->itemNew.hItem;
TreeView_GetItem(hwndTree[selected], &item);
var = (VARINFO*)item.lParam;
if (var->editable)
{
WatchValue(watchinfo_list[selected][var->watchindex].dbg_info, buf,
var, TRUE);
return buf;
}
return 0;
case TCN_EDITDONE:
nmt = h;
item.mask = TVIF_PARAM;
item.hItem = (HTREEITEM)nmt->itemNew.hItem;
TreeView_GetItem(hwndTree[selected], &item);
var = (VARINFO*)item.lParam;
ChangeData(var, nmt->itemNew.pszText, selected);
RefreshItems(selected);
return 0;
}
break;
case WM_CREATE:
hwndWatch = hwnd;
GetClientRect(hwnd, &r);
valueBitmap = LoadImage(hInstance, "ID_VALUEBMP", IMAGE_BITMAP, 0, 0, LR_LOADMAP3DCOLORS);
itemBitmap = LoadImage(hInstance, "ID_ITEMBMP", IMAGE_BITMAP, 0, 0, LR_LOADMAP3DCOLORS);
tch.colText1 = "Item";
tch.colText2 = "Value";
tch.colBmp1 = itemBitmap;
tch.colBmp2 = valueBitmap;
hwndTabCtrl = CreateLsTabWindow(hwnd, TABS_BOTTOM | TABS_HOTTRACK | TABS_FLAT | WS_VISIBLE);
tabNormalFont = CreateFontIndirect(&tabFontData);
SendMessage(hwndTabCtrl, WM_SETFONT, (WPARAM)tabNormalFont, 0);
r.bottom -= 25;
for (i=3; i >0 ; i--)
hwndTree[i] = CreateextTreeWindow(hwnd, WS_DLGFRAME | TCS_LINE, &r, &tch);
hwndTree[0] = CreateextTreeWindow(hwnd, WS_DLGFRAME | TCS_LINE | WS_VISIBLE, &r, &tch);
for (i=3; i >=0 ; i--)
SendMessage(hwndTabCtrl, TABM_ADD, (WPARAM)nameTags[i], (LPARAM)hwndTree[i]);
return 0;
case WM_ADDWATCHINDIRECT:
win = (HWND)wParam;
doit = FALSE;
SendMessage(win, EM_EXGETSEL, (WPARAM)0, (LPARAM) &charrange);
if (charrange.cpMin == charrange.cpMax)
{
doit = SendMessage(win, WM_WORDUNDERPOINT, (WPARAM)&rightclickPos, (LPARAM)buf);
if (!doit)
{
SendMessage(hwndFrame, IDM_ADDWATCH, 0, 0);
break;
}
}
else
{
if (charrange.cpMax - charrange.cpMin < sizeof(buf))
{
SendMessage(win, EM_GETSELTEXT, 0, (LPARAM)buf);
doit = TRUE ;
}
}
if (doit)
{
var = EvalExpr(&dbg, activeScope, (char*) buf, TRUE);
if (var)
{
AddItem(dbg, var, activeScope->address, selected);
dmgrHideWindow(DID_WATCHWND, FALSE);
break ;
}
}
ExtendedMessageBox("Error", MB_SETFOREGROUND |
MB_SYSTEMMODAL, "Symbol does not exist in this scope");
break;
case WM_ADDWATCH:
offset = wParam;
if (!offset)
{
DeleteAllItems(selected);
}
else
{
var = EvalExpr(&dbg, activeScope, (char*)
lParam, TRUE);
if (var)
{
AddItem(dbg, var, activeScope->address, selected);
dmgrHideWindow(DID_WATCHWND, FALSE);
}
}
break;
case WM_COMMAND:
switch (wParam)
{
case ID_SETADDRESS:
for (i=3; i >=0; i--)
RefreshItems(i);
InvalidateRect(hwndTree[selected], 0, 0);
break;
case IDM_DELETEWATCH:
DeleteItem(&menupos, selected);
break;
case IDM_DELETEALLWATCH:
DeleteAllItems(selected);
break;
}
break;
case WM_DESTROY:
for (i=3; i >=0 ; i--)
TreeView_DeleteAllItems(hwndTree[i]);
for (i=3; i >=0 ; i--)
DestroyWindow(hwndTree[i]);
DeleteObject(valueBitmap);
DeleteObject(itemBitmap);
hwndWatch = 0;
break;
case WM_SIZE:
r.left = 0;
r.right = LOWORD(lParam);
r.top = 0;
r.bottom = HIWORD(lParam);
MoveWindow(hwndTabCtrl, r.left, r.bottom - 24, r.right - r.left, 24, 1);
for (i=3; i >=0 ; i--)
MoveWindow(hwndTree[i], r.left, r.top, r.right - r.left, r.bottom -
r.top - 25, 0);
return 0;
case WM_CLOSE:
break;
case WM_ACTIVATEME:
SendMessage(GetParent(hwnd), WM_ACTIVATEME, 0, 0);
break;
}
return DefWindowProc(hwnd, iMessage, wParam, lParam);
}
void RestoreProject(PROJECTITEM *project, BOOL loadWA)
{
int projectVersion;
struct xmlNode *root;
struct xmlNode *children;
struct xmlAttr *attribs;
FILE *in;
char name[MAX_PATH];
sprintf(name, "%s.cpj", project->realName);
in = fopen(name, "r");
if (!in)
{
ExtendedMessageBox("Load Error", MB_SETFOREGROUND | MB_SYSTEMMODAL,
"Project File %s Not Found",project->displayName);
strcat(project->displayName, " (unable to load)");
return;
}
root = xmlReadFile(in);
fclose(in);
if (!root || !IsNode(root, "CC386PROJECT"))
{
LoadErr(root, project->displayName);
strcat(project->displayName, " (unable to load)");
return;
}
if (loadWA)
{
children = root->children;
while (children)
{
if (IsNode(children, "WORKAREA"))
{
attribs = children->attribs;
while (attribs)
{
if (IsAttrib(attribs, "NAME"))
{
LoadWorkArea(attribs->value, TRUE);
return;
}
attribs = attribs->next;
}
}
children = children->next;
}
}
children = root->children;
while (children)
{
if (IsNode(children, "VERSION"))
{
attribs = children->attribs;
while (attribs)
{
if (IsAttrib(attribs, "ID"))
projectVersion = atoi(attribs->value);
attribs = attribs->next;
}
}
else if (IsNode(children, "TARGET"))
{
struct xmlNode *settings = children->children;
attribs = children->attribs;
while (attribs)
{
if (IsAttrib(attribs, "TITLE"))
{
strcpy(project->displayName, attribs->value);
}
attribs = attribs->next;
}
while (settings)
{
if (IsNode(settings, "FILES"))
{
RestoreFiles(settings->children, project, project);
}
if (IsNode(settings, "PROPERTIES"))
{
RestoreProps(settings->children, project, project);
}
settings = settings->next;
}
}
children = children->next;
}
xmlFree(root);
CalculateProjectDepends(project);
project->loaded = TRUE;
}
