a783f14eff
And add the manifest that gets us visual styles on the controls under Win32. [git-p4: depot-paths = "//depot/solvespace/": change = 1844]
1052 lines
31 KiB
C++
1052 lines
31 KiB
C++
#include <windows.h>
|
|
#include <commctrl.h>
|
|
#include <commdlg.h>
|
|
#include <gl/gl.h>
|
|
#include <gl/glu.h>
|
|
#include <stdarg.h>
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
|
|
#include "solvespace.h"
|
|
|
|
#define FREEZE_SUBKEY "SolveSpace"
|
|
#include "freeze.h"
|
|
|
|
#define MIN_COLS 45
|
|
#define TEXT_HEIGHT 20
|
|
#define TEXT_WIDTH 9
|
|
#define TEXT_LEFT_MARGIN 4
|
|
|
|
// For the edit controls
|
|
#define EDIT_WIDTH 220
|
|
#define EDIT_HEIGHT 21
|
|
|
|
HINSTANCE Instance;
|
|
|
|
HWND TextWnd;
|
|
HWND TextWndScrollBar;
|
|
HWND TextEditControl;
|
|
int TextEditControlCol, TextEditControlHalfRow;
|
|
int TextWndScrollPos; // The scrollbar position, in half-row units
|
|
int TextWndHalfRows; // The height of our window, in half-row units
|
|
|
|
HWND GraphicsWnd;
|
|
HGLRC GraphicsHpgl;
|
|
HWND GraphicsEditControl;
|
|
struct {
|
|
int x, y;
|
|
} LastMousePos;
|
|
|
|
char RecentFile[MAX_RECENT][MAX_PATH];
|
|
HMENU SubMenus[100];
|
|
HMENU RecentOpenMenu, RecentImportMenu;
|
|
|
|
int ClientIsSmallerBy;
|
|
|
|
HFONT FixedFont, LinkFont;
|
|
|
|
void dbp(char *str, ...)
|
|
{
|
|
va_list f;
|
|
static char buf[1024*50];
|
|
va_start(f, str);
|
|
vsprintf(buf, str, f);
|
|
OutputDebugString(buf);
|
|
va_end(f);
|
|
}
|
|
|
|
void Error(char *str, ...)
|
|
{
|
|
va_list f;
|
|
char buf[1024];
|
|
va_start(f, str);
|
|
vsprintf(buf, str, f);
|
|
va_end(f);
|
|
|
|
EnableWindow(GraphicsWnd, FALSE);
|
|
EnableWindow(TextWnd, FALSE);
|
|
|
|
HWND h = GetForegroundWindow();
|
|
MessageBox(h, buf, "SolveSpace Error", MB_OK | MB_ICONERROR);
|
|
|
|
EnableWindow(TextWnd, TRUE);
|
|
EnableWindow(GraphicsWnd, TRUE);
|
|
SetForegroundWindow(GraphicsWnd);
|
|
}
|
|
|
|
void ExitNow(void) {
|
|
PostQuitMessage(0);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Helpers so that we can read/write registry keys from the platform-
|
|
// independent code.
|
|
//-----------------------------------------------------------------------------
|
|
void CnfFreezeString(char *str, char *name)
|
|
{ FreezeStringF(str, FREEZE_SUBKEY, name); }
|
|
|
|
void CnfFreezeDWORD(DWORD v, char *name)
|
|
{ FreezeDWORDF(v, FREEZE_SUBKEY, name); }
|
|
|
|
void CnfFreezeFloat(float v, char *name)
|
|
{ FreezeDWORDF(*((DWORD *)&v), FREEZE_SUBKEY, name); }
|
|
|
|
void CnfThawString(char *str, int maxLen, char *name)
|
|
{ ThawStringF(str, maxLen, FREEZE_SUBKEY, name); }
|
|
|
|
DWORD CnfThawDWORD(DWORD v, char *name)
|
|
{ return ThawDWORDF(v, FREEZE_SUBKEY, name); }
|
|
|
|
float CnfThawFloat(float v, char *name) {
|
|
DWORD d = ThawDWORDF(*((DWORD *)&v), FREEZE_SUBKEY, name);
|
|
return *((float *)&d);
|
|
}
|
|
|
|
void SetWindowTitle(char *str) {
|
|
SetWindowText(GraphicsWnd, str);
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// A separate heap, on which we allocate expressions. Maybe a bit faster,
|
|
// since no fragmentation issues whatsoever, and it also makes it possible
|
|
// to be sloppy with our memory management, and just free everything at once
|
|
// at the end.
|
|
//-----------------------------------------------------------------------------
|
|
static HANDLE Temp;
|
|
void *AllocTemporary(int n)
|
|
{
|
|
void *v = HeapAlloc(Temp, HEAP_NO_SERIALIZE | HEAP_ZERO_MEMORY, n);
|
|
if(!v) oops();
|
|
return v;
|
|
}
|
|
void FreeTemporary(void *p) {
|
|
HeapFree(Temp, HEAP_NO_SERIALIZE, p);
|
|
}
|
|
void FreeAllTemporary(void)
|
|
{
|
|
if(Temp) HeapDestroy(Temp);
|
|
Temp = HeapCreate(HEAP_NO_SERIALIZE, 1024*1024*20, 0);
|
|
// This is a good place to validate, because it gets called fairly
|
|
// often.
|
|
vl();
|
|
}
|
|
|
|
static HANDLE Perm;
|
|
void *MemRealloc(void *p, int n) {
|
|
if(!p) {
|
|
return MemAlloc(n);
|
|
}
|
|
|
|
p = HeapReAlloc(Perm, HEAP_NO_SERIALIZE | HEAP_ZERO_MEMORY, p, n);
|
|
if(!p) oops();
|
|
return p;
|
|
}
|
|
void *MemAlloc(int n) {
|
|
void *p = HeapAlloc(Perm, HEAP_NO_SERIALIZE | HEAP_ZERO_MEMORY, n);
|
|
if(!p) oops();
|
|
return p;
|
|
}
|
|
void MemFree(void *p) {
|
|
HeapFree(Perm, HEAP_NO_SERIALIZE, p);
|
|
}
|
|
|
|
void vl(void) {
|
|
if(!HeapValidate(Temp, HEAP_NO_SERIALIZE, NULL)) oops();
|
|
if(!HeapValidate(Perm, HEAP_NO_SERIALIZE, NULL)) oops();
|
|
}
|
|
|
|
static void PaintTextWnd(HDC hdc)
|
|
{
|
|
int i;
|
|
|
|
static BOOL MadeBrushes = FALSE;
|
|
static COLORREF BgColor[256];
|
|
static COLORREF FgColor[256];
|
|
static HBRUSH BgBrush[256];
|
|
static HBRUSH FillBrush;
|
|
if(!MadeBrushes) {
|
|
// Generate the color table.
|
|
for(i = 0; SS.TW.fgColors[i].c != 0; i++) {
|
|
int c = SS.TW.fgColors[i].c;
|
|
if(c < 0 || c > 255) oops();
|
|
FgColor[c] = SS.TW.fgColors[i].color;
|
|
}
|
|
for(i = 0; SS.TW.bgColors[i].c != 0; i++) {
|
|
int c = SS.TW.bgColors[i].c;
|
|
if(c < 0 || c > 255) oops();
|
|
BgColor[c] = SS.TW.bgColors[i].color;
|
|
BgBrush[c] = CreateSolidBrush(BgColor[c]);
|
|
}
|
|
FillBrush = CreateSolidBrush(RGB(0, 0, 0));
|
|
MadeBrushes = TRUE;
|
|
}
|
|
|
|
RECT rect;
|
|
GetClientRect(TextWnd, &rect);
|
|
// Set up the back-buffer
|
|
HDC backDc = CreateCompatibleDC(hdc);
|
|
int width = rect.right - rect.left;
|
|
int height = rect.bottom - rect.top;
|
|
HBITMAP backBitmap = CreateCompatibleBitmap(hdc, width, height);
|
|
SelectObject(backDc, backBitmap);
|
|
|
|
FillRect(backDc, &rect, FillBrush);
|
|
|
|
SelectObject(backDc, FixedFont);
|
|
SetBkColor(backDc, RGB(0, 0, 0));
|
|
|
|
int halfRows = height / (TEXT_HEIGHT/2);
|
|
TextWndHalfRows = halfRows;
|
|
|
|
int bottom = SS.TW.top[SS.TW.rows-1] + 2;
|
|
TextWndScrollPos = min(TextWndScrollPos, bottom - halfRows);
|
|
TextWndScrollPos = max(TextWndScrollPos, 0);
|
|
|
|
// Let's set up the scroll bar first
|
|
SCROLLINFO si;
|
|
memset(&si, 0, sizeof(si));
|
|
si.cbSize = sizeof(si);
|
|
si.fMask = SIF_DISABLENOSCROLL | SIF_ALL;
|
|
si.nMin = 0;
|
|
si.nMax = SS.TW.top[SS.TW.rows - 1] + 1;
|
|
si.nPos = TextWndScrollPos;
|
|
si.nPage = halfRows;
|
|
SetScrollInfo(TextWndScrollBar, SB_CTL, &si, TRUE);
|
|
|
|
int r, c;
|
|
for(r = 0; r < SS.TW.rows; r++) {
|
|
int top = SS.TW.top[r];
|
|
if(top < (TextWndScrollPos-1)) continue;
|
|
if(top > TextWndScrollPos+halfRows) break;
|
|
|
|
for(c = 0; c < min((width/TEXT_WIDTH)+1, SS.TW.MAX_COLS); c++) {
|
|
int fg = SS.TW.meta[r][c].fg;
|
|
int bg = SS.TW.meta[r][c].bg;
|
|
|
|
SetTextColor(backDc, FgColor[fg]);
|
|
|
|
HBRUSH bgb;
|
|
if(bg & 0x80000000) {
|
|
bgb = (HBRUSH)GetStockObject(BLACK_BRUSH);
|
|
SetBkColor(backDc, bg & 0xffffff);
|
|
} else {
|
|
bgb = BgBrush[bg];
|
|
SetBkColor(backDc, BgColor[bg]);
|
|
}
|
|
|
|
if(SS.TW.meta[r][c].link && SS.TW.meta[r][c].link != 'n') {
|
|
SelectObject(backDc, LinkFont);
|
|
} else {
|
|
SelectObject(backDc, FixedFont);
|
|
}
|
|
|
|
int x = TEXT_LEFT_MARGIN + c*TEXT_WIDTH;
|
|
int y = (top-TextWndScrollPos)*(TEXT_HEIGHT/2);
|
|
|
|
RECT a;
|
|
a.left = x; a.right = x+TEXT_WIDTH;
|
|
a.top = y; a.bottom = y+TEXT_HEIGHT;
|
|
FillRect(backDc, &a, bgb);
|
|
|
|
TextOut(backDc, x, y+2, (char *)&(SS.TW.text[r][c]), 1);
|
|
}
|
|
}
|
|
|
|
// And commit the back buffer
|
|
BitBlt(hdc, 0, 0, width, height, backDc, 0, 0, SRCCOPY);
|
|
DeleteObject(backBitmap);
|
|
DeleteDC(backDc);
|
|
}
|
|
|
|
void HandleTextWindowScrollBar(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
int prevPos = TextWndScrollPos;
|
|
switch(LOWORD(wParam)) {
|
|
case SB_LINEUP: TextWndScrollPos--; break;
|
|
case SB_PAGEUP: TextWndScrollPos -= 4; break;
|
|
|
|
case SB_LINEDOWN: TextWndScrollPos++; break;
|
|
case SB_PAGEDOWN: TextWndScrollPos += 4; break;
|
|
|
|
case SB_TOP: TextWndScrollPos = 0; break;
|
|
|
|
case SB_BOTTOM: TextWndScrollPos = SS.TW.rows; break;
|
|
|
|
case SB_THUMBTRACK:
|
|
case SB_THUMBPOSITION: TextWndScrollPos = HIWORD(wParam); break;
|
|
}
|
|
int bottom = SS.TW.top[SS.TW.rows-1] + 2;
|
|
TextWndScrollPos = min(TextWndScrollPos, bottom - TextWndHalfRows);
|
|
TextWndScrollPos = max(TextWndScrollPos, 0);
|
|
if(prevPos != TextWndScrollPos) {
|
|
SCROLLINFO si;
|
|
si.cbSize = sizeof(si);
|
|
si.fMask = SIF_POS;
|
|
si.nPos = TextWndScrollPos;
|
|
SetScrollInfo(TextWndScrollBar, SB_CTL, &si, TRUE);
|
|
|
|
if(TextEditControlIsVisible()) {
|
|
int x = TEXT_LEFT_MARGIN + TEXT_WIDTH*TextEditControlCol;
|
|
int y = (TextEditControlHalfRow - TextWndScrollPos)*(TEXT_HEIGHT/2);
|
|
MoveWindow(TextEditControl, x, y, EDIT_WIDTH, EDIT_HEIGHT, TRUE);
|
|
}
|
|
InvalidateRect(TextWnd, NULL, FALSE);
|
|
}
|
|
}
|
|
|
|
LRESULT CALLBACK TextWndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
switch (msg) {
|
|
case WM_ERASEBKGND:
|
|
break;
|
|
|
|
case WM_CLOSE:
|
|
case WM_DESTROY:
|
|
SolveSpace::MenuFile(GraphicsWindow::MNU_EXIT);
|
|
break;
|
|
|
|
case WM_PAINT: {
|
|
PAINTSTRUCT ps;
|
|
HDC hdc = BeginPaint(hwnd, &ps);
|
|
PaintTextWnd(hdc);
|
|
EndPaint(hwnd, &ps);
|
|
break;
|
|
}
|
|
|
|
case WM_SIZING: {
|
|
RECT *r = (RECT *)lParam;
|
|
int hc = (r->bottom - r->top) - ClientIsSmallerBy;
|
|
int extra = hc % (TEXT_HEIGHT/2);
|
|
switch(wParam) {
|
|
case WMSZ_BOTTOM:
|
|
case WMSZ_BOTTOMLEFT:
|
|
case WMSZ_BOTTOMRIGHT:
|
|
r->bottom -= extra;
|
|
break;
|
|
|
|
case WMSZ_TOP:
|
|
case WMSZ_TOPLEFT:
|
|
case WMSZ_TOPRIGHT:
|
|
r->top += extra;
|
|
break;
|
|
}
|
|
int tooNarrow = (MIN_COLS*TEXT_WIDTH) - (r->right - r->left);
|
|
if(tooNarrow >= 0) {
|
|
switch(wParam) {
|
|
case WMSZ_RIGHT:
|
|
case WMSZ_BOTTOMRIGHT:
|
|
case WMSZ_TOPRIGHT:
|
|
r->right += tooNarrow;
|
|
break;
|
|
|
|
case WMSZ_LEFT:
|
|
case WMSZ_BOTTOMLEFT:
|
|
case WMSZ_TOPLEFT:
|
|
r->left -= tooNarrow;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
case WM_LBUTTONDOWN:
|
|
case WM_MOUSEMOVE: {
|
|
if(TextEditControlIsVisible() || GraphicsEditControlIsVisible()) {
|
|
SetCursor(LoadCursor(NULL, IDC_ARROW));
|
|
break;
|
|
}
|
|
GraphicsWindow::Selection ps = SS.GW.hover;
|
|
SS.GW.hover.Clear();
|
|
|
|
int x = LOWORD(lParam);
|
|
int y = HIWORD(lParam);
|
|
|
|
// Find the corresponding character in the text buffer
|
|
int c = (x / TEXT_WIDTH);
|
|
int hh = (TEXT_HEIGHT)/2;
|
|
y += TextWndScrollPos*hh;
|
|
int r;
|
|
for(r = 0; r < SS.TW.rows; r++) {
|
|
if(y >= SS.TW.top[r]*hh && y <= (SS.TW.top[r]+2)*hh) {
|
|
break;
|
|
}
|
|
}
|
|
if(r >= SS.TW.rows) {
|
|
SetCursor(LoadCursor(NULL, IDC_ARROW));
|
|
goto done;
|
|
}
|
|
|
|
#define META (SS.TW.meta[r][c])
|
|
if(msg == WM_MOUSEMOVE) {
|
|
if(META.link) {
|
|
SetCursor(LoadCursor(NULL, IDC_HAND));
|
|
if(META.h) {
|
|
(META.h)(META.link, META.data);
|
|
}
|
|
} else {
|
|
SetCursor(LoadCursor(NULL, IDC_ARROW));
|
|
}
|
|
} else {
|
|
if(META.link && META.f) {
|
|
(META.f)(META.link, META.data);
|
|
SS.TW.Show();
|
|
InvalidateGraphics();
|
|
}
|
|
}
|
|
done:
|
|
if(!ps.Equals(&(SS.GW.hover))) {
|
|
InvalidateGraphics();
|
|
}
|
|
break;
|
|
}
|
|
|
|
case WM_SIZE: {
|
|
RECT r;
|
|
GetWindowRect(TextWndScrollBar, &r);
|
|
int sw = r.right - r.left;
|
|
GetClientRect(hwnd, &r);
|
|
MoveWindow(TextWndScrollBar, r.right - sw, r.top, sw,
|
|
(r.bottom - r.top), TRUE);
|
|
// If the window is growing, then the scrollbar position may
|
|
// be moving, so it's as if we're dragging the scrollbar.
|
|
HandleTextWindowScrollBar(0, 0);
|
|
InvalidateRect(TextWnd, NULL, FALSE);
|
|
break;
|
|
}
|
|
|
|
case WM_VSCROLL:
|
|
HandleTextWindowScrollBar(wParam, lParam);
|
|
break;
|
|
|
|
default:
|
|
return DefWindowProc(hwnd, msg, wParam, lParam);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static BOOL ProcessKeyDown(WPARAM wParam)
|
|
{
|
|
if(GraphicsEditControlIsVisible() && wParam != VK_ESCAPE) {
|
|
if(wParam == VK_RETURN) {
|
|
char s[1024];
|
|
memset(s, 0, sizeof(s));
|
|
SendMessage(GraphicsEditControl, WM_GETTEXT, 900, (LPARAM)s);
|
|
SS.GW.EditControlDone(s);
|
|
return TRUE;
|
|
} else {
|
|
return FALSE;
|
|
}
|
|
}
|
|
if(TextEditControlIsVisible() && wParam != VK_ESCAPE) {
|
|
if(wParam == VK_RETURN) {
|
|
char s[1024];
|
|
memset(s, 0, sizeof(s));
|
|
SendMessage(TextEditControl, WM_GETTEXT, 900, (LPARAM)s);
|
|
SS.TW.EditControlDone(s);
|
|
} else {
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if(wParam == VK_BACK && !GraphicsEditControlIsVisible()) {
|
|
TextWindow::ScreenHome(0, 0);
|
|
SS.TW.Show();
|
|
return TRUE;
|
|
}
|
|
|
|
int c;
|
|
switch(wParam) {
|
|
case VK_OEM_PLUS: c = '+'; break;
|
|
case VK_OEM_MINUS: c = '-'; break;
|
|
case VK_ESCAPE: c = 27; break;
|
|
case VK_OEM_1: c = ';'; break;
|
|
case VK_OEM_4: c = '['; break;
|
|
case VK_OEM_6: c = ']'; break;
|
|
case VK_OEM_5: c = '\\'; break;
|
|
case VK_SPACE: c = ' '; break;
|
|
case VK_DELETE: c = 127; break;
|
|
case VK_TAB: c = '\t'; break;
|
|
|
|
// These overlap with some character codes that I'm using, so
|
|
// don't let them trigger by accident.
|
|
case VK_F16:
|
|
case VK_INSERT:
|
|
case VK_EXECUTE:
|
|
case VK_APPS:
|
|
case VK_LWIN:
|
|
case VK_RWIN: return FALSE;
|
|
|
|
default:
|
|
c = wParam;
|
|
break;
|
|
}
|
|
if(GetAsyncKeyState(VK_SHIFT) & 0x8000) c |= 0x100;
|
|
if(GetAsyncKeyState(VK_CONTROL) & 0x8000) c |= 0x200;
|
|
|
|
for(int i = 0; SS.GW.menu[i].level >= 0; i++) {
|
|
if(c == SS.GW.menu[i].accel) {
|
|
(SS.GW.menu[i].fn)((GraphicsWindow::MenuId)SS.GW.menu[i].id);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// No accelerator; process the key as normal.
|
|
return FALSE;
|
|
}
|
|
|
|
void ShowTextWindow(BOOL visible)
|
|
{
|
|
ShowWindow(TextWnd, visible ? SW_SHOWNOACTIVATE : SW_HIDE);
|
|
}
|
|
|
|
static void CreateGlContext(void)
|
|
{
|
|
HDC hdc = GetDC(GraphicsWnd);
|
|
|
|
PIXELFORMATDESCRIPTOR pfd;
|
|
int pixelFormat;
|
|
|
|
memset(&pfd, 0, sizeof(pfd));
|
|
pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
|
|
pfd.nVersion = 1;
|
|
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL |
|
|
PFD_DOUBLEBUFFER;
|
|
pfd.dwLayerMask = PFD_MAIN_PLANE;
|
|
pfd.iPixelType = PFD_TYPE_RGBA;
|
|
pfd.cColorBits = 32;
|
|
pfd.cDepthBits = 24;
|
|
pfd.cAccumBits = 0;
|
|
pfd.cStencilBits = 0;
|
|
|
|
pixelFormat = ChoosePixelFormat(hdc, &pfd);
|
|
if(!pixelFormat) oops();
|
|
|
|
if(!SetPixelFormat(hdc, pixelFormat, &pfd)) oops();
|
|
|
|
GraphicsHpgl = wglCreateContext(hdc);
|
|
wglMakeCurrent(hdc, GraphicsHpgl);
|
|
}
|
|
|
|
void InvalidateGraphics(void)
|
|
{
|
|
InvalidateRect(GraphicsWnd, NULL, FALSE);
|
|
}
|
|
void GetGraphicsWindowSize(int *w, int *h)
|
|
{
|
|
RECT r;
|
|
GetClientRect(GraphicsWnd, &r);
|
|
*w = r.right - r.left;
|
|
*h = r.bottom - r.top;
|
|
}
|
|
void PaintGraphics(void)
|
|
{
|
|
int w, h;
|
|
GetGraphicsWindowSize(&w, &h);
|
|
|
|
SS.GW.Paint(w, h);
|
|
SwapBuffers(GetDC(GraphicsWnd));
|
|
}
|
|
|
|
SDWORD GetMilliseconds(void)
|
|
{
|
|
LARGE_INTEGER t, f;
|
|
QueryPerformanceCounter(&t);
|
|
QueryPerformanceFrequency(&f);
|
|
LONGLONG d = t.QuadPart/(f.QuadPart/1000);
|
|
return (SDWORD)d;
|
|
}
|
|
|
|
void InvalidateText(void)
|
|
{
|
|
InvalidateRect(TextWnd, NULL, FALSE);
|
|
}
|
|
|
|
static void ShowEditControl(HWND h, int x, int y, char *s) {
|
|
MoveWindow(h, x, y, EDIT_WIDTH, EDIT_HEIGHT, TRUE);
|
|
ShowWindow(h, SW_SHOW);
|
|
SendMessage(h, WM_SETTEXT, 0, (LPARAM)s);
|
|
SendMessage(h, EM_SETSEL, 0, strlen(s));
|
|
SetFocus(h);
|
|
}
|
|
void ShowTextEditControl(int hr, int c, char *s)
|
|
{
|
|
if(TextEditControlIsVisible() || GraphicsEditControlIsVisible()) return;
|
|
|
|
int x = TEXT_LEFT_MARGIN + TEXT_WIDTH*c;
|
|
int y = (hr - TextWndScrollPos)*(TEXT_HEIGHT/2);
|
|
TextEditControlCol = c;
|
|
TextEditControlHalfRow = hr;
|
|
ShowEditControl(TextEditControl, x, y, s);
|
|
}
|
|
void HideTextEditControl(void)
|
|
{
|
|
ShowWindow(TextEditControl, SW_HIDE);
|
|
}
|
|
BOOL TextEditControlIsVisible(void)
|
|
{
|
|
return IsWindowVisible(TextEditControl);
|
|
}
|
|
void ShowGraphicsEditControl(int x, int y, char *s)
|
|
{
|
|
if(TextEditControlIsVisible() || GraphicsEditControlIsVisible()) return;
|
|
|
|
RECT r;
|
|
GetClientRect(GraphicsWnd, &r);
|
|
x = x + (r.right - r.left)/2;
|
|
y = (r.bottom - r.top)/2 - y;
|
|
|
|
// (x, y) are the bottom left, but the edit control is placed by its
|
|
// top left corner
|
|
y -= 20;
|
|
|
|
ShowEditControl(GraphicsEditControl, x, y, s);
|
|
}
|
|
void HideGraphicsEditControl(void)
|
|
{
|
|
ShowWindow(GraphicsEditControl, SW_HIDE);
|
|
}
|
|
BOOL GraphicsEditControlIsVisible(void)
|
|
{
|
|
return IsWindowVisible(GraphicsEditControl);
|
|
}
|
|
|
|
LRESULT CALLBACK GraphicsWndProc(HWND hwnd, UINT msg, WPARAM wParam,
|
|
LPARAM lParam)
|
|
{
|
|
switch (msg) {
|
|
case WM_ERASEBKGND:
|
|
break;
|
|
|
|
case WM_SIZE:
|
|
InvalidateRect(GraphicsWnd, NULL, FALSE);
|
|
break;
|
|
|
|
case WM_PAINT: {
|
|
PaintGraphics();
|
|
PAINTSTRUCT ps;
|
|
HDC hdc = BeginPaint(hwnd, &ps);
|
|
EndPaint(hwnd, &ps);
|
|
break;
|
|
}
|
|
|
|
case WM_MOUSEMOVE:
|
|
case WM_LBUTTONDOWN:
|
|
case WM_LBUTTONUP:
|
|
case WM_LBUTTONDBLCLK:
|
|
case WM_RBUTTONDOWN:
|
|
case WM_MBUTTONDOWN: {
|
|
int x = LOWORD(lParam);
|
|
int y = HIWORD(lParam);
|
|
|
|
RECT r;
|
|
GetClientRect(GraphicsWnd, &r);
|
|
x = x - (r.right - r.left)/2;
|
|
y = (r.bottom - r.top)/2 - y;
|
|
|
|
LastMousePos.x = x;
|
|
LastMousePos.y = y;
|
|
|
|
if(msg == WM_LBUTTONDOWN) {
|
|
SS.GW.MouseLeftDown(x, y);
|
|
} else if(msg == WM_LBUTTONUP) {
|
|
SS.GW.MouseLeftUp(x, y);
|
|
} else if(msg == WM_LBUTTONDBLCLK) {
|
|
SS.GW.MouseLeftDoubleClick(x, y);
|
|
} else if(msg == WM_MBUTTONDOWN || msg == WM_RBUTTONDOWN) {
|
|
SS.GW.MouseMiddleOrRightDown(x, y);
|
|
} else if(msg == WM_MOUSEMOVE) {
|
|
SS.GW.MouseMoved(x, y,
|
|
!!(wParam & MK_LBUTTON),
|
|
!!(wParam & MK_MBUTTON),
|
|
!!(wParam & MK_RBUTTON),
|
|
!!(wParam & MK_SHIFT),
|
|
!!(wParam & MK_CONTROL));
|
|
} else {
|
|
oops();
|
|
}
|
|
break;
|
|
}
|
|
case WM_MOUSEWHEEL: {
|
|
int delta = GET_WHEEL_DELTA_WPARAM(wParam);
|
|
SS.GW.MouseScroll(LastMousePos.x, LastMousePos.y, delta);
|
|
break;
|
|
}
|
|
case WM_COMMAND: {
|
|
if(HIWORD(wParam) == 0) {
|
|
int id = LOWORD(wParam);
|
|
if((id >= RECENT_OPEN && id < (RECENT_OPEN + MAX_RECENT))) {
|
|
SolveSpace::MenuFile(id);
|
|
break;
|
|
}
|
|
if((id >= RECENT_IMPORT && id < (RECENT_IMPORT + MAX_RECENT))) {
|
|
Group::MenuGroup(id);
|
|
break;
|
|
}
|
|
int i;
|
|
for(i = 0; SS.GW.menu[i].level >= 0; i++) {
|
|
if(id == SS.GW.menu[i].id) {
|
|
(SS.GW.menu[i].fn)((GraphicsWindow::MenuId)id);
|
|
break;
|
|
}
|
|
}
|
|
if(SS.GW.menu[i].level < 0) oops();
|
|
}
|
|
break;
|
|
}
|
|
|
|
case WM_CLOSE:
|
|
case WM_DESTROY:
|
|
SolveSpace::MenuFile(GraphicsWindow::MNU_EXIT);
|
|
return 1;
|
|
|
|
default:
|
|
return DefWindowProc(hwnd, msg, wParam, lParam);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Common dialog routines, to open or save a file.
|
|
//-----------------------------------------------------------------------------
|
|
BOOL GetOpenFile(char *file, char *defExtension, char *selPattern)
|
|
{
|
|
OPENFILENAME ofn;
|
|
|
|
memset(&ofn, 0, sizeof(ofn));
|
|
ofn.lStructSize = sizeof(ofn);
|
|
ofn.hInstance = Instance;
|
|
ofn.hwndOwner = GraphicsWnd;
|
|
ofn.lpstrFilter = selPattern;
|
|
ofn.lpstrDefExt = defExtension;
|
|
ofn.lpstrFile = file;
|
|
ofn.nMaxFile = MAX_PATH;
|
|
ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST | OFN_HIDEREADONLY;
|
|
|
|
EnableWindow(GraphicsWnd, FALSE);
|
|
EnableWindow(TextWnd, FALSE);
|
|
|
|
BOOL r = GetOpenFileName(&ofn);
|
|
|
|
EnableWindow(TextWnd, TRUE);
|
|
EnableWindow(GraphicsWnd, TRUE);
|
|
SetForegroundWindow(GraphicsWnd);
|
|
|
|
return r;
|
|
}
|
|
BOOL GetSaveFile(char *file, char *defExtension, char *selPattern)
|
|
{
|
|
OPENFILENAME ofn;
|
|
|
|
memset(&ofn, 0, sizeof(ofn));
|
|
ofn.lStructSize = sizeof(ofn);
|
|
ofn.hInstance = Instance;
|
|
ofn.hwndOwner = GraphicsWnd;
|
|
ofn.lpstrFilter = selPattern;
|
|
ofn.lpstrDefExt = defExtension;
|
|
ofn.lpstrFile = file;
|
|
ofn.nMaxFile = MAX_PATH;
|
|
ofn.Flags = OFN_PATHMUSTEXIST | OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT;
|
|
|
|
EnableWindow(GraphicsWnd, FALSE);
|
|
EnableWindow(TextWnd, FALSE);
|
|
|
|
BOOL r = GetSaveFileName(&ofn);
|
|
|
|
EnableWindow(TextWnd, TRUE);
|
|
EnableWindow(GraphicsWnd, TRUE);
|
|
SetForegroundWindow(GraphicsWnd);
|
|
|
|
return r;
|
|
}
|
|
int SaveFileYesNoCancel(void)
|
|
{
|
|
EnableWindow(GraphicsWnd, FALSE);
|
|
EnableWindow(TextWnd, FALSE);
|
|
|
|
int r = MessageBox(GraphicsWnd,
|
|
"The program has changed since it was last saved.\r\n\r\n"
|
|
"Do you want to save the changes?", "SolveSpace",
|
|
MB_YESNOCANCEL | MB_ICONWARNING);
|
|
|
|
EnableWindow(TextWnd, TRUE);
|
|
EnableWindow(GraphicsWnd, TRUE);
|
|
SetForegroundWindow(GraphicsWnd);
|
|
|
|
return r;
|
|
}
|
|
|
|
void GetAbsoluteFilename(char *file)
|
|
{
|
|
char absoluteFile[MAX_PATH];
|
|
GetFullPathName(file, sizeof(absoluteFile), absoluteFile, NULL);
|
|
strcpy(file, absoluteFile);
|
|
}
|
|
|
|
void LoadAllFontFiles(void)
|
|
{
|
|
WIN32_FIND_DATA wfd;
|
|
char dir[MAX_PATH];
|
|
GetWindowsDirectory(dir, MAX_PATH - 30);
|
|
strcat(dir, "\\fonts\\*.ttf");
|
|
|
|
HANDLE h = FindFirstFile(dir, &wfd);
|
|
|
|
while(h != INVALID_HANDLE_VALUE) {
|
|
TtfFont tf;
|
|
ZERO(&tf);
|
|
|
|
char fullPath[MAX_PATH];
|
|
GetWindowsDirectory(fullPath, MAX_PATH - (30 + strlen(wfd.cFileName)));
|
|
strcat(fullPath, "\\fonts\\");
|
|
strcat(fullPath, wfd.cFileName);
|
|
|
|
strcpy(tf.fontFile, fullPath);
|
|
SS.fonts.l.Add(&tf);
|
|
|
|
if(!FindNextFile(h, &wfd)) break;
|
|
}
|
|
}
|
|
|
|
static void MenuById(int id, BOOL yes, BOOL check)
|
|
{
|
|
int i;
|
|
int subMenu = -1;
|
|
|
|
for(i = 0; SS.GW.menu[i].level >= 0; i++) {
|
|
if(SS.GW.menu[i].level == 0) subMenu++;
|
|
|
|
if(SS.GW.menu[i].id == id) {
|
|
if(subMenu < 0) oops();
|
|
if(subMenu >= (sizeof(SubMenus)/sizeof(SubMenus[0]))) oops();
|
|
|
|
if(check) {
|
|
CheckMenuItem(SubMenus[subMenu], id,
|
|
yes ? MF_CHECKED : MF_UNCHECKED);
|
|
} else {
|
|
EnableMenuItem(SubMenus[subMenu], id,
|
|
yes ? MF_ENABLED : MF_GRAYED);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
oops();
|
|
}
|
|
void CheckMenuById(int id, BOOL checked)
|
|
{
|
|
MenuById(id, checked, TRUE);
|
|
}
|
|
void EnableMenuById(int id, BOOL enabled)
|
|
{
|
|
MenuById(id, enabled, FALSE);
|
|
}
|
|
static void DoRecent(HMENU m, int base)
|
|
{
|
|
while(DeleteMenu(m, 0, MF_BYPOSITION))
|
|
;
|
|
int i, c = 0;
|
|
for(i = 0; i < MAX_RECENT; i++) {
|
|
char *s = RecentFile[i];
|
|
if(*s) {
|
|
AppendMenu(m, MF_STRING, base+i, s);
|
|
c++;
|
|
}
|
|
}
|
|
if(c == 0) AppendMenu(m, MF_STRING | MF_GRAYED, 0, "(no recent files)");
|
|
}
|
|
void RefreshRecentMenus(void)
|
|
{
|
|
DoRecent(RecentOpenMenu, RECENT_OPEN);
|
|
DoRecent(RecentImportMenu, RECENT_IMPORT);
|
|
}
|
|
|
|
HMENU CreateGraphicsWindowMenus(void)
|
|
{
|
|
HMENU top = CreateMenu();
|
|
HMENU m;
|
|
|
|
int i;
|
|
int subMenu = 0;
|
|
|
|
for(i = 0; SS.GW.menu[i].level >= 0; i++) {
|
|
if(SS.GW.menu[i].level == 0) {
|
|
m = CreateMenu();
|
|
AppendMenu(top, MF_STRING | MF_POPUP, (UINT_PTR)m,
|
|
SS.GW.menu[i].label);
|
|
|
|
if(subMenu >= arraylen(SubMenus)) oops();
|
|
SubMenus[subMenu] = m;
|
|
subMenu++;
|
|
} else if(SS.GW.menu[i].level == 1) {
|
|
if(SS.GW.menu[i].label) {
|
|
AppendMenu(m, MF_STRING, SS.GW.menu[i].id, SS.GW.menu[i].label);
|
|
} else {
|
|
AppendMenu(m, MF_SEPARATOR, SS.GW.menu[i].id, "");
|
|
}
|
|
} else if(SS.GW.menu[i].level == 10) {
|
|
RecentOpenMenu = CreateMenu();
|
|
AppendMenu(m, MF_STRING | MF_POPUP,
|
|
(UINT_PTR)RecentOpenMenu, SS.GW.menu[i].label);
|
|
} else if(SS.GW.menu[i].level == 11) {
|
|
RecentImportMenu = CreateMenu();
|
|
AppendMenu(m, MF_STRING | MF_POPUP,
|
|
(UINT_PTR)RecentImportMenu, SS.GW.menu[i].label);
|
|
} else oops();
|
|
}
|
|
RefreshRecentMenus();
|
|
|
|
return top;
|
|
}
|
|
|
|
static void CreateMainWindows(void)
|
|
{
|
|
WNDCLASSEX wc;
|
|
|
|
memset(&wc, 0, sizeof(wc));
|
|
wc.cbSize = sizeof(wc);
|
|
|
|
// The graphics window, where the sketch is drawn and shown.
|
|
wc.style = CS_BYTEALIGNCLIENT | CS_BYTEALIGNWINDOW | CS_OWNDC |
|
|
CS_DBLCLKS;
|
|
wc.lpfnWndProc = (WNDPROC)GraphicsWndProc;
|
|
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
|
|
wc.lpszClassName = "GraphicsWnd";
|
|
wc.lpszMenuName = NULL;
|
|
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
|
|
wc.hIcon = (HICON)LoadImage(Instance, MAKEINTRESOURCE(4000),
|
|
IMAGE_ICON, 32, 32, 0);
|
|
wc.hIconSm = (HICON)LoadImage(Instance, MAKEINTRESOURCE(4000),
|
|
IMAGE_ICON, 16, 16, 0);
|
|
if(!RegisterClassEx(&wc)) oops();
|
|
|
|
HMENU top = CreateGraphicsWindowMenus();
|
|
GraphicsWnd = CreateWindowEx(0, "GraphicsWnd",
|
|
"SolveSpace (Graphics Window)",
|
|
WS_OVERLAPPED | WS_THICKFRAME | WS_CLIPCHILDREN | WS_MAXIMIZEBOX |
|
|
WS_MINIMIZEBOX | WS_SYSMENU | WS_SIZEBOX | WS_CLIPSIBLINGS,
|
|
50, 50, 900, 600, NULL, top, Instance, NULL);
|
|
if(!GraphicsWnd) oops();
|
|
|
|
CreateGlContext();
|
|
|
|
GraphicsEditControl = CreateWindowEx(WS_EX_CLIENTEDGE, WC_EDIT, "",
|
|
WS_CHILD | ES_AUTOHSCROLL | WS_TABSTOP | WS_CLIPSIBLINGS,
|
|
50, 50, 100, 21, GraphicsWnd, NULL, Instance, NULL);
|
|
SendMessage(GraphicsEditControl, WM_SETFONT, (WPARAM)FixedFont, TRUE);
|
|
|
|
|
|
// The text window, with a comand line and some textual information
|
|
// about the sketch.
|
|
wc.style &= ~CS_DBLCLKS;
|
|
wc.lpfnWndProc = (WNDPROC)TextWndProc;
|
|
wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
|
|
wc.lpszClassName = "TextWnd";
|
|
wc.hCursor = NULL;
|
|
if(!RegisterClassEx(&wc)) oops();
|
|
|
|
// We get the desired Alt+Tab behaviour by specifying that the text
|
|
// window is a child of the graphics window.
|
|
TextWnd = CreateWindowEx(0,
|
|
"TextWnd", "SolveSpace (Text Window)", WS_THICKFRAME | WS_CLIPCHILDREN,
|
|
650, 500, 420, 300, GraphicsWnd, (HMENU)NULL, Instance, NULL);
|
|
if(!TextWnd) oops();
|
|
|
|
TextWndScrollBar = CreateWindowEx(0, WC_SCROLLBAR, "", WS_CHILD |
|
|
SBS_VERT | SBS_LEFTALIGN | WS_VISIBLE | WS_CLIPSIBLINGS,
|
|
200, 100, 100, 100, TextWnd, NULL, Instance, NULL);
|
|
// Force the scrollbar to get resized to the window,
|
|
TextWndProc(TextWnd, WM_SIZE, 0, 0);
|
|
|
|
TextEditControl = CreateWindowEx(WS_EX_CLIENTEDGE, WC_EDIT, "",
|
|
WS_CHILD | ES_AUTOHSCROLL | WS_TABSTOP | WS_CLIPSIBLINGS,
|
|
50, 50, 100, 21, TextWnd, NULL, Instance, NULL);
|
|
SendMessage(TextEditControl, WM_SETFONT, (WPARAM)FixedFont, TRUE);
|
|
|
|
|
|
RECT r, rc;
|
|
GetWindowRect(TextWnd, &r);
|
|
GetClientRect(TextWnd, &rc);
|
|
ClientIsSmallerBy = (r.bottom - r.top) - (rc.bottom - rc.top);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Entry point into the program.
|
|
//-----------------------------------------------------------------------------
|
|
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
|
|
LPSTR lpCmdLine, INT nCmdShow)
|
|
{
|
|
Instance = hInstance;
|
|
|
|
InitCommonControls();
|
|
|
|
// A monospaced font
|
|
FixedFont = CreateFont(TEXT_HEIGHT-4, TEXT_WIDTH, 0, 0, FW_REGULAR, FALSE,
|
|
FALSE, FALSE, ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
|
|
DEFAULT_QUALITY, FF_DONTCARE, "Lucida Console");
|
|
LinkFont = CreateFont(TEXT_HEIGHT-4, TEXT_WIDTH, 0, 0, FW_REGULAR, FALSE,
|
|
TRUE, FALSE, ANSI_CHARSET, OUT_DEFAULT_PRECIS, CLIP_DEFAULT_PRECIS,
|
|
DEFAULT_QUALITY, FF_DONTCARE, "Lucida Console");
|
|
if(!FixedFont)
|
|
FixedFont = (HFONT)GetStockObject(SYSTEM_FONT);
|
|
if(!LinkFont)
|
|
LinkFont = (HFONT)GetStockObject(SYSTEM_FONT);
|
|
|
|
// Create the root windows: one for control, with text, and one for
|
|
// the graphics
|
|
CreateMainWindows();
|
|
|
|
ThawWindowPos(TextWnd);
|
|
ThawWindowPos(GraphicsWnd);
|
|
|
|
// Create the heap used for long-lived stuff (that gets freed piecewise).
|
|
Perm = HeapCreate(HEAP_NO_SERIALIZE, 1024*1024*20, 0);
|
|
// Create the heap that we use to store Exprs and other temp stuff.
|
|
FreeAllTemporary();
|
|
|
|
// A filename may have been specified on the command line; if so, then
|
|
// strip any quotation marks, and make it absolute.
|
|
char file[MAX_PATH] = "";
|
|
if(strlen(lpCmdLine)+1 < MAX_PATH) {
|
|
char *s = lpCmdLine;
|
|
while(*s == ' ' || *s == '"') s++;
|
|
strcpy(file, s);
|
|
s = strrchr(file, '"');
|
|
if(s) *s = '\0';
|
|
}
|
|
if(*file != '\0') {
|
|
GetAbsoluteFilename(file);
|
|
}
|
|
|
|
// Call in to the platform-independent code, and let them do their init
|
|
SS.Init(file);
|
|
|
|
ShowWindow(TextWnd, SW_SHOWNOACTIVATE);
|
|
ShowWindow(GraphicsWnd, SW_SHOW);
|
|
|
|
// And now it's the message loop. All calls in to the rest of the code
|
|
// will be from the wndprocs.
|
|
MSG msg;
|
|
DWORD ret;
|
|
while(ret = GetMessage(&msg, NULL, 0, 0)) {
|
|
if(msg.message == WM_KEYDOWN) {
|
|
if(ProcessKeyDown(msg.wParam)) goto done;
|
|
}
|
|
if(msg.message == WM_SYSKEYDOWN && msg.hwnd == TextWnd) {
|
|
// If the user presses the Alt key when the text window has focus,
|
|
// then that should probably go to the graphics window instead.
|
|
SetForegroundWindow(GraphicsWnd);
|
|
}
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
done:
|
|
SS.DoLater();
|
|
}
|
|
|
|
// Write everything back to the registry
|
|
FreezeWindowPos(TextWnd);
|
|
FreezeWindowPos(GraphicsWnd);
|
|
return 0;
|
|
}
|