Ekdohibs
/
ocaml
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
ocaml/win32caml/ocaml.c

1600 lines
47 KiB
C
Raw Blame History

/* */
/* Objective Caml */
/* */
/* Developed by Jacob Navia. */
/* Copyright 2001 Institut National de Recherche en Informatique et */
/* en Automatique. All rights reserved. This file is distributed */
/* under the terms of the GNU Library General Public License, with */
/* the special exception on linking described in file ../LICENSE. */
/* */
/***********************************************************************/
/***********************************************************************/
/* Changes made by Chris Watford to enhance the source editor */
/* Began 14 Sept 2003 - watford@uiuc.edu */
/***********************************************************************/
/* $Id$ */
/*@@ Wedit generated application. Written Sat Jun 02 18:22:38 2001
@@header: D:\lcc\inria\inriares.h
@@resources: D:\lcc\inria\inria.rc
Do not edit outside the indicated areas */
/*<---------------------------------------------------------------------->*/
#include <stdio.h>
#include <windows.h>
#include <windowsx.h>
#include <commctrl.h>
#include <string.h>
#include <direct.h>
#include <Richedit.h>
#include "inriares.h"
#include "inria.h"
#define VK_BACKSPACE 0x108
/*<---------------------------------------------------------------------->*/
int EditControls = IDEDITCONTROL;
static WNDPROC lpEProc;
static char lineBuffer[1024*32];
int ReadToLineBuffer(void);
int AddLineBuffer(void);
static int busy;
static DWORD TimerId;
POSITION LastPromptPosition;
char LibDir[512];
char OcamlPath[512];
HBRUSH BackgroundBrush;
COLORREF BackColor = RGB(255,255,255);
PROGRAM_PARAMS ProgramParams;
StatementHistory *History = NULL;
StatementHistory *HistoryTail = NULL;
StatementHistory *historyEntry = NULL;
EditBuffer *CurrentEditBuffer = NULL; // current edit buffer
/*<----------------- global variables --------------------------------------->*/
HANDLE hInst; // Instance handle
HWND hwndMain; //Main window handle
HWND hwndSession;
HWND hwndMDIClient; //Mdi client window handle
static LRESULT CALLBACK MainWndProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam);
static LRESULT CALLBACK MdiChildWndProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam);
PROCESS_INFORMATION pi;
HWND hWndStatusbar;
/*------------------------------------------------------------------------
Procedure: UpdateStatusBar ID:1
Purpose: Updates the statusbar control with the appropiate
text
Input: lpszStatusString: Charactar string that will be shown
partNumber: index of the status bar part number.
displayFlags: Decoration flags
Output: none
Errors: none
------------------------------------------------------------------------*/
void UpdateStatusBar(LPSTR lpszStatusString, WORD partNumber, WORD displayFlags)
{
SendMessage(hWndStatusbar,
SB_SETTEXT,
partNumber | displayFlags,
(LPARAM)lpszStatusString);
}
/*------------------------------------------------------------------------
Procedure: MsgMenuSelect ID:1
Purpose: Shows in the status bar a descriptive explaation of
the purpose of each menu item.The message
WM_MENUSELECT is sent when the user starts browsing
the menu for each menu item where the mouse passes.
Input: Standard windows.
Output: The string from the resources string table is shown
Errors: If the string is not found nothing will be shown.
------------------------------------------------------------------------*/
LRESULT MsgMenuSelect(HWND hwnd, UINT uMessage, WPARAM wparam, LPARAM lparam)
{
static char szBuffer[256];
UINT nStringID = 0;
UINT fuFlags = GET_WM_MENUSELECT_FLAGS(wparam, lparam) & 0xffff;
UINT uCmd = GET_WM_MENUSELECT_CMD(wparam, lparam);
HMENU hMenu = GET_WM_MENUSELECT_HMENU(wparam, lparam);
szBuffer[0] = 0; // First reset the buffer
if (fuFlags == 0xffff && hMenu == NULL) // Menu has been closed
nStringID = 0;
else if (fuFlags & MFT_SEPARATOR) // Ignore separators
nStringID = 0;
else if (fuFlags & MF_POPUP) // Popup menu
{
if (fuFlags & MF_SYSMENU) // System menu
nStringID = IDS_SYSMENU;
else
// Get string ID for popup menu from idPopup array.
nStringID = 0;
} // for MF_POPUP
else // Must be a command item
nStringID = uCmd; // String ID == Command ID
// Load the string if we have an ID
if (0 != nStringID)
LoadString(hInst, nStringID, szBuffer, sizeof(szBuffer));
// Finally... send the string to the status bar
UpdateStatusBar(szBuffer, 0, 0);
return 0;
}
/*------------------------------------------------------------------------
Procedure: TimerProc ID:1
Purpose: This procedure will be called by windows about 4
times a second. It will just send a message to the
mdi child window to look at the pipe.
Input:
Output:
Errors:
------------------------------------------------------------------------*/
static VOID CALLBACK TimerProc(HWND hwnd, UINT uMsg, UINT idEvent, DWORD dwTime)
{
SendMessage(hwndSession, WM_TIMERTICK, 0, 0);
}
/*------------------------------------------------------------------------
Procedure: InitializeStatusBar ID:1
Purpose: Initialize the status bar
Input: hwndParent: the parent window
nrOfParts: The status bar can contain more than one
part. What is difficult, is to figure out how this
should be drawn. So, for the time being only one is
being used...
Output: The status bar is created
Errors:
------------------------------------------------------------------------*/
void InitializeStatusBar(HWND hwndParent,int nrOfParts)
{
const int cSpaceInBetween = 8;
int ptArray[40]; // Array defining the number of parts/sections
RECT rect;
HDC hDC;
/* * Fill in the ptArray... */
hDC = GetDC(hwndParent);
GetClientRect(hwndParent, &rect);
ptArray[nrOfParts-1] = rect.right;
//---TODO--- Add code to calculate the size of each part of the status
// bar here.
ReleaseDC(hwndParent, hDC);
SendMessage(hWndStatusbar,
SB_SETPARTS,
nrOfParts,
(LPARAM)(LPINT)ptArray);
UpdateStatusBar("Ready", 0, 0);
}
/*------------------------------------------------------------------------
Procedure: CreateSBar ID:1
Purpose: Calls CreateStatusWindow to create the status bar
Input: hwndParent: the parent window
initial text: the initial contents of the status bar
Output:
Errors:
------------------------------------------------------------------------*/
static BOOL CreateSBar(HWND hwndParent,char *initialText,int nrOfParts)
{
hWndStatusbar = CreateStatusWindow(WS_CHILD | WS_VISIBLE | WS_BORDER|SBARS_SIZEGRIP,
initialText,
hwndParent,
IDM_STATUSBAR);
if(hWndStatusbar)
{
InitializeStatusBar(hwndParent,nrOfParts);
return TRUE;
}
return FALSE;
}
/*------------------------------------------------------------------------
Procedure: InitApplication ID:1
Purpose: Registers two window classes: the "inria" window
class with the main window, and the mdi child
window's window class.
Input:
Output:
Errors:
------------------------------------------------------------------------*/
static BOOL InitApplication(void)
{
WNDCLASS wc;
memset(&wc,0,sizeof(WNDCLASS));
wc.style = CS_HREDRAW|CS_VREDRAW |CS_DBLCLKS ;
wc.lpfnWndProc = (WNDPROC)MainWndProc;
wc.hInstance = hInst;
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
wc.lpszClassName = "inriaWndClass";
wc.lpszMenuName = MAKEINTRESOURCE(IDMAINMENU);
wc.hCursor = LoadCursor(NULL,IDC_ARROW);
wc.hIcon = LoadIcon(hInst,MAKEINTRESOURCE(OCAML_ICON));
if (!RegisterClass(&wc))
return 0;
wc.style = 0;
wc.lpfnWndProc = (WNDPROC)MdiChildWndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 20;
wc.hInstance = hInst; // Owner of this class
wc.hIcon = LoadIcon(hInst, MAKEINTRESOURCE(OCAML_ICON));
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1); // Default color
wc.lpszMenuName = NULL;
wc.lpszClassName = "MdiChildWndClass";
if (!RegisterClass((LPWNDCLASS)&wc))
return FALSE;
return 1;
}
/*------------------------------------------------------------------------
Procedure: CreateinriaWndClassWnd ID:1
Purpose: Creates the main window
Input:
Output:
Errors:
------------------------------------------------------------------------*/
HWND CreateinriaWndClassWnd(void)
{
return CreateWindow("inriaWndClass","OCamlWinPlus v1.9RC4",
WS_MINIMIZEBOX|WS_VISIBLE|WS_CLIPSIBLINGS|WS_CLIPCHILDREN|WS_MAXIMIZEBOX|WS_CAPTION|WS_BORDER|WS_SYSMENU|WS_THICKFRAME,
CW_USEDEFAULT,0,CW_USEDEFAULT,0,
NULL,
NULL,
hInst,
NULL);
}
/*------------------------------------------------------------------------
Procedure: MDICmdFileNew ID:1
Purpose: Creates a new session window. Note that multiple
windows with multiple sessions are possible.
Input:
Output:
Errors:
------------------------------------------------------------------------*/
static HWND MDICmdFileNew(char *title, int show)
{
HWND hwndChild;
char rgch[150];
static int cUntitled;
MDICREATESTRUCT mcs;
if (title == NULL)
wsprintf(rgch,"Session%d", cUntitled++);
else {
strncpy(rgch,title,149);
rgch[149] = 0;
}
// Create the MDI child window
mcs.szClass = "MdiChildWndClass"; // window class name
mcs.szTitle = rgch; // window title
mcs.hOwner = hInst; // owner
mcs.x = CW_USEDEFAULT; // x position
mcs.y = CW_USEDEFAULT; // y position
mcs.cx = CW_USEDEFAULT; // width
mcs.cy = CW_USEDEFAULT; // height
mcs.style = 0; // window style
mcs.lParam = 0; // lparam
hwndChild = (HWND) SendMessage(hwndMDIClient,
WM_MDICREATE,
0,
(LPARAM)(LPMDICREATESTRUCT) &mcs);
if (hwndChild != NULL && show)
ShowWindow(hwndChild, SW_SHOW);
return hwndChild;
}
static HWND CreateMdiClient(HWND hwndparent)
{
CLIENTCREATESTRUCT ccs = {0};
HWND hwndMDIClient;
int icount = GetMenuItemCount(GetMenu(hwndparent));
// Find window menu where children will be listed
ccs.hWindowMenu = GetSubMenu(GetMenu(hwndparent), icount-2);
ccs.idFirstChild = IDM_WINDOWCHILD;
// Create the MDI client filling the client area
hwndMDIClient = CreateWindow("mdiclient",
NULL,
WS_CHILD | WS_CLIPCHILDREN | WS_VSCROLL |
WS_HSCROLL,
0, 0, 0, 0,
hwndparent,
(HMENU)0xCAC,
hInst,
(LPVOID)&ccs);
ShowWindow(hwndMDIClient, SW_SHOW);
return hwndMDIClient;
}
void GotoEOF(void)
{
HWND hEdit = (HWND)GetWindowLongPtr(hwndSession,DWLP_USER);
int linesCount = SendMessage(hEdit,EM_GETLINECOUNT,0,0);
int lineindex = SendMessage(hEdit,EM_LINEINDEX,linesCount-1,0);
int lastLineLength = SendMessage(hEdit,EM_LINELENGTH,linesCount-1,0);
lineindex += lastLineLength;
SendMessage(hEdit,EM_SETSEL,lineindex,lineindex);
}
/*------------------------------------------------------------------------
Procedure: GotoPrompt ID:1
Author: Chris Watford watford@uiuc.edu
Purpose: Puts the cursor on the prompt line right after the '# '
Input:
Output:
Errors:
------------------------------------------------------------------------*/
void GotoPrompt(void)
{
HWND hEdit = (HWND)GetWindowLongPtr(hwndSession,DWLP_USER);
int lineindex = SendMessage(hEdit,EM_LINEINDEX,LastPromptPosition.line,0)+2;
SendMessage(hEdit,EM_SETSEL,lineindex,lineindex);
}
int GetCurLineIndex(HWND hEdit)
{
return SendMessage(hEdit,EM_LINEFROMCHAR,(WPARAM)-1,0);
}
int GetNumberOfLines(HWND hEdit)
{
return SendMessage(hEdit,EM_GETLINECOUNT,0,0);
}
static int GetWordUnderCursor(HWND hwndEditControl,char *buf,int len)
{
char *line,*p,*pstart,*pend;
int lineidx,start,end,length,offset,cursorpos,startingChar;
SendMessage(hwndEditControl,EM_GETSEL,(WPARAM)&start,(LPARAM)&end);
lineidx = SendMessage(hwndEditControl,EM_EXLINEFROMCHAR,0,start);
startingChar = SendMessage(hwndEditControl,EM_LINEINDEX,lineidx,0);
start -= startingChar;
end -= startingChar;
lineidx = SendMessage(hwndEditControl,EM_LINEFROMCHAR,start,0);
length = SendMessage(hwndEditControl,EM_LINELENGTH,lineidx,0);
offset = SendMessage(hwndEditControl,EM_LINEINDEX,lineidx,0);
line = SafeMalloc(length+1);
memset(line,0,length+1);
*(unsigned short *)line = length;
SendMessage(hwndEditControl,EM_GETLINE,lineidx,(LPARAM)line);
cursorpos = start-offset;
p = line + cursorpos;
pstart = p;
while (*pstart
&& *pstart != ' '
&& *pstart != '\t'
&& *pstart != '('
&& pstart > line)
pstart--;
pend = p;
while (*pend
&& *pend != ' '
&& *pend != '\t'
&& *pend != '('
&& pend < line + length)
pend++;
if (*pstart == ' ' || *pstart == '\t')
pstart++;
if (*pend == ' ' || *pend == '\t')
pend--;
memcpy(buf,pstart,1+pend-pstart);
buf[pend-pstart] = 0;
free(line);
return 1;
}
/*------------------------------------------------------------------------
Procedure: GetLastLine ID:1
Purpose: Gets the data in the line containing the cursor to
the interpreter.
Input: The edit control window handle
Output: None explicit
Errors: None
------------------------------------------------------------------------*/
char* GetLastLine(HWND hEdit)
{
int curline = GetCurLineIndex(hEdit);
char *linebuffer = (char*)SafeMalloc(2048*sizeof(char));
int n;
int linescount = GetNumberOfLines(hEdit);
*(unsigned short *)linebuffer = 2047;
n = SendMessage(hEdit,EM_GETLINE,curline,(LPARAM)linebuffer);
if (n >= 2 && linebuffer[0] == '#' && linebuffer[1] == ' ') {
n -= 2;
memmove(linebuffer, linebuffer+2, n);
}
linebuffer[n] = '\0';
return linebuffer;
}
void DoHelp(HWND hwnd)
{
char word[256];
GetWordUnderCursor(hwnd,word,sizeof(word));
MessageBox(NULL,word,"Aide pour:",MB_OK);
}
/*------------------------------------------------------------------------
Procedure: RewriteCurrentEditBuffer ID:1
Purpose: Rewrites what is at the prompt with the current contents of
the edit buffer
Input: None
Output: None explicit
Errors: None
------------------------------------------------------------------------*/
void RewriteCurrentEditBuffer(void)
{
// get the editbox's handle
HWND hEdit = (HWND)GetWindowLongPtr(hwndSession,DWLP_USER);
// calculate what to highlight
int linesCount = SendMessage(hEdit,EM_GETLINECOUNT,0,0);
int lineindex = SendMessage(hEdit,EM_LINEINDEX,LastPromptPosition.line,0) + 2;
int lastLine = SendMessage(hEdit,EM_LINEINDEX,linesCount-1,0) + SendMessage(hEdit,EM_LINELENGTH,linesCount-1,0) + 100;
// delete the current text
SendMessage(hEdit, EM_SETSEL, (WPARAM)lineindex, (LPARAM)lastLine);
SendMessage(hEdit, EM_REPLACESEL, (WPARAM)TRUE, (LPARAM)"");
{
// loop through each line in the edit buffer and add it to the control
LineList* line = CurrentEditBuffer->Lines;
for(; line != NULL; line = line->Next)
{
// if there is a line before me, add a newline
if(line->Prev != NULL)
SendMessage(hEdit, EM_REPLACESEL, (WPARAM)TRUE, (LPARAM)"\r\n");
// add the line
SendMessage(hEdit, EM_REPLACESEL, (WPARAM)TRUE, (LPARAM)line->Text);
}
}
}
/*------------------------------------------------------------------------
Procedure: RefreshCurrentEditBuffer ID:1
Purpose: Rewrites what is in the CurrentEditBuffer with what is
actually there
Input: None
Output: None explicit
Errors: None
------------------------------------------------------------------------*/
void RefreshCurrentEditBuffer(void)
{
// get the editbox's handle
HWND hEdit = (HWND)GetWindowLongPtr(hwndSession,DWLP_USER);
// get the last line index
int linesCount = SendMessage(hEdit,EM_GETLINECOUNT,0,0) - 1;
int i = 0, n = 0;
// where to hold the line we grab
char *linebuffer = (char*)SafeMalloc(2048*sizeof(char));
*(unsigned short *)linebuffer = 2047;
editbuffer_destroy(CurrentEditBuffer);
CurrentEditBuffer = editbuffer_new();
// loop through each line updating or adding it to the current edit buffer
for( ; (i + LastPromptPosition.line) <= linesCount; i++)
{
n = SendMessage(hEdit, EM_GETLINE, (i + LastPromptPosition.line), (LPARAM)linebuffer);
if ((n >= 2) && (linebuffer[0] == '#') && (linebuffer[1] == ' ')) {
n -= 2;
memmove(linebuffer, linebuffer+2, n);
}
linebuffer[n] = '\0';
{ // remove line breaks and feeds
char* ln = linebuffer;
while((*ln) != 0)
{
switch((*ln))
{
case '\r':
case '\n':
(*ln) = ' ';
}
ln++;
}
}
editbuffer_addline(CurrentEditBuffer, linebuffer);
}
}
/*------------------------------------------------------------------------
Procedure: NextHistoryEntry ID:1
Purpose: Scrolls to the next history entry
Input: None
Output: None explicit
Errors: None
--------------------------------------------------------------------------
Edit History:
17 Sept 2003 - Chris Watford watford@uiuc.edu
- Added this as a helper function
18 Sept 2003 - Chris Watford watford@uiuc.edu
- Corrected doubly linked list problems
------------------------------------------------------------------------*/
void NextHistoryEntry(void)
{
// out of bounds, put it back into bounds
if(historyEntry == NULL && History == NULL)
{
return;
} else if (historyEntry == NULL && History != NULL) {
historyEntry = History;
} else {
if(historyEntry->Next == NULL)
return;
historyEntry = historyEntry->Next;
}
// if its valid
if(historyEntry != NULL)
{
// copy the history entry to a new buffer
EditBuffer* newBuf = editbuffer_copy(historyEntry->Statement);
// destroy the old buffer
editbuffer_destroy(CurrentEditBuffer);
// setup the current one to the copy
CurrentEditBuffer = newBuf;
// rewrite the old one and go to the prompt
RewriteCurrentEditBuffer();
GotoPrompt();
}
}
/*------------------------------------------------------------------------
Procedure: PrevHistoryEntry ID:1
Purpose: Scrolls to the previous history entry
Input: None
Output: None explicit
Errors: None
--------------------------------------------------------------------------
Edit History:
17 Sept 2003 - Chris Watford watford@uiuc.edu
- Added this as a helper function
18 Sept 2003 - Chris Watford watford@uiuc.edu
- Corrected doubly linked list problems
------------------------------------------------------------------------*/
void PrevHistoryEntry(void)
{
// out of bounds, put it back into bounds
if(historyEntry == NULL || History == NULL)
{
return;
} else {
if(historyEntry->Prev == NULL)
return;
historyEntry = historyEntry->Prev;
}
// if its valid
if(historyEntry != NULL)
{
// copy the history entry to a new buffer
EditBuffer* newBuf = editbuffer_copy(historyEntry->Statement);
// destroy the old buffer
editbuffer_destroy(CurrentEditBuffer);
// setup the current one to the copy
CurrentEditBuffer = newBuf;
// rewrite the old one and go to the prompt
RewriteCurrentEditBuffer();
GotoPrompt();
}
}
/*------------------------------------------------------------------------
Procedure: SubClassEdit ID:1
Purpose: Handles messages to the editbox
Input:
Output:
Errors:
--------------------------------------------------------------------------
Edit History:
14 Sept 2003 - Chris Watford watford@uiuc.edu
- Setup handler for up and down arrows
15 Sept 2003 - Chris Watford watford@uiuc.edu
- Setup framework for history on up arrow
- Saves lines you move off of in the edit buffer
16 Sept 2003 - Chris Watford watford@uiuc.edu
- Proper handling of newline message finished
- Fixed ENTER on middle of interior line, moves cursor to the end
and sends the line
- Setup the copying and destroying of the old buffer
- Included buffer rewrite
17 Sept 2003 - Chris Watford watford@uiuc.edu
- Added C-p/C-n support
- Changed UpArrow to C-UpArrow so as to not confuse users
18 Sept 2003 - Chris Watford watford@uiuc.edu
- Added Left and Right arrow line saving
- Added backspace and delete line saving and removing
- Fixed history scrolling
21 Sept 2003 - Chris Watford watford@uiuc.edu
- Fixed pasting errors associated with lines being out of bounds
for the buffer
- Added error handling, possibly able to handle it diff down the
line
- Removed C-Up/C-Dn for history scrolling, buggy at best on my
machine
------------------------------------------------------------------------*/
static LRESULT CALLBACK SubClassEdit(HWND hwnd, UINT msg, WPARAM mp1, LPARAM mp2)
{
LRESULT r;
int postit=0,nl;
if (msg == WM_CHAR && mp1 == '\r') {
if (!busy) {
r = GetCurLineIndex(hwnd);
nl = GetNumberOfLines(hwnd);
// if we're not the last line
if (r != nl-1)
{
// update or add us, we might not have any lines in the edit buffer
editbuffer_updateoraddline(CurrentEditBuffer, r-LastPromptPosition.line, GetLastLine(hwnd));
// scroll to the end, add CrLf then post the newline message
GotoEOF();
AddStringToControl("\r\n");
PostMessage(GetParent(hwnd),WM_NEWLINE,0,0);
return 0;
}
CallWindowProc(lpEProc,hwnd,WM_KEYDOWN,VK_END,1);
CallWindowProc(lpEProc,hwnd,WM_KEYUP,VK_END,1);
postit = 1;
}
}
else if (msg == WM_CHAR && mp1 == (char)0x08) {
int lineindex = SendMessage(hwnd, EM_LINEINDEX, LastPromptPosition.line, 0) + 2;
int curline = SendMessage(hwnd,EM_LINEFROMCHAR,(WPARAM)-1,0);
int nextline = 0;
int curpoint = 0;
SendMessage(hwnd, EM_GETSEL, (WPARAM)&curpoint, (LPARAM)NULL);
nextline = SendMessage(hwnd,EM_LINEFROMCHAR,(WPARAM)(curpoint - 1),0);
if(curpoint <= lineindex)
{
return 0;
} else if(nextline != curline) {
// delete the line we're on
// grab the index
curline -= LastPromptPosition.line;
// kill it
editbuffer_removeline(CurrentEditBuffer, curline);
}
}
else if (msg == WM_KEYDOWN && mp1 == VK_F1) {
DoHelp(hwnd);
}
else if ((msg == WM_KEYDOWN || msg == WM_KEYUP) && mp1 == VK_UP) {
int curline = GetCurLineIndex(hwnd);
/*if((msg == WM_KEYDOWN) && (GetKeyState(VK_CONTROL) && 0x8000))
{ // go forward once in history
NextHistoryEntry();
return 0;
} else */
if((curline > LastPromptPosition.line) && (curline <= (LastPromptPosition.line + CurrentEditBuffer->LineCount)))
{
// update current line
if (msg == WM_KEYDOWN)
{
int lineidx = (curline - LastPromptPosition.line);
CallWindowProc(lpEProc,hwnd,WM_KEYDOWN,VK_END,1);
CallWindowProc(lpEProc,hwnd,WM_KEYUP,VK_END,1);
// we may have to add this line, otherwise update it
editbuffer_updateoraddline(CurrentEditBuffer, lineidx, GetLastLine(hwnd));
}
} else {
return 0;
}
}
else if ((msg == WM_KEYDOWN || msg == WM_KEYUP) && (mp1 == VK_LEFT)) {
int lineindex = SendMessage(hwnd, EM_LINEINDEX, LastPromptPosition.line, 0) + 2;
int curline = SendMessage(hwnd,EM_LINEFROMCHAR,(WPARAM)-1,0);
int nextline = 0;
int curpoint = 0;
SendMessage(hwnd, EM_GETSEL, (WPARAM)&curpoint, (LPARAM)NULL);
nextline = SendMessage(hwnd,EM_LINEFROMCHAR,(WPARAM)(curpoint - 1),0);
if(curpoint <= lineindex)
{ // no left arrow to the left of the prompt
return 0;
} else if(nextline != curline) {
// update current line
if (msg == WM_KEYDOWN)
{
int lineidx = (curline - LastPromptPosition.line);
CallWindowProc(lpEProc,hwnd,WM_KEYDOWN,VK_END,1);
CallWindowProc(lpEProc,hwnd,WM_KEYUP,VK_END,1);
// we may have to add this line, otherwise update it
editbuffer_updateoraddline(CurrentEditBuffer, lineidx, GetLastLine(hwnd));
CallWindowProc(lpEProc,hwnd,WM_KEYDOWN,VK_HOME,1);
CallWindowProc(lpEProc,hwnd,WM_KEYUP,VK_HOME,1);
}
}
}
else if ((msg == WM_KEYDOWN || msg == WM_KEYUP) && (mp1 == VK_DOWN)) {
int curline = GetCurLineIndex(hwnd);
/*if((msg == WM_KEYDOWN) && (GetKeyState(VK_CONTROL) && 0x8000))
{ // go back once in history
PrevHistoryEntry();
return 0;
} else*/
if((curline >= LastPromptPosition.line) && (curline < (LastPromptPosition.line + CurrentEditBuffer->LineCount)))
{
// We don't post the newline, but instead update the current line
if (msg == WM_KEYDOWN)
{
int lineidx = (curline - LastPromptPosition.line);
CallWindowProc(lpEProc,hwnd,WM_KEYDOWN,VK_END,1);
CallWindowProc(lpEProc,hwnd,WM_KEYUP,VK_END,1);
editbuffer_updateline(CurrentEditBuffer, lineidx, GetLastLine(hwnd));
}
} else {
return 0;
}
}
else if ((msg == WM_KEYDOWN || msg == WM_KEYUP) && (mp1 == VK_RIGHT)) {
int lineindex = SendMessage(hwnd, EM_LINEINDEX, LastPromptPosition.line, 0) + 1;
int curline = SendMessage(hwnd,EM_LINEFROMCHAR,(WPARAM)-1,0);
int nextline = 0;
int curpoint = 0;
SendMessage(hwnd, EM_GETSEL, (WPARAM)&curpoint, (LPARAM)NULL);
nextline = SendMessage(hwnd,EM_LINEFROMCHAR,(WPARAM)(curpoint + 2),0);
if(curpoint <= lineindex)
{ // no movement behind the prompt
return 0;
} else if((nextline != curline) && (msg = WM_KEYDOWN)) {
int lineidx = (curline - LastPromptPosition.line);
CallWindowProc(lpEProc,hwnd,WM_KEYDOWN,VK_END,1);
CallWindowProc(lpEProc,hwnd,WM_KEYUP,VK_END,1);
editbuffer_updateline(CurrentEditBuffer, lineidx, GetLastLine(hwnd));
}
}
else if ((msg == WM_KEYDOWN) && (mp1 == VK_PRIOR) && (GetKeyState(VK_CONTROL) && 0x8000)) {
// C-p
NextHistoryEntry();
return 0;
}
else if ((msg == WM_KEYDOWN) && (mp1 == VK_NEXT) && (GetKeyState(VK_CONTROL) && 0x8000)) {
// C-n
PrevHistoryEntry();
return 0;
}
else if ((msg == WM_KEYDOWN || msg == WM_KEYUP) && (mp1 == VK_DELETE)) {
// see if we're the last char on the line, if so delete the next line
// don't allow deleting left of the prompt
int lineindex = SendMessage(hwnd, EM_LINEINDEX, LastPromptPosition.line, 0) + 2;
int curline = SendMessage(hwnd,EM_LINEFROMCHAR,(WPARAM)-1,0);
int nextline = 0;
int curpoint = 0;
SendMessage(hwnd, EM_GETSEL, (WPARAM)&curpoint, (LPARAM)NULL);
nextline = SendMessage(hwnd,EM_LINEFROMCHAR,(WPARAM)(curpoint + 2),0);
if(curpoint < lineindex)
{ // no chomping behind the prompt
return 0;
} else if(nextline != curline) {
// deleting
// grab the next line index
curline -= LastPromptPosition.line;
// kill it
editbuffer_removeline(CurrentEditBuffer, curline+1);
}
}
else if (msg == WM_PASTE) {
// if they paste text, allow it
r = CallWindowProc(lpEProc, hwnd, msg, mp1, mp2);
// update the current edit buffer
RefreshCurrentEditBuffer();
return r;
}
// handle errors
switch(msg)
{
case WM_SYNTAXERROR:
case WM_ILLEGALCHAR:
case WM_UNBOUNDVAL:
{ // currently I handle them all the same
// get the start of the line
int start = SendMessage(hwnd, EM_LINEINDEX, LastPromptPosition.line, 0) + 2;
// get the statement that error'd
NextHistoryEntry();
// tell the history that the last line errored
if(History != NULL)
if(History->Statement != NULL)
History->Statement->isCorrect = FALSE;
// highlight the offending chars
SendMessage(hwnd,EM_SETSEL,(WPARAM)(start + mp1), (LPARAM)(start + mp2));
return 0;
}
}
r = CallWindowProc(lpEProc, hwnd, msg, mp1, mp2);
if (postit)
PostMessage(GetParent(hwnd),WM_NEWLINE,0,0);
return r;
}
static void SubClassEditField(HWND hwnd)
{
if (lpEProc == NULL) {
lpEProc = (WNDPROC) GetWindowLongPtr(hwnd, GWLP_WNDPROC);
}
SetWindowLongPtr(hwnd, GWLP_WNDPROC, (LONG_PTR) SubClassEdit);
}
/*------------------------------------------------------------------------
Procedure: SendLastLine ID:1
Purpose: Sends the data in the line containing the cursor to
the interpreter. If this is NOT the last line, copy
the line to the end of the text.
Input: The edit control window handle
Output: None explicit
Errors: None
REMOVED!
------------------------------------------------------------------------*/
void SendLastLine(HWND hEdit)
{
/* int curline = GetCurLineIndex(hEdit);
char *p,linebuffer[2048];
int n;
int linescount = GetNumberOfLines(hEdit);
*(unsigned short *)linebuffer = sizeof(linebuffer)-1;
if (curline != linescount-1)
n = SendMessage(hEdit,EM_GETLINE,curline,(LPARAM)linebuffer);
else
n = SendMessage(hEdit,EM_GETLINE,curline-1,(LPARAM)linebuffer);
if (n >= 2 && linebuffer[0] == '#' && linebuffer[1] == ' ') {
n -= 2;
memmove(linebuffer, linebuffer+2, n);
}
linebuffer[n] = 0;
// Record user input!
AddToHistory(linebuffer);
linebuffer[n] = '\n';
linebuffer[n+1] = 0;
WriteToPipe(linebuffer);
if (curline != linescount-1) {
// Copy the line sent to the end of the text
p = strrchr(linebuffer,'\n');
if (p) {
*p = 0;
}
busy = 1;
AddLineToControl(linebuffer);
busy = 0;
}*/
}
/*------------------------------------------------------------------------
Procedure: SendLastEditBuffer ID:1
Author: Chris Watford watford@uiuc.edu
Purpose: Sends an edit buffer to the pipe
Input:
Output:
Errors:
--------------------------------------------------------------------------
Edit History:
7 Aug 2004 - Chris Watford christopher.watford@gmail.com
- Fixed error where SendLastEditBuffer sent waaaay too many
newlines which completely broke the underlying connection to the
ocaml.exe pipe
15 Sept 2003 - Chris Watford watford@uiuc.edu
- Sends line to the pipe and adds newline to the end
------------------------------------------------------------------------*/
void SendLastEditBuffer(HWND hwndChild)
{
char* line = editbuffer_getasbuffer(CurrentEditBuffer);
int l = strlen(line) - 1;
char* linebuffer = (char*)SafeMalloc(l+2);
// save current edit buffer to history and create a new blank edit buffer
CurrentEditBuffer->isCorrect = TRUE;
AddToHistory(CurrentEditBuffer);
CurrentEditBuffer = (EditBuffer*)SafeMalloc(sizeof(EditBuffer));
CurrentEditBuffer->LineCount = 0;
CurrentEditBuffer->Lines = NULL;
// trim and add the newline to the end
strncpy(linebuffer, line, l+1);
while((linebuffer[l] == '\n' || linebuffer[l] == '\r') && (l >= 0))
{
linebuffer[l--] = '\0';
}
linebuffer[l+1] = '\n';
linebuffer[l+2] = '\0';
// save line to the pipe
WriteToPipe(linebuffer);
}
/*------------------------------------------------------------------------
Procedure: SendingFullCommand ID:1
Author: Chris Watford watford@uiuc.edu
Purpose: Returns if the command being sent
Input: The edit control window handle
Output: None explicit
Errors: None
--------------------------------------------------------------------------
Edit History:
7 Aug 2004 - Chris Watford christopher.watford@gmail.com
- Fixed bug #2932 where many carraige returns were sent and it came
back with a null pointer error due to a fault of not checking if
the line returned was NULL
13 Oct 2003 - Chris Watford watford@uiuc.edu
- Solved the error when you have a malformed comment in the buffer
------------------------------------------------------------------------*/
BOOL SendingFullCommand(void)
{
// if there is a ;; on the line, return true
char *line = editbuffer_getasline(CurrentEditBuffer);
char *firstComment, *firstSemiColonSemiColon, *firstQuote;
if(line == NULL)
{
return FALSE;
}
firstComment = strstr(line, "(*");
firstSemiColonSemiColon = strstr(line, ";;");
firstQuote = strstr(line, "\"");
// easy case :D
if(firstSemiColonSemiColon == NULL)
{
free(line);
return FALSE;
}
// if there are no comments
if(firstComment == NULL)
{
// if there are no quotations used
if(firstQuote == NULL)
{
BOOL r = (firstSemiColonSemiColon != NULL);
free(line);
return r;
} else {
// we need to first check if the ;; is before the \", since the \"
// won't matter if its before the semicolonsemicolon
if(firstQuote < firstSemiColonSemiColon)
{
// the quote is before the ;;, we need to make sure its terminated
// also we have to check for escaped quotes, le sigh!
char *c = firstQuote+1;
BOOL in_quote = TRUE;
// in-quote determiner loop
while(c[0] != '\0')
{
// are we a backslash?
if(c[0] == '\\')
{
// ignore the next character
c++;
}
else
{
// are we a quote?
if(c[0] == '"')
{
in_quote = !in_quote;
}
}
c++;
}
free(line);
return !in_quote;
} else {
BOOL r = (firstSemiColonSemiColon != NULL);
free(line);
return r;
}
}
} else {
// we have to search through finding all comments
// a neat little trick we can do is compare the point at which
// the ;; is and where the first (* can be found, if the ;; is
// before the (* ocaml.exe ignores the comment
if((unsigned int)firstSemiColonSemiColon < (unsigned int)firstComment)
{
free(line);
return TRUE;
} else {
// time to search and find if the endline is inside a comment or not
// start at the first comment, and move forward keeping track of the
// nesting level, if the nest level is 0, i.e. outside a comment
// and we find the ;; return TRUE immediately, otherwise keep searching
// if we end with a nest level >0 return FALSE
char *c = firstComment+2; // firstComment[0] is the '(', firstComment[1] is the '*'
int nestLevel = 1; // we have a (*
// in-comment determiner loop
while(c[0] != '\0')
{
// are we an endline
if((c[0] == ';') && (c[1] == ';'))
{
// if we are NOT in a comment, its a full line
if(nestLevel <= 0)
{
free(line);
return TRUE;
}
}
// are we in a comment?
if((c[0] == '(') && (c[1] == '*'))
{
nestLevel++;
// watch out we may go past the end
if(c[2] == '\0')
{
free(line);
return FALSE;
}
// c needs to advance past the *, cause (*) is NOT the start/finish of a comment
c++;
}
// adjust the nesting down a level
if((c[0] == '*') && (c[1] == ')'))
nestLevel--;
// next char
c++;
}
// not a full line
free(line);
return FALSE;
}
}
// weird case ;)
free(line);
return FALSE;
}
/*------------------------------------------------------------------------
Procedure: AppendToEditBuffer ID:1
Author: Chris Watford watford@uiuc.edu
Purpose: Add a line to the edit buffer
Input: Handle of the edit control
Output:
Errors:
------------------------------------------------------------------------*/
void AppendToEditBuffer(HWND hEdit)
{
char *p = NULL, linebuffer[2048];
int n = 0;
int curline = GetCurLineIndex(hEdit);
int linescount = GetNumberOfLines(hEdit);
// they are passing the size of the buffer as
// the first 'short' in the array...
*(unsigned short *)linebuffer = sizeof(linebuffer)-1;
if (curline > (linescount-1))
{
n = SendMessage(hEdit, EM_GETLINE, curline, (LPARAM)linebuffer);
} else {
n = SendMessage(hEdit, EM_GETLINE, --curline, (LPARAM)linebuffer);
}
// correct for the prompt line
if (n >= 2 && linebuffer[0] == '#' && linebuffer[1] == ' ')
{
n -= 2;
memmove(linebuffer, linebuffer+2, n);
}
linebuffer[n] = '\0';
// linebuffer now has the line to add to our edit buffer
editbuffer_updateoraddline(CurrentEditBuffer, (curline - LastPromptPosition.line), linebuffer);
}
/*------------------------------------------------------------------------
Procedure: SetLastPrompt ID:1
Purpose: Record the position of the last prompt ("# ") sent by
the interpreter. This isn't really used yet.
Input:
Output:
Errors:
------------------------------------------------------------------------*/
void SetLastPrompt(HWND hEdit)
{
DWORD startpos,endpos;
SendMessage(hEdit,EM_GETSEL,(WPARAM)&startpos,(LPARAM)&endpos);
LastPromptPosition.line = SendMessage(hEdit,EM_LINEFROMCHAR,(WPARAM)-1,0);
LastPromptPosition.col = startpos;
}
/*------------------------------------------------------------------------
Procedure: MdiChildWndProc ID:1
Purpose: The edit control is enclosed in a normal MDI window.
This is the window procedure for that window. When it
receives the WM_CREATE message, it will create the
edit control.
Input:
Output:
Errors:
--------------------------------------------------------------------------
Edit History:
14 Sept 2003 - Chris Watford watford@uiuc.edu
- Added edit buffer and statement buffer support to the WM_NEWLINE
message.
15 Sept 2003 - Chris Watford watford@uiuc.edu
- Got it adding to the edit buffer
16 Sept 2003 - Chris Watford watford@uiuc.edu
- Proper handling of newline message finished
21 Sept 2003 - Chris Watford watford@uiuc.edu
- Added error detection on return from ocaml interp
23 Sept 2003 - Chris Watford watford@uiuc.edu
- Fixed prompt detection error as pointed out by Patrick Meredith
------------------------------------------------------------------------*/
static LRESULT CALLBACK MdiChildWndProc(HWND hwnd,UINT msg,WPARAM wparam,LPARAM lparam)
{
HWND hwndChild;
RECT rc;
HDC hDC;
switch(msg) {
case WM_CREATE:
GetClientRect(hwnd,&rc);
hwndChild= CreateWindow("EDIT",
NULL,
WS_CHILD | WS_VISIBLE |
ES_MULTILINE |
WS_VSCROLL | WS_HSCROLL |
ES_AUTOHSCROLL | ES_AUTOVSCROLL,
0,
0,
(rc.right-rc.left),
(rc.bottom-rc.top),
hwnd,
(HMENU) EditControls++,
hInst,
NULL);
SetWindowLongPtr(hwnd, DWLP_USER, (LONG_PTR) hwndChild);
SendMessage(hwndChild, WM_SETFONT, (WPARAM) ProgramParams.hFont, 0L);
SendMessage(hwndChild,EM_LIMITTEXT,0xffffffff,0);
SubClassEditField(hwndChild);
break;
// Resize the edit control
case WM_SIZE:
hwndChild = (HWND) GetWindowLongPtr(hwnd, DWLP_USER);
MoveWindow(hwndChild, 0, 0, LOWORD(lparam), HIWORD(lparam), TRUE);
break;
// Always set the focus to the edit control.
case WM_SETFOCUS:
hwndChild = (HWND) GetWindowLongPtr(hwnd, DWLP_USER);
SetFocus(hwndChild);
break;
// Repainting of the edit control about to happen.
// Set the text color and the background color
case WM_CTLCOLOREDIT:
hDC = (HDC)wparam;
SetTextColor(hDC,ProgramParams.TextColor);
SetBkColor(hDC,BackColor);
return (LRESULT)BackgroundBrush;
// Take care of erasing the background color to avoid flicker
case WM_ERASEBKGND:
GetWindowRect(hwnd,&rc);
hDC = (HDC)wparam;
FillRect(hDC,&rc,BackgroundBrush);
return 1;
// A carriage return has been pressed. Send the data to the interpreted.
// This message is posted by the subclassed edit field.
case WM_COMMAND:
if (LOWORD(wparam) >= IDEDITCONTROL && LOWORD(wparam) < IDEDITCONTROL+5) {
switch (HIWORD(wparam)) {
case EN_ERRSPACE:
case EN_MAXTEXT:
ResetText();
break;
}
}
break;
case WM_NEWLINE:
if (busy)
break;
hwndChild = (HWND) GetWindowLongPtr(hwnd, DWLP_USER);
// add what they wrote to the edit buffer
AppendToEditBuffer(hwndChild);
/** Modified by Chris Watford 14 Sept 2003, 15 Sept 2003, 16 Sept 2003 **/
// test if this line has an end or if it needs to be in the Edit Buffer
if(SendingFullCommand())
{
// send the edit buffer to the interpreter
//SendLastLine(hwndChild);
SendLastEditBuffer(hwndChild);
historyEntry = NULL;
} else {
AddStringToControl(" ");
}
/** End Modifications **/
break;
// The timer will call us 4 times a second. Look if the interpreter
// has written something in its end of the pipe.
case WM_TIMERTICK:
/** Modified by Chris Watford 21 Sept 2003 **/
hwndChild = (HWND) GetWindowLongPtr(hwnd, DWLP_USER);
if (ReadToLineBuffer())
{
int errMsg = 0;
char *p, *l = lineBuffer;
// Ok we read something. Display the trimmed version
while(((*l) == ' ') || ((*l) == '\t') || ((*l) == '\n') || ((*l) == '\r') || ((*l) == '*'))
l++;
SendMessage(hwndChild,EM_REPLACESEL,0,(LPARAM)l);
// fix bug where it won't find prompt
p = strrchr(l, '\r');
if((l[0] == '#') || (p != NULL))
{
if(p != NULL)
{
if(!strcmp(p, "\r\n# "))
{
SetLastPrompt(hwndChild);
}
// solve the bug Patrick found
} else if((l[0] == '#') && (l[1] == ' ')) {
SetLastPrompt(hwndChild);
}
}
// detect syntax errors
if(strstr(lineBuffer, "Syntax error"))
{
errMsg = WM_SYNTAXERROR;
} else if(strstr(lineBuffer, "Illegal character")) {
errMsg = WM_ILLEGALCHAR;
} else if(strstr(lineBuffer, "Unbound value")) {
errMsg = WM_UNBOUNDVAL;
}
// error! error! alert alert!
if(errMsg > 0)
{
int len = strlen(lineBuffer);
char* err = (char*)SafeMalloc(len+1);
char *m = err, *n1 = NULL, *n2 = NULL, *nt = NULL;
// make a copy of the message
strncpy(err, lineBuffer, len);
err[len] = '\0';
// find it
m = strstr(err, "Characters ");
if(m == NULL)
break;
// got the start char
n1 = m + strlen("Characters ");
// start looking for the end char
nt = strstr(n1, "-");
if(nt == NULL)
break;
// makes n1 a valid string
nt[0] = '\0';
// end char is right after this
n2 = nt + 1;
// find the end of n2
nt = strstr(n2, ":");
if(nt == NULL)
break;
// makes n2 a valid string
nt[0] = '\0';
SendMessage(hwndChild, errMsg, (WPARAM)atoi(n1), (LPARAM)atoi(n2));
}
}
/** End Modifications **/
break;
}
return DefMDIChildProc(hwnd, msg, wparam, lparam);
}
/*------------------------------------------------------------------------
Procedure: MainWndProc ID:1
Purpose: Window procedure for the frame window, that contains
the menu. The messages handled are:
WM_CREATE: Creates the mdi child window
WM_SIZE: resizes the status bar and the mdi child
window
WM_COMMAND: Sends the command to the dispatcher
WM_CLOSE: If the user confirms, it exists the program
WM_QUITOCAML: Stops the program unconditionally.
Input: Standard windows callback
Output:
Errors:
------------------------------------------------------------------------*/
static LRESULT CALLBACK MainWndProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
switch (msg) {
// Create the MDI client invisible window
case WM_CREATE:
hwndMDIClient = CreateMdiClient(hwnd);
TimerId = SetTimer((HWND) 0, 0, 100, (TIMERPROC) TimerProc);
break;
// Move the child windows
case WM_SIZE:
SendMessage(hWndStatusbar,msg,wParam,lParam);
InitializeStatusBar(hWndStatusbar,1);
// Position the MDI client window between the tool and status bars
if (wParam != SIZE_MINIMIZED) {
RECT rc, rcClient;
GetClientRect(hwnd, &rcClient);
GetWindowRect(hWndStatusbar, &rc);
ScreenToClient(hwnd, (LPPOINT)&rc.left);
rcClient.bottom = rc.top;
MoveWindow(hwndMDIClient,rcClient.left,rcClient.top,rcClient.right-rcClient.left, rcClient.bottom-rcClient.top, TRUE);
}
return 0;
// Dispatch the menu commands
case WM_COMMAND:
HandleCommand(hwnd, wParam,lParam);
return 0;
// If user confirms close
case WM_CLOSE:
if (!AskYesOrNo("Quit OCamlWinPlus?"))
return 0;
break;
// End application
case WM_DESTROY:
PostQuitMessage(0);
break;
// The interpreter has exited. Force close of the application
case WM_QUITOCAML:
DestroyWindow(hwnd);
return 0;
case WM_USER+1000:
// TestGraphics();
break;
default:
return DefFrameProc(hwnd,hwndMDIClient,msg,wParam,lParam);
}
return DefFrameProc(hwnd,hwndMDIClient,msg,wParam,lParam);
}
/*------------------------------------------------------------------------
Procedure: CreationCourier ID:1
Purpose: Creates the courier font
Input:
Output:
Errors:
------------------------------------------------------------------------*/
static HFONT CreationCourier(int flag)
{
LOGFONT CurrentFont;
memset(&CurrentFont, 0, sizeof(LOGFONT));
CurrentFont.lfCharSet = ANSI_CHARSET;
CurrentFont.lfWeight = FW_NORMAL;
if (flag)
CurrentFont.lfHeight = 18;
else
CurrentFont.lfHeight = 15;
CurrentFont.lfPitchAndFamily = (BYTE) (FIXED_PITCH | FF_MODERN);
strcpy(CurrentFont.lfFaceName, "Courier"); /* Courier */
return (CreateFontIndirect(&CurrentFont));
}
/*------------------------------------------------------------------------
Procedure: ReadToLineBuffer ID:1
Purpose: Reads into the line buffer the characters written by
the interpreter
Input: None
Output: The number of characters read
Errors: None
------------------------------------------------------------------------*/
int ReadToLineBuffer(void)
{
memset(lineBuffer,0,sizeof(lineBuffer));
return ReadFromPipe(lineBuffer,sizeof(lineBuffer));
}
/*------------------------------------------------------------------------
Procedure: AddLineBuffer ID:1
Purpose: Sends the contents of the line buffer to the edit
control
Input: None
Output:
Errors:
------------------------------------------------------------------------*/
int AddLineBuffer(void)
{
HWND hEditCtrl;
hEditCtrl = (HWND)GetWindowLongPtr(hwndSession,DWLP_USER);
return SendMessage(hEditCtrl,EM_REPLACESEL,0,(LPARAM)lineBuffer);
}
/*------------------------------------------------------------------------
Procedure: Setup ID:1
Purpose: Handles GUI initialization (Fonts, brushes, colors,
etc)
Input:
Output:
Errors:
------------------------------------------------------------------------*/
static int Setup(HANDLE *phAccelTable)
{
if (!InitApplication())
return 0;
ProgramParams.hFont = CreationCourier(1);
ProgramParams.TextColor = RGB(0,0,0);
GetObject(ProgramParams.hFont,sizeof(LOGFONT),&CurrentFont);
BackgroundBrush = CreateSolidBrush(BackColor);
*phAccelTable = LoadAccelerators(hInst,MAKEINTRESOURCE(IDACCEL));
return 1;
}
/*------------------------------------------------------------------------
Procedure: WinMain ID:1
Purpose: Entry point for windows programs.
Input:
Output:
Errors:
------------------------------------------------------------------------*/
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, INT nCmdShow)
{
MSG msg;
HANDLE hAccelTable;
char consoleTitle[512];
HWND hwndConsole;
CurrentEditBuffer = (EditBuffer*)SafeMalloc(sizeof(EditBuffer));
CurrentEditBuffer->LineCount = 0;
CurrentEditBuffer->Lines = NULL;
//setup the history index pointer
historyEntry = NULL;
// Setup the hInst global
hInst = hInstance;
// Do the setup
if (!Setup(&hAccelTable))
return 0;
// Need to set up a console so that we can send ctrl-break signal
// to inferior Caml
AllocConsole();
GetConsoleTitle(consoleTitle,sizeof(consoleTitle));
hwndConsole = FindWindow(NULL,consoleTitle);
ShowWindow(hwndConsole,SW_HIDE);
// Create main window and exit if this fails
if ((hwndMain = CreateinriaWndClassWnd()) == (HWND)0)
return 0;
// Create the status bar
CreateSBar(hwndMain,"Ready",2);
// Show the window
ShowWindow(hwndMain,SW_SHOW);
// Create the session window
hwndSession = MDICmdFileNew("Session transcript",0);
// Get the path to ocaml.exe
GetOcamlPath();
// Start the interpreter
StartOcaml();
// Show the session window
ShowWindow(hwndSession, SW_SHOW);
// Maximize it
SendMessage(hwndMDIClient, WM_MDIMAXIMIZE, (WPARAM) hwndSession, 0);
PostMessage(hwndMain,WM_USER+1000,0,0);
while (GetMessage(&msg,NULL,0,0)) {
if (!TranslateMDISysAccel(hwndMDIClient, &msg))
if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg)) {
TranslateMessage(&msg); // Translates virtual key codes
DispatchMessage(&msg); // Dispatches message to window
}
}
WriteToPipe("#quit;;\r\n\032");
KillTimer((HWND) 0, TimerId);
return msg.wParam;
}
Reference in New Issue View Git Blame Copy Permalink