mirror of
https://github.com/jmarshall23/DoomRTX.git
synced 2026-08-12 16:21:04 +02:00
Justin Marshall
4934 lines
133 KiB
C++
4934 lines
133 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
IceTech GPL Source Code
|
|
Copyright (C) 2026 Justin Marshall
|
|
|
|
This file is part of the IceTech GPL Source Code (?IceTech Source Code?).
|
|
|
|
IceTech Source Code is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
IceTech Source Code is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with IceTech Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the IceTech Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the IceTech Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing Justin Marshall, justinmarshall20@gmail.com
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#include "precompiled.h"
|
|
#pragma hdrstop
|
|
|
|
#include <stdio.h>
|
|
#include <ctype.h>
|
|
|
|
#include "../../sys/win32/rc/Common_resource.h"
|
|
#include "../../sys/win32/rc/ScriptEditor_resource.h"
|
|
|
|
#include "../radiant/qe3.h"
|
|
#include "../radiant/Radiant.h"
|
|
#include "../comafx/DialogGoToLine.h"
|
|
#include "DialogScriptEditor.h"
|
|
#include "../radiant/XYWnd.h"
|
|
|
|
#ifdef ID_DEBUG_MEMORY
|
|
#undef new
|
|
#undef DEBUG_NEW
|
|
#define DEBUG_NEW new
|
|
#endif
|
|
|
|
#ifndef IDC_SCRIPTEDITOR_BUTTON_FIND
|
|
#define IDC_SCRIPTEDITOR_BUTTON_FIND 0x7C10
|
|
#endif
|
|
#ifndef IDC_SCRIPTEDITOR_BUTTON_REPLACE
|
|
#define IDC_SCRIPTEDITOR_BUTTON_REPLACE 0x7C11
|
|
#endif
|
|
#ifndef IDC_SCRIPTEDITOR_BUTTON_GOTOLINE
|
|
#define IDC_SCRIPTEDITOR_BUTTON_GOTOLINE 0x7C12
|
|
#endif
|
|
#ifndef IDC_SCRIPTEDITOR_BUTTON_INTELLISENSE
|
|
#define IDC_SCRIPTEDITOR_BUTTON_INTELLISENSE 0x7C13
|
|
#endif
|
|
#ifndef IDC_SCRIPTEDITOR_INTELLISENSE_LIST
|
|
#define IDC_SCRIPTEDITOR_INTELLISENSE_LIST 0x7C14
|
|
#endif
|
|
#ifndef IDC_SCRIPTEDITOR_TITLE
|
|
#define IDC_SCRIPTEDITOR_TITLE 0x7C15
|
|
#endif
|
|
#ifndef IDC_SCRIPTEDITOR_PATH
|
|
#define IDC_SCRIPTEDITOR_PATH 0x7C16
|
|
#endif
|
|
#ifndef IDC_SCRIPTEDITOR_STATUS
|
|
#define IDC_SCRIPTEDITOR_STATUS 0x7C17
|
|
#endif
|
|
#ifndef IDC_SCRIPTEDITOR_LANGUAGE
|
|
#define IDC_SCRIPTEDITOR_LANGUAGE 0x7C18
|
|
#endif
|
|
#ifndef IDC_SCRIPTEDITOR_BUTTON_NEW
|
|
#define IDC_SCRIPTEDITOR_BUTTON_NEW 0x7C08
|
|
#endif
|
|
#ifndef IDC_SCRIPTEDITOR_BUTTON_OPEN
|
|
#define IDC_SCRIPTEDITOR_BUTTON_OPEN 0x7C19
|
|
#endif
|
|
#ifndef IDC_SCRIPTEDITOR_BUTTON_SAVEAS
|
|
#define IDC_SCRIPTEDITOR_BUTTON_SAVEAS 0x7C1A
|
|
#endif
|
|
#ifndef IDC_SCRIPTEDITOR_SIGNATURE_HELP
|
|
#define IDC_SCRIPTEDITOR_SIGNATURE_HELP 0x7C1B
|
|
#endif
|
|
|
|
#ifndef IDC_SCRIPTBROWSER_FILTER
|
|
#define IDC_SCRIPTBROWSER_FILTER 0x7C50
|
|
#endif
|
|
#ifndef IDC_SCRIPTBROWSER_LIST
|
|
#define IDC_SCRIPTBROWSER_LIST 0x7C51
|
|
#endif
|
|
#ifndef IDC_SCRIPTBROWSER_LOCAL
|
|
#define IDC_SCRIPTBROWSER_LOCAL 0x7C52
|
|
#endif
|
|
#ifndef IDC_SCRIPTBROWSER_PANEL
|
|
#define IDC_SCRIPTBROWSER_PANEL 0x7C53
|
|
#endif
|
|
#ifndef ID_FILE_NEW
|
|
#define ID_FILE_NEW 0xE100
|
|
#endif
|
|
#ifndef ID_FILE_SAVE
|
|
#define ID_FILE_SAVE 0xE103
|
|
#endif
|
|
#ifndef ID_FILE_SAVE_AS
|
|
#define ID_FILE_SAVE_AS 0xE104
|
|
#endif
|
|
#ifndef ID_SCRIPTEDITOR_INDEX_TIMER
|
|
#define ID_SCRIPTEDITOR_INDEX_TIMER 0x7C80
|
|
#endif
|
|
|
|
|
|
#ifndef IDC_SCRIPTSAVE_PATH
|
|
#define IDC_SCRIPTSAVE_PATH 0x7C70
|
|
#endif
|
|
#ifndef IDC_SCRIPTSAVE_LOCAL
|
|
#define IDC_SCRIPTSAVE_LOCAL 0x7C71
|
|
#endif
|
|
#ifndef IDC_SCRIPTSAVE_PANEL
|
|
#define IDC_SCRIPTSAVE_PANEL 0x7C72
|
|
#endif
|
|
|
|
#ifndef WM_SCRIPTEDITOR_DEFERRED_INTELLISENSE
|
|
#define WM_SCRIPTEDITOR_DEFERRED_INTELLISENSE (WM_USER + 0x531)
|
|
#endif
|
|
#ifndef WM_SCRIPTEDITOR_INTELLISENSE_KEY
|
|
#define WM_SCRIPTEDITOR_INTELLISENSE_KEY (WM_USER + 0x532)
|
|
#endif
|
|
#ifndef EN_SELCHANGE
|
|
#define EN_SELCHANGE 0x0702
|
|
#endif
|
|
|
|
static const COLORREF SE_DARK_BG = RGB(14, 16, 20);
|
|
static const COLORREF SE_DARK_PANEL = RGB(22, 25, 31);
|
|
static const COLORREF SE_DARK_PANEL_2 = RGB(28, 32, 40);
|
|
static const COLORREF SE_DARK_EDIT = RGB(11, 13, 18);
|
|
static const COLORREF SE_DARK_EDIT_LINE = RGB(15, 18, 24);
|
|
static const COLORREF SE_DARK_GUTTER = RGB(18, 21, 27);
|
|
static const COLORREF SE_DARK_BORDER = RGB(58, 66, 78);
|
|
static const COLORREF SE_DARK_TEXT = RGB(226, 232, 240);
|
|
static const COLORREF SE_DARK_MUTED = RGB(148, 163, 184);
|
|
static const COLORREF SE_DARK_DISABLED = RGB(95, 105, 122);
|
|
static const COLORREF SE_DARK_ACCENT = RGB(87, 166, 255);
|
|
static const COLORREF SE_DARK_WARNING = RGB(251, 191, 36);
|
|
static const COLORREF SE_DARK_SELECTION = RGB(37, 83, 128);
|
|
static const COLORREF SE_DARK_SELECTION_TEXT = RGB(245, 249, 255);
|
|
static const COLORREF SE_DARK_COMMENT = RGB(128, 190, 106);
|
|
static const COLORREF SE_DARK_STRING = RGB(206, 145, 120);
|
|
static const COLORREF SE_DARK_ALT_STRING = RGB(214, 157, 133);
|
|
static const COLORREF SE_DARK_NUMBER = RGB(181, 206, 168);
|
|
static const COLORREF SE_DARK_KEYWORD = RGB(86, 156, 214);
|
|
static const COLORREF SE_DARK_TYPE = RGB(78, 201, 176);
|
|
static const COLORREF SE_DARK_FUNCTION = RGB(220, 220, 170);
|
|
static const COLORREF SE_DARK_OPERATOR = RGB(212, 212, 212);
|
|
static const COLORREF SE_DARK_LINE_NUMBER = RGB(93, 101, 116);
|
|
static const COLORREF SE_DARK_CARET = RGB(245, 249, 255);
|
|
|
|
static const int SE_TAB_SIZE = 4;
|
|
static const int SE_MIN_EDITOR_WIDTH = 360;
|
|
static const int SE_MIN_EDITOR_HEIGHT = 220;
|
|
static const UINT_PTR SE_INTELLISENSE_TIMER_ID = 0x7CF0;
|
|
|
|
#ifndef CLEARTYPE_NATURAL_QUALITY
|
|
#define CLEARTYPE_NATURAL_QUALITY 6
|
|
#endif
|
|
|
|
static bool ScriptEditorCreateFontPixels(CFont& font, const char* faceName, int pointSize, bool mono) {
|
|
if (font.GetSafeHandle()) {
|
|
font.DeleteObject();
|
|
}
|
|
|
|
HDC hDC = ::GetDC(NULL);
|
|
int dpiY = hDC ? ::GetDeviceCaps(hDC, LOGPIXELSY) : 96;
|
|
if (hDC) {
|
|
::ReleaseDC(NULL, hDC);
|
|
}
|
|
|
|
LOGFONTA lf;
|
|
memset(&lf, 0, sizeof(lf));
|
|
|
|
lf.lfHeight = -MulDiv(pointSize, dpiY, 72);
|
|
lf.lfWeight = FW_NORMAL;
|
|
lf.lfCharSet = ANSI_CHARSET;
|
|
lf.lfOutPrecision = OUT_TT_PRECIS;
|
|
lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
|
|
lf.lfQuality = CLEARTYPE_NATURAL_QUALITY;
|
|
lf.lfPitchAndFamily = mono ? (FIXED_PITCH | FF_MODERN) : (VARIABLE_PITCH | FF_SWISS);
|
|
|
|
const char* fallbackFace = mono ? "Consolas" : "Segoe UI";
|
|
idStr::Copynz(lf.lfFaceName, faceName && faceName[0] ? faceName : fallbackFace, sizeof(lf.lfFaceName));
|
|
|
|
return font.CreateFontIndirectA(&lf) != FALSE;
|
|
}
|
|
|
|
|
|
static UINT FindDialogMessage = ::RegisterWindowMessage(FINDMSGSTRING);
|
|
|
|
typedef struct scriptEventInfo_s {
|
|
idStr name;
|
|
idStr parms;
|
|
idStr help;
|
|
} scriptEventInfo_t;
|
|
|
|
static idList<scriptEventInfo_t> scriptEvents;
|
|
|
|
typedef struct scriptCompletionInfo_s {
|
|
idStr name;
|
|
idStr insertText;
|
|
idStr kind;
|
|
idStr source;
|
|
idStr help;
|
|
int weight;
|
|
} scriptCompletionInfo_t;
|
|
|
|
static idList<scriptCompletionInfo_t> scriptCompletions;
|
|
static idList<idStr> scriptVirtualFiles;
|
|
static bool scriptCoreBuilt = false;
|
|
static bool scriptDatabaseBuilt = false;
|
|
static bool scriptVirtualFileListBuilt = false;
|
|
static DialogScriptEditor* g_StandaloneScriptEditor = NULL;
|
|
|
|
DialogScriptEditor* DialogScriptEditor::primaryEditor = NULL;
|
|
|
|
static const char* scriptKeywords[] = {
|
|
"accum", "ai", "boolean", "break", "case", "catch", "const", "continue",
|
|
"default", "do", "else", "entity", "float", "for", "function", "if",
|
|
"integer", "namespace", "object", "return", "scriptEvent", "string", "sys",
|
|
"thread", "true", "false", "vector", "void", "while", NULL
|
|
};
|
|
|
|
static const char* guiKeywords[] = {
|
|
"windowDef", "renderDef", "choiceDef", "editDef", "listDef", "bindDef", "onAction",
|
|
"onInit", "onTime", "onNamedEvent", "rect", "visible", "text", "forecolor",
|
|
"backcolor", "matcolor", "background", "font", "textscale", "float", "vec4", NULL
|
|
};
|
|
|
|
static void ScriptEditorActivateDockParent(DialogScriptEditor* editor) {
|
|
if (!editor || !editor->GetSafeHwnd()) {
|
|
return;
|
|
}
|
|
|
|
for (CWnd* parent = editor->GetParent(); parent && parent->GetSafeHwnd(); parent = parent->GetParent()) {
|
|
if (parent->IsKindOf(RUNTIME_CLASS(CXYDockWnd))) {
|
|
static_cast<CXYDockWnd*>(parent)->SelectScriptEditorTab();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void ScriptEditorFillRect(HDC hDC, const RECT& rc, COLORREF color) {
|
|
HBRUSH brush = ::CreateSolidBrush(color);
|
|
::FillRect(hDC, &rc, brush);
|
|
::DeleteObject(brush);
|
|
}
|
|
|
|
static void ScriptEditorFrameRect(HDC hDC, const RECT& rc, COLORREF color) {
|
|
HBRUSH brush = ::CreateSolidBrush(color);
|
|
::FrameRect(hDC, &rc, brush);
|
|
::DeleteObject(brush);
|
|
}
|
|
|
|
static void ScriptEditorApplyNativeDarkTheme(HWND hWnd) {
|
|
if (!hWnd) {
|
|
return;
|
|
}
|
|
|
|
typedef HRESULT(WINAPI* SetWindowThemeProc)(HWND, LPCWSTR, LPCWSTR);
|
|
typedef BOOL(WINAPI* AllowDarkModeForWindowProc)(HWND, BOOL);
|
|
static HMODULE hUxTheme = ::LoadLibraryA("uxtheme.dll");
|
|
static SetWindowThemeProc pSetWindowTheme = hUxTheme ? (SetWindowThemeProc)::GetProcAddress(hUxTheme, "SetWindowTheme") : NULL;
|
|
static AllowDarkModeForWindowProc pAllowDarkModeForWindow = hUxTheme ? (AllowDarkModeForWindowProc)::GetProcAddress(hUxTheme, MAKEINTRESOURCEA(133)) : NULL;
|
|
|
|
if (pAllowDarkModeForWindow) {
|
|
pAllowDarkModeForWindow(hWnd, TRUE);
|
|
}
|
|
if (pSetWindowTheme) {
|
|
pSetWindowTheme(hWnd, L"DarkMode_Explorer", NULL);
|
|
}
|
|
::SendMessage(hWnd, WM_THEMECHANGED, 0, 0);
|
|
}
|
|
|
|
static CString ScriptEditorNormalizeText(const char* text) {
|
|
CString out = text ? text : "";
|
|
out.Replace("\r\n", "\n");
|
|
out.Replace("\r", "\n");
|
|
out.Replace("\v", "\n");
|
|
return out;
|
|
}
|
|
|
|
static CString ScriptEditorToCRLF(const CString& text) {
|
|
CString out = text;
|
|
out.Replace("\r\n", "\n");
|
|
out.Replace("\r", "\n");
|
|
out.Replace("\n", "\r\n");
|
|
return out;
|
|
}
|
|
|
|
static bool ScriptEditorIsIdentifierChar(int ch) {
|
|
return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') || ch == '_' || ch == '#';
|
|
}
|
|
|
|
static bool ScriptEditorIsIdentifierStart(int ch) {
|
|
return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == '_' || ch == '#';
|
|
}
|
|
|
|
static bool ScriptEditorIsSpaceOrTab(int ch) {
|
|
return ch == ' ' || ch == '\t';
|
|
}
|
|
|
|
static bool ScriptEditorIsTypeKeyword(const CString& word) {
|
|
return word == "void" || word == "float" || word == "integer" || word == "boolean" || word == "string" ||
|
|
word == "vector" || word == "entity" || word == "object" || word == "windowDef" || word == "vec4";
|
|
}
|
|
|
|
static int ScriptEditorUpperChar(int ch) {
|
|
if (ch >= 'a' && ch <= 'z') {
|
|
return ch - 'a' + 'A';
|
|
}
|
|
return ch;
|
|
}
|
|
|
|
static int ScriptEditorCompareNoCase(const CString& a, const CString& b) {
|
|
CString aa = a;
|
|
CString bb = b;
|
|
aa.MakeLower();
|
|
bb.MakeLower();
|
|
return aa.Compare(bb);
|
|
}
|
|
|
|
|
|
static bool ScriptEditorIsKeywordName(const char* name) {
|
|
if (!name || !name[0]) {
|
|
return false;
|
|
}
|
|
for (int i = 0; scriptKeywords[i]; i++) {
|
|
if (idStr::Icmp(scriptKeywords[i], name) == 0) {
|
|
return true;
|
|
}
|
|
}
|
|
for (int i = 0; guiKeywords[i]; i++) {
|
|
if (idStr::Icmp(guiKeywords[i], name) == 0) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static CString ScriptEditorNormalizeVirtualPath(const char* path) {
|
|
CString out = path ? path : "";
|
|
out.TrimLeft();
|
|
out.TrimRight();
|
|
out.Replace("\\", "/");
|
|
while (out.Find("//") >= 0) {
|
|
out.Replace("//", "/");
|
|
}
|
|
return out;
|
|
}
|
|
|
|
static bool ScriptEditorHasExtension(const CString& path, const char* extension) {
|
|
CString ext = extension ? extension : "";
|
|
CString p = path;
|
|
ext.MakeLower();
|
|
p.MakeLower();
|
|
if (ext.GetLength() <= 0) {
|
|
return true;
|
|
}
|
|
if (ext[0] != '.') {
|
|
ext = "." + ext;
|
|
}
|
|
return p.Right(ext.GetLength()) == ext;
|
|
}
|
|
|
|
static void ScriptEditorAddVirtualFile(const char* basePath, const char* fileName) {
|
|
CString file = ScriptEditorNormalizeVirtualPath(fileName);
|
|
CString base = ScriptEditorNormalizeVirtualPath(basePath);
|
|
|
|
while (file.GetLength() > 0 && (file[0] == '/' || file[0] == '\\')) {
|
|
file.Delete(0, 1);
|
|
}
|
|
while (base.GetLength() > 0 && (base[base.GetLength() - 1] == '/' || base[base.GetLength() - 1] == '\\')) {
|
|
base.Delete(base.GetLength() - 1, 1);
|
|
}
|
|
|
|
if (file.IsEmpty()) {
|
|
return;
|
|
}
|
|
if (!ScriptEditorHasExtension(file, ".script") && !ScriptEditorHasExtension(file, ".gui")) {
|
|
return;
|
|
}
|
|
if (!base.IsEmpty()) {
|
|
CString fileLower = file;
|
|
CString baseLower = base;
|
|
fileLower.MakeLower();
|
|
baseLower.MakeLower();
|
|
|
|
const CString baseWithSlash = baseLower + "/";
|
|
if (fileLower != baseLower && fileLower.Left(baseWithSlash.GetLength()) != baseWithSlash) {
|
|
file = base + "/" + file;
|
|
file = ScriptEditorNormalizeVirtualPath(file);
|
|
}
|
|
}
|
|
|
|
while (file.GetLength() > 0 && file[0] == '/') {
|
|
file.Delete(0, 1);
|
|
}
|
|
|
|
for (int i = 0; i < scriptVirtualFiles.Num(); i++) {
|
|
if (scriptVirtualFiles[i].Icmp(file) == 0) {
|
|
return;
|
|
}
|
|
}
|
|
scriptVirtualFiles.Append(idStr(file));
|
|
}
|
|
|
|
static void ScriptEditorListVirtualFilesFromTree(const char* basePath, const char* extension) {
|
|
if (!fileSystem || !basePath || !extension) {
|
|
return;
|
|
}
|
|
|
|
idFileList* treeList = fileSystem->ListFilesTree(basePath, extension, true);
|
|
if (treeList) {
|
|
for (int i = 0; i < treeList->GetNumFiles(); i++) {
|
|
ScriptEditorAddVirtualFile(basePath, treeList->GetFile(i));
|
|
}
|
|
fileSystem->FreeFileList(treeList);
|
|
}
|
|
|
|
// Some idFileSystem implementations only expose pk4/pk5-backed files through
|
|
// ListFiles(..., fullRelativePath = true), so collect both ways.
|
|
idFileList* flatList = fileSystem->ListFiles(basePath, extension, true, true);
|
|
if (flatList) {
|
|
for (int i = 0; i < flatList->GetNumFiles(); i++) {
|
|
ScriptEditorAddVirtualFile(basePath, flatList->GetFile(i));
|
|
}
|
|
fileSystem->FreeFileList(flatList);
|
|
}
|
|
}
|
|
|
|
static void ScriptEditorAddCompletion(const char* name, const char* insertText, const char* kind, const char* source, const char* help, int weight) {
|
|
if (!name || !name[0]) {
|
|
return;
|
|
}
|
|
if (idStr::Length(name) > 128) {
|
|
return;
|
|
}
|
|
if (!ScriptEditorIsIdentifierStart(name[0])) {
|
|
return;
|
|
}
|
|
|
|
for (const char* p = name; *p; p++) {
|
|
if (!ScriptEditorIsIdentifierChar(*p) && *p != ':') {
|
|
return;
|
|
}
|
|
}
|
|
|
|
const char* completionKind = kind && kind[0] ? kind : "symbol";
|
|
for (int i = 0; i < scriptCompletions.Num(); i++) {
|
|
if (scriptCompletions[i].name.Icmp(name) == 0 && scriptCompletions[i].kind.Icmp(completionKind) == 0) {
|
|
if (weight > scriptCompletions[i].weight) {
|
|
scriptCompletions[i].insertText = insertText && insertText[0] ? insertText : name;
|
|
scriptCompletions[i].source = source && source[0] ? source : "";
|
|
scriptCompletions[i].help = help && help[0] ? help : "";
|
|
scriptCompletions[i].weight = weight;
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
scriptCompletionInfo_t completion;
|
|
completion.name = name;
|
|
completion.insertText = insertText && insertText[0] ? insertText : name;
|
|
completion.kind = completionKind;
|
|
completion.source = source && source[0] ? source : "";
|
|
completion.help = help && help[0] ? help : "";
|
|
completion.weight = weight;
|
|
scriptCompletions.Append(completion);
|
|
}
|
|
|
|
static void ScriptEditorRemoveCompletionsFromSource(const char* sourceName) {
|
|
if (!sourceName || !sourceName[0]) {
|
|
return;
|
|
}
|
|
for (int i = scriptCompletions.Num() - 1; i >= 0; i--) {
|
|
if (scriptCompletions[i].source.Icmp(sourceName) == 0) {
|
|
scriptCompletions.RemoveIndex(i);
|
|
}
|
|
}
|
|
}
|
|
|
|
static int ScriptEditorFindNextNonSpace(const CString& text, int index) {
|
|
while (index < text.GetLength() && (text[index] == ' ' || text[index] == '\t' || text[index] == '\r' || text[index] == '\n')) {
|
|
index++;
|
|
}
|
|
return index;
|
|
}
|
|
|
|
static CString ScriptEditorReadIdentifierAt(const CString& text, int index, int* endIndex = NULL) {
|
|
CString word;
|
|
if (index < 0 || index >= text.GetLength() || !ScriptEditorIsIdentifierStart(text[index])) {
|
|
if (endIndex) {
|
|
*endIndex = index;
|
|
}
|
|
return word;
|
|
}
|
|
int i = index;
|
|
while (i < text.GetLength() && ScriptEditorIsIdentifierChar(text[i])) {
|
|
word += text[i];
|
|
i++;
|
|
}
|
|
if (endIndex) {
|
|
*endIndex = i;
|
|
}
|
|
return word;
|
|
}
|
|
|
|
static CString ScriptEditorPreviousIdentifier(const CString& text, int index) {
|
|
int i = index - 1;
|
|
while (i >= 0 && (text[i] == ' ' || text[i] == '\t' || text[i] == '\r' || text[i] == '\n')) {
|
|
i--;
|
|
}
|
|
if (i < 0 || !ScriptEditorIsIdentifierChar(text[i])) {
|
|
return "";
|
|
}
|
|
int end = i + 1;
|
|
while (i >= 0 && ScriptEditorIsIdentifierChar(text[i])) {
|
|
i--;
|
|
}
|
|
return text.Mid(i + 1, end - (i + 1));
|
|
}
|
|
|
|
static void ScriptEditorScanTextForCompletions(const char* sourceName, const char* rawText) {
|
|
CString text = ScriptEditorNormalizeText(rawText);
|
|
CString previousWord;
|
|
bool inString = false;
|
|
bool inLiteral = false;
|
|
bool inLineComment = false;
|
|
bool inBlockComment = false;
|
|
|
|
for (int i = 0; i < text.GetLength(); ) {
|
|
char ch = text[i];
|
|
char next = (i + 1 < text.GetLength()) ? text[i + 1] : '\0';
|
|
|
|
if (inLineComment) {
|
|
if (ch == '\n') {
|
|
inLineComment = false;
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
if (inBlockComment) {
|
|
if (ch == '*' && next == '/') {
|
|
inBlockComment = false;
|
|
i += 2;
|
|
}
|
|
else {
|
|
i++;
|
|
}
|
|
continue;
|
|
}
|
|
if (inString) {
|
|
if (ch == '"' && (i == 0 || text[i - 1] != '\\')) {
|
|
inString = false;
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
if (inLiteral) {
|
|
if (ch == '\'' && (i == 0 || text[i - 1] != '\\')) {
|
|
inLiteral = false;
|
|
}
|
|
i++;
|
|
continue;
|
|
}
|
|
|
|
if (ch == '/' && next == '/') {
|
|
inLineComment = true;
|
|
i += 2;
|
|
continue;
|
|
}
|
|
if (ch == '/' && next == '*') {
|
|
inBlockComment = true;
|
|
i += 2;
|
|
continue;
|
|
}
|
|
if (ch == '"') {
|
|
inString = true;
|
|
i++;
|
|
continue;
|
|
}
|
|
if (ch == '\'') {
|
|
inLiteral = true;
|
|
i++;
|
|
continue;
|
|
}
|
|
|
|
if (ScriptEditorIsIdentifierStart(ch)) {
|
|
int wordEnd = i;
|
|
CString word = ScriptEditorReadIdentifierAt(text, i, &wordEnd);
|
|
int after = ScriptEditorFindNextNonSpace(text, wordEnd);
|
|
char afterChar = after < text.GetLength() ? text[after] : '\0';
|
|
CString prev = previousWord;
|
|
CString prevLower = prev;
|
|
prevLower.MakeLower();
|
|
|
|
if (!ScriptEditorIsKeywordName(word) && word.GetLength() >= 2) {
|
|
if (afterChar == '(') {
|
|
CString signature = word;
|
|
int sigEnd = after;
|
|
int depth = 0;
|
|
for (int s = after; s < text.GetLength() && s - after < 240; s++) {
|
|
char sigCh = text[s];
|
|
if (sigCh == '(') {
|
|
depth++;
|
|
}
|
|
else if (sigCh == ')') {
|
|
depth--;
|
|
if (depth <= 0) {
|
|
sigEnd = s;
|
|
break;
|
|
}
|
|
}
|
|
else if (sigCh == '\n' || sigCh == ';' || sigCh == '{') {
|
|
sigEnd = s - 1;
|
|
break;
|
|
}
|
|
sigEnd = s;
|
|
}
|
|
if (sigEnd >= after) {
|
|
signature += text.Mid(after, sigEnd - after + 1);
|
|
}
|
|
signature.Replace("\n", " ");
|
|
signature.Replace("\t", " ");
|
|
ScriptEditorAddCompletion(word, word, "function", sourceName, signature, 85);
|
|
}
|
|
else if (prevLower == "object") {
|
|
ScriptEditorAddCompletion(word, word, "object", sourceName, sourceName, 80);
|
|
}
|
|
else if (prevLower == "namespace") {
|
|
ScriptEditorAddCompletion(word, word, "namespace", sourceName, sourceName, 70);
|
|
}
|
|
else if (ScriptEditorIsTypeKeyword(prev)) {
|
|
ScriptEditorAddCompletion(word, word, "variable", sourceName, sourceName, 55);
|
|
}
|
|
else if (word.GetLength() >= 3) {
|
|
ScriptEditorAddCompletion(word, word, "symbol", sourceName, sourceName, 20);
|
|
}
|
|
}
|
|
|
|
previousWord = word;
|
|
i = wordEnd;
|
|
continue;
|
|
}
|
|
|
|
i++;
|
|
}
|
|
}
|
|
|
|
|
|
static void ScriptEditorSubclassButton(CWnd& wnd);
|
|
|
|
static bool ScriptEditorIsModalInputMessage(UINT message) {
|
|
return (message >= WM_KEYFIRST && message <= WM_KEYLAST) ||
|
|
(message >= WM_MOUSEFIRST && message <= WM_MOUSELAST) ||
|
|
message == WM_NCLBUTTONDOWN || message == WM_NCRBUTTONDOWN ||
|
|
message == WM_NCMBUTTONDOWN || message == WM_NCLBUTTONDBLCLK ||
|
|
message == WM_NCRBUTTONDBLCLK || message == WM_NCMBUTTONDBLCLK;
|
|
}
|
|
|
|
static bool ScriptEditorMessageTargetsWindow(HWND root, HWND target) {
|
|
return root && target && (target == root || ::IsChild(root, target));
|
|
}
|
|
|
|
static void ScriptEditorCenterChildRectOnOwner(CRect& rect, CWnd* owner) {
|
|
if (!owner || !owner->GetSafeHwnd()) {
|
|
return;
|
|
}
|
|
|
|
CRect client;
|
|
owner->GetClientRect(client);
|
|
|
|
int wantedW = rect.Width();
|
|
int wantedH = rect.Height();
|
|
|
|
const int margin = 18;
|
|
if (wantedW > client.Width() - margin * 2) {
|
|
wantedW = max(260, client.Width() - margin * 2);
|
|
}
|
|
if (wantedH > client.Height() - margin * 2) {
|
|
wantedH = max(160, client.Height() - margin * 2);
|
|
}
|
|
|
|
int x = client.left + (client.Width() - wantedW) / 2;
|
|
int y = client.top + (client.Height() - wantedH) / 2;
|
|
if (x < client.left + margin) {
|
|
x = client.left + margin;
|
|
}
|
|
if (y < client.top + margin) {
|
|
y = client.top + margin;
|
|
}
|
|
rect.SetRect(x, y, x + wantedW, y + wantedH);
|
|
}
|
|
|
|
//=============================================================================
|
|
// Script file browser for files exposed by the Doom filesystem, including pk5s.
|
|
// This is a lightweight modal CWnd rather than a resource-template dialog so the
|
|
// editor can be dropped into existing tools projects without adding new .rc data.
|
|
//=============================================================================
|
|
class CScriptFileBrowserWnd : public CWnd {
|
|
DECLARE_DYNAMIC(CScriptFileBrowserWnd)
|
|
|
|
public:
|
|
CScriptFileBrowserWnd();
|
|
virtual ~CScriptFileBrowserWnd();
|
|
|
|
INT_PTR DoModal(CWnd* owner, CString& selectedPath);
|
|
|
|
protected:
|
|
afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
|
|
afx_msg void OnSize(UINT nType, int cx, int cy);
|
|
afx_msg BOOL OnEraseBkgnd(CDC* pDC);
|
|
afx_msg HBRUSH OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor);
|
|
afx_msg void OnPaint();
|
|
afx_msg void OnFilterChanged();
|
|
afx_msg void OnOpen();
|
|
afx_msg void OnCancel();
|
|
afx_msg void OnLocalFile();
|
|
afx_msg void OnListDoubleClick();
|
|
afx_msg void OnClose();
|
|
|
|
DECLARE_MESSAGE_MAP()
|
|
|
|
private:
|
|
CStatic m_title;
|
|
CStatic m_filterLabel;
|
|
CEdit m_filter;
|
|
CListBox m_list;
|
|
CButton m_open;
|
|
CButton m_cancel;
|
|
CButton m_local;
|
|
CFont m_font;
|
|
CBrush m_backBrush;
|
|
CBrush m_panelBrush;
|
|
CBrush m_editBrush;
|
|
CString m_selectedPath;
|
|
INT_PTR m_result;
|
|
bool m_done;
|
|
|
|
private:
|
|
void LayoutChildren(void);
|
|
void RebuildList(void);
|
|
void Finish(INT_PTR result);
|
|
};
|
|
|
|
IMPLEMENT_DYNAMIC(CScriptFileBrowserWnd, CWnd)
|
|
|
|
BEGIN_MESSAGE_MAP(CScriptFileBrowserWnd, CWnd)
|
|
ON_WM_CREATE()
|
|
ON_WM_SIZE()
|
|
ON_WM_ERASEBKGND()
|
|
ON_WM_CTLCOLOR()
|
|
ON_WM_PAINT()
|
|
ON_WM_CLOSE()
|
|
ON_EN_CHANGE(IDC_SCRIPTBROWSER_FILTER, OnFilterChanged)
|
|
ON_LBN_DBLCLK(IDC_SCRIPTBROWSER_LIST, OnListDoubleClick)
|
|
ON_BN_CLICKED(IDOK, OnOpen)
|
|
ON_BN_CLICKED(IDCANCEL, OnCancel)
|
|
ON_BN_CLICKED(IDC_SCRIPTBROWSER_LOCAL, OnLocalFile)
|
|
END_MESSAGE_MAP()
|
|
|
|
CScriptFileBrowserWnd::CScriptFileBrowserWnd()
|
|
: m_result(0)
|
|
, m_done(false) {
|
|
m_backBrush.CreateSolidBrush(SE_DARK_BG);
|
|
m_panelBrush.CreateSolidBrush(SE_DARK_PANEL);
|
|
m_editBrush.CreateSolidBrush(SE_DARK_EDIT);
|
|
}
|
|
|
|
CScriptFileBrowserWnd::~CScriptFileBrowserWnd() {
|
|
}
|
|
|
|
INT_PTR CScriptFileBrowserWnd::DoModal(CWnd* owner, CString& selectedPath) {
|
|
selectedPath.Empty();
|
|
m_selectedPath.Empty();
|
|
m_result = 0;
|
|
m_done = false;
|
|
|
|
if (owner == NULL || !owner->GetSafeHwnd()) {
|
|
common->Printf("Script Editor: cannot open VFS browser without a valid editor parent.\n");
|
|
return IDCANCEL;
|
|
}
|
|
|
|
CString className = AfxRegisterWndClass(
|
|
CS_DBLCLKS,
|
|
::LoadCursor(NULL, IDC_ARROW),
|
|
(HBRUSH)m_backBrush.GetSafeHandle(),
|
|
NULL
|
|
);
|
|
|
|
CRect rect(0, 0, 760, 520);
|
|
ScriptEditorCenterChildRectOnOwner(rect, owner);
|
|
|
|
if (className.IsEmpty()) {
|
|
common->Printf("Script Editor: failed to register VFS browser window class.\n");
|
|
return IDCANCEL;
|
|
}
|
|
|
|
// This used to be a top-level WS_POPUP window with its owner disabled.
|
|
// In the Radiant tab host that could leave a separate owner/tool window in
|
|
// front and make the browser itself impossible to click. Keep it as an
|
|
// in-tab child overlay instead: no owner disabling, no SetForegroundWindow,
|
|
// no taskbar/tool-window focus handoff.
|
|
if (!CreateEx(
|
|
WS_EX_CLIENTEDGE | WS_EX_CONTROLPARENT,
|
|
className,
|
|
"Open Script From PK5 / VFS",
|
|
WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
|
|
rect,
|
|
owner,
|
|
IDC_SCRIPTBROWSER_PANEL
|
|
)) {
|
|
common->Printf("Script Editor: failed to create in-tab VFS browser window, GetLastError=%lu.\n", ::GetLastError());
|
|
return IDCANCEL;
|
|
}
|
|
|
|
HWND oldFocus = ::GetFocus();
|
|
ShowWindow(SW_SHOW);
|
|
SetWindowPos(&wndTop, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
|
|
UpdateWindow();
|
|
if (m_filter.GetSafeHwnd()) {
|
|
m_filter.SetFocus();
|
|
}
|
|
|
|
MSG msg;
|
|
while (!m_done && GetSafeHwnd() && ::GetMessage(&msg, NULL, 0, 0)) {
|
|
if (ScriptEditorIsModalInputMessage(msg.message) &&
|
|
!ScriptEditorMessageTargetsWindow(GetSafeHwnd(), msg.hwnd)) {
|
|
if (m_filter.GetSafeHwnd()) {
|
|
m_filter.SetFocus();
|
|
}
|
|
continue;
|
|
}
|
|
if (!IsDialogMessage(&msg)) {
|
|
::TranslateMessage(&msg);
|
|
::DispatchMessage(&msg);
|
|
}
|
|
}
|
|
|
|
if (oldFocus && ::IsWindow(oldFocus)) {
|
|
::SetFocus(oldFocus);
|
|
}
|
|
if (GetSafeHwnd()) {
|
|
DestroyWindow();
|
|
}
|
|
|
|
selectedPath = m_selectedPath;
|
|
return m_result ? m_result : IDCANCEL;
|
|
}
|
|
|
|
int CScriptFileBrowserWnd::OnCreate(LPCREATESTRUCT lpCreateStruct) {
|
|
if (CWnd::OnCreate(lpCreateStruct) == -1) {
|
|
return -1;
|
|
}
|
|
|
|
m_font.CreatePointFont(85, "MS Shell Dlg");
|
|
m_title.Create("Open a script from the loaded pk5/dev filesystem", WS_CHILD | WS_VISIBLE | SS_CENTERIMAGE, CRect(0, 0, 0, 0), this);
|
|
m_filterLabel.Create("Filter:", WS_CHILD | WS_VISIBLE | SS_CENTERIMAGE, CRect(0, 0, 0, 0), this);
|
|
m_filter.Create(WS_CHILD | WS_VISIBLE | WS_TABSTOP | WS_BORDER | ES_AUTOHSCROLL, CRect(0, 0, 0, 0), this, IDC_SCRIPTBROWSER_FILTER);
|
|
m_list.Create(WS_CHILD | WS_VISIBLE | WS_TABSTOP | WS_BORDER | WS_VSCROLL | LBS_NOTIFY | LBS_NOINTEGRALHEIGHT | LBS_SORT, CRect(0, 0, 0, 0), this, IDC_SCRIPTBROWSER_LIST);
|
|
m_open.Create("Open", WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_DEFPUSHBUTTON, CRect(0, 0, 0, 0), this, IDOK);
|
|
m_cancel.Create("Cancel", WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_PUSHBUTTON, CRect(0, 0, 0, 0), this, IDCANCEL);
|
|
m_local.Create("Local...", WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_PUSHBUTTON, CRect(0, 0, 0, 0), this, IDC_SCRIPTBROWSER_LOCAL);
|
|
|
|
CWnd* windows[] = { &m_title, &m_filterLabel, &m_filter, &m_list, &m_open, &m_cancel, &m_local };
|
|
for (int i = 0; i < sizeof(windows) / sizeof(windows[0]); i++) {
|
|
if (windows[i] && windows[i]->GetSafeHwnd()) {
|
|
windows[i]->SetFont(&m_font);
|
|
}
|
|
}
|
|
|
|
ScriptEditorSubclassButton(m_open);
|
|
ScriptEditorSubclassButton(m_cancel);
|
|
ScriptEditorSubclassButton(m_local);
|
|
ScriptEditorApplyNativeDarkTheme(m_filter.GetSafeHwnd());
|
|
ScriptEditorApplyNativeDarkTheme(m_list.GetSafeHwnd());
|
|
ScriptEditorApplyNativeDarkTheme(m_open.GetSafeHwnd());
|
|
ScriptEditorApplyNativeDarkTheme(m_cancel.GetSafeHwnd());
|
|
ScriptEditorApplyNativeDarkTheme(m_local.GetSafeHwnd());
|
|
|
|
RebuildList();
|
|
LayoutChildren();
|
|
return 0;
|
|
}
|
|
|
|
void CScriptFileBrowserWnd::LayoutChildren(void) {
|
|
if (!GetSafeHwnd()) {
|
|
return;
|
|
}
|
|
CRect client;
|
|
GetClientRect(client);
|
|
const int margin = 12;
|
|
const int buttonW = 86;
|
|
const int buttonH = 25;
|
|
const int gap = 8;
|
|
|
|
if (m_title.GetSafeHwnd()) {
|
|
m_title.MoveWindow(margin, 8, client.Width() - margin * 2, 22, TRUE);
|
|
}
|
|
if (m_filterLabel.GetSafeHwnd()) {
|
|
m_filterLabel.MoveWindow(margin, 38, 46, 22, TRUE);
|
|
}
|
|
if (m_filter.GetSafeHwnd()) {
|
|
m_filter.MoveWindow(margin + 52, 38, client.Width() - margin * 2 - 52, 22, TRUE);
|
|
}
|
|
if (m_list.GetSafeHwnd()) {
|
|
m_list.MoveWindow(margin, 68, client.Width() - margin * 2, client.Height() - 68 - 44, TRUE);
|
|
}
|
|
|
|
int y = client.bottom - 34;
|
|
int x = client.right - margin - buttonW;
|
|
if (m_cancel.GetSafeHwnd()) {
|
|
m_cancel.MoveWindow(x, y, buttonW, buttonH, TRUE);
|
|
}
|
|
x -= buttonW + gap;
|
|
if (m_open.GetSafeHwnd()) {
|
|
m_open.MoveWindow(x, y, buttonW, buttonH, TRUE);
|
|
}
|
|
if (m_local.GetSafeHwnd()) {
|
|
m_local.MoveWindow(margin, y, buttonW, buttonH, TRUE);
|
|
}
|
|
}
|
|
|
|
void CScriptFileBrowserWnd::RebuildList(void) {
|
|
if (!m_list.GetSafeHwnd()) {
|
|
return;
|
|
}
|
|
CString filter;
|
|
if (m_filter.GetSafeHwnd()) {
|
|
m_filter.GetWindowText(filter);
|
|
}
|
|
filter.MakeLower();
|
|
|
|
m_list.ResetContent();
|
|
for (int i = 0; i < scriptVirtualFiles.Num(); i++) {
|
|
CString path = scriptVirtualFiles[i].c_str();
|
|
CString pathLower = path;
|
|
pathLower.MakeLower();
|
|
if (filter.IsEmpty() || pathLower.Find(filter) >= 0) {
|
|
m_list.AddString(path);
|
|
}
|
|
}
|
|
if (m_list.GetCount() > 0) {
|
|
m_list.SetCurSel(0);
|
|
}
|
|
}
|
|
|
|
void CScriptFileBrowserWnd::Finish(INT_PTR result) {
|
|
m_result = result;
|
|
m_done = true;
|
|
}
|
|
|
|
void CScriptFileBrowserWnd::OnSize(UINT nType, int cx, int cy) {
|
|
CWnd::OnSize(nType, cx, cy);
|
|
LayoutChildren();
|
|
}
|
|
|
|
BOOL CScriptFileBrowserWnd::OnEraseBkgnd(CDC* pDC) {
|
|
CRect client;
|
|
GetClientRect(client);
|
|
pDC->FillSolidRect(client, SE_DARK_BG);
|
|
return TRUE;
|
|
}
|
|
|
|
HBRUSH CScriptFileBrowserWnd::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor) {
|
|
if (pDC) {
|
|
pDC->SetBkMode(TRANSPARENT);
|
|
pDC->SetTextColor(SE_DARK_TEXT);
|
|
}
|
|
if (nCtlColor == CTLCOLOR_EDIT || nCtlColor == CTLCOLOR_LISTBOX) {
|
|
if (pDC) {
|
|
pDC->SetBkColor(SE_DARK_EDIT);
|
|
pDC->SetTextColor(SE_DARK_TEXT);
|
|
}
|
|
return (HBRUSH)m_editBrush.GetSafeHandle();
|
|
}
|
|
if (nCtlColor == CTLCOLOR_STATIC) {
|
|
return (HBRUSH)m_backBrush.GetSafeHandle();
|
|
}
|
|
return (HBRUSH)m_backBrush.GetSafeHandle();
|
|
}
|
|
|
|
void CScriptFileBrowserWnd::OnPaint() {
|
|
CPaintDC dc(this);
|
|
CRect client;
|
|
GetClientRect(client);
|
|
dc.FillSolidRect(client, SE_DARK_BG);
|
|
CRect header(client.left, client.top, client.right, 34);
|
|
dc.FillSolidRect(header, SE_DARK_PANEL);
|
|
dc.FillSolidRect(client.left, header.bottom - 1, client.Width(), 1, SE_DARK_BORDER);
|
|
}
|
|
|
|
void CScriptFileBrowserWnd::OnFilterChanged() {
|
|
RebuildList();
|
|
}
|
|
|
|
void CScriptFileBrowserWnd::OnOpen() {
|
|
CString typedPath;
|
|
if (m_filter.GetSafeHwnd()) {
|
|
m_filter.GetWindowText(typedPath);
|
|
typedPath.TrimLeft();
|
|
typedPath.TrimRight();
|
|
typedPath.Replace("\\", "/");
|
|
}
|
|
|
|
const bool typedLooksLikePath =
|
|
!typedPath.IsEmpty() &&
|
|
(typedPath.Find('/') >= 0 || typedPath.Find(':') >= 0 ||
|
|
ScriptEditorHasExtension(typedPath, ".script") ||
|
|
ScriptEditorHasExtension(typedPath, ".gui") ||
|
|
ScriptEditorHasExtension(typedPath, ".txt"));
|
|
|
|
if (typedLooksLikePath) {
|
|
if (!ScriptEditorHasExtension(typedPath, ".script") &&
|
|
!ScriptEditorHasExtension(typedPath, ".gui") &&
|
|
!ScriptEditorHasExtension(typedPath, ".txt")) {
|
|
typedPath += ".script";
|
|
}
|
|
m_selectedPath = typedPath;
|
|
Finish(IDOK);
|
|
return;
|
|
}
|
|
|
|
int sel = m_list.GetCurSel();
|
|
if (sel != LB_ERR) {
|
|
m_list.GetText(sel, m_selectedPath);
|
|
Finish(IDOK);
|
|
return;
|
|
}
|
|
|
|
MessageBox("Select a script file, or type a virtual path such as script/foo.script.", "Open Script", MB_OK | MB_ICONINFORMATION);
|
|
}
|
|
|
|
void CScriptFileBrowserWnd::OnCancel() {
|
|
Finish(IDCANCEL);
|
|
}
|
|
|
|
void CScriptFileBrowserWnd::OnLocalFile() {
|
|
CFileDialog dlg(
|
|
TRUE,
|
|
NULL,
|
|
NULL,
|
|
OFN_HIDEREADONLY | OFN_FILEMUSTEXIST,
|
|
"Script Files (*.script)|*.script|GUI Files (*.gui)|*.gui|Text Files (*.txt)|*.txt|All Files (*.*)|*.*||",
|
|
this
|
|
);
|
|
if (dlg.DoModal() == IDOK) {
|
|
m_selectedPath = dlg.GetPathName();
|
|
Finish(IDOK);
|
|
}
|
|
}
|
|
|
|
void CScriptFileBrowserWnd::OnListDoubleClick() {
|
|
OnOpen();
|
|
}
|
|
|
|
void CScriptFileBrowserWnd::OnClose() {
|
|
Finish(IDCANCEL);
|
|
}
|
|
|
|
|
|
//=============================================================================
|
|
// Save path prompt. Lets users save a new buffer or a pk5-backed override to
|
|
// a virtual dev path such as script/my_new_file.script, with a Local... fallback.
|
|
//=============================================================================
|
|
class CScriptSavePathWnd : public CWnd {
|
|
DECLARE_DYNAMIC(CScriptSavePathWnd)
|
|
|
|
public:
|
|
CScriptSavePathWnd();
|
|
virtual ~CScriptSavePathWnd();
|
|
|
|
INT_PTR DoModal(CWnd* owner, CString& selectedPath, const char* suggestedPath);
|
|
|
|
protected:
|
|
afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
|
|
afx_msg void OnSize(UINT nType, int cx, int cy);
|
|
afx_msg BOOL OnEraseBkgnd(CDC* pDC);
|
|
afx_msg HBRUSH OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor);
|
|
afx_msg void OnPaint();
|
|
afx_msg void OnSave();
|
|
afx_msg void OnCancel();
|
|
afx_msg void OnLocalFile();
|
|
afx_msg void OnClose();
|
|
|
|
DECLARE_MESSAGE_MAP()
|
|
|
|
private:
|
|
CStatic m_title;
|
|
CStatic m_help;
|
|
CEdit m_path;
|
|
CButton m_save;
|
|
CButton m_cancel;
|
|
CButton m_local;
|
|
CFont m_font;
|
|
CBrush m_backBrush;
|
|
CBrush m_panelBrush;
|
|
CBrush m_editBrush;
|
|
CString m_selectedPath;
|
|
CString m_suggestedPath;
|
|
INT_PTR m_result;
|
|
bool m_done;
|
|
|
|
private:
|
|
void LayoutChildren(void);
|
|
void Finish(INT_PTR result);
|
|
};
|
|
|
|
IMPLEMENT_DYNAMIC(CScriptSavePathWnd, CWnd)
|
|
|
|
BEGIN_MESSAGE_MAP(CScriptSavePathWnd, CWnd)
|
|
ON_WM_CREATE()
|
|
ON_WM_SIZE()
|
|
ON_WM_ERASEBKGND()
|
|
ON_WM_CTLCOLOR()
|
|
ON_WM_PAINT()
|
|
ON_WM_CLOSE()
|
|
ON_BN_CLICKED(IDOK, OnSave)
|
|
ON_BN_CLICKED(IDCANCEL, OnCancel)
|
|
ON_BN_CLICKED(IDC_SCRIPTSAVE_LOCAL, OnLocalFile)
|
|
END_MESSAGE_MAP()
|
|
|
|
CScriptSavePathWnd::CScriptSavePathWnd()
|
|
: m_result(0)
|
|
, m_done(false) {
|
|
m_backBrush.CreateSolidBrush(SE_DARK_BG);
|
|
m_panelBrush.CreateSolidBrush(SE_DARK_PANEL);
|
|
m_editBrush.CreateSolidBrush(SE_DARK_EDIT);
|
|
}
|
|
|
|
CScriptSavePathWnd::~CScriptSavePathWnd() {
|
|
}
|
|
|
|
INT_PTR CScriptSavePathWnd::DoModal(CWnd* owner, CString& selectedPath, const char* suggestedPath) {
|
|
selectedPath.Empty();
|
|
m_selectedPath.Empty();
|
|
m_suggestedPath = suggestedPath && suggestedPath[0] ? suggestedPath : "script/new_script.script";
|
|
m_result = 0;
|
|
m_done = false;
|
|
|
|
if (owner == NULL || !owner->GetSafeHwnd()) {
|
|
common->Printf("Script Editor: cannot open Save As prompt without a valid editor parent.\n");
|
|
return IDCANCEL;
|
|
}
|
|
|
|
CString className = AfxRegisterWndClass(
|
|
CS_DBLCLKS,
|
|
::LoadCursor(NULL, IDC_ARROW),
|
|
(HBRUSH)m_backBrush.GetSafeHandle(),
|
|
NULL
|
|
);
|
|
|
|
CRect rect(0, 0, 620, 190);
|
|
ScriptEditorCenterChildRectOnOwner(rect, owner);
|
|
|
|
if (className.IsEmpty()) {
|
|
common->Printf("Script Editor: failed to register Save As window class.\n");
|
|
return IDCANCEL;
|
|
}
|
|
|
|
// Keep Save As inside the script-editor tab for the same reason as the VFS
|
|
// browser: no external tool window, no disabled owner frame, no focus trap.
|
|
if (!CreateEx(
|
|
WS_EX_CLIENTEDGE | WS_EX_CONTROLPARENT,
|
|
className,
|
|
"Save Script As",
|
|
WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
|
|
rect,
|
|
owner,
|
|
IDC_SCRIPTSAVE_PANEL
|
|
)) {
|
|
common->Printf("Script Editor: failed to create in-tab Save As window, GetLastError=%lu.\n", ::GetLastError());
|
|
return IDCANCEL;
|
|
}
|
|
|
|
HWND oldFocus = ::GetFocus();
|
|
ShowWindow(SW_SHOW);
|
|
SetWindowPos(&wndTop, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
|
|
UpdateWindow();
|
|
if (m_path.GetSafeHwnd()) {
|
|
m_path.SetSel(0, -1);
|
|
m_path.SetFocus();
|
|
}
|
|
|
|
MSG msg;
|
|
while (!m_done && GetSafeHwnd() && ::GetMessage(&msg, NULL, 0, 0)) {
|
|
if (ScriptEditorIsModalInputMessage(msg.message) &&
|
|
!ScriptEditorMessageTargetsWindow(GetSafeHwnd(), msg.hwnd)) {
|
|
if (m_path.GetSafeHwnd()) {
|
|
m_path.SetFocus();
|
|
}
|
|
continue;
|
|
}
|
|
if (!IsDialogMessage(&msg)) {
|
|
::TranslateMessage(&msg);
|
|
::DispatchMessage(&msg);
|
|
}
|
|
}
|
|
|
|
if (oldFocus && ::IsWindow(oldFocus)) {
|
|
::SetFocus(oldFocus);
|
|
}
|
|
if (GetSafeHwnd()) {
|
|
DestroyWindow();
|
|
}
|
|
|
|
selectedPath = m_selectedPath;
|
|
return m_result ? m_result : IDCANCEL;
|
|
}
|
|
|
|
int CScriptSavePathWnd::OnCreate(LPCREATESTRUCT lpCreateStruct) {
|
|
if (CWnd::OnCreate(lpCreateStruct) == -1) {
|
|
return -1;
|
|
}
|
|
|
|
m_font.CreatePointFont(85, "MS Shell Dlg");
|
|
m_title.Create("Save script to dev path", WS_CHILD | WS_VISIBLE | SS_CENTERIMAGE, CRect(0, 0, 0, 0), this);
|
|
m_help.Create("Use a virtual path like script/my_file.script to create or override a pk5 script in fs_devpath.", WS_CHILD | WS_VISIBLE | SS_CENTERIMAGE, CRect(0, 0, 0, 0), this);
|
|
m_path.Create(WS_CHILD | WS_VISIBLE | WS_TABSTOP | WS_BORDER | ES_AUTOHSCROLL, CRect(0, 0, 0, 0), this, IDC_SCRIPTSAVE_PATH);
|
|
m_save.Create("Save", WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_DEFPUSHBUTTON, CRect(0, 0, 0, 0), this, IDOK);
|
|
m_cancel.Create("Cancel", WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_PUSHBUTTON, CRect(0, 0, 0, 0), this, IDCANCEL);
|
|
m_local.Create("Local...", WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_PUSHBUTTON, CRect(0, 0, 0, 0), this, IDC_SCRIPTSAVE_LOCAL);
|
|
|
|
CWnd* windows[] = { &m_title, &m_help, &m_path, &m_save, &m_cancel, &m_local };
|
|
for (int i = 0; i < sizeof(windows) / sizeof(windows[0]); i++) {
|
|
if (windows[i] && windows[i]->GetSafeHwnd()) {
|
|
windows[i]->SetFont(&m_font);
|
|
}
|
|
}
|
|
|
|
m_path.SetWindowText(m_suggestedPath);
|
|
ScriptEditorSubclassButton(m_save);
|
|
ScriptEditorSubclassButton(m_cancel);
|
|
ScriptEditorSubclassButton(m_local);
|
|
ScriptEditorApplyNativeDarkTheme(m_path.GetSafeHwnd());
|
|
ScriptEditorApplyNativeDarkTheme(m_save.GetSafeHwnd());
|
|
ScriptEditorApplyNativeDarkTheme(m_cancel.GetSafeHwnd());
|
|
ScriptEditorApplyNativeDarkTheme(m_local.GetSafeHwnd());
|
|
|
|
LayoutChildren();
|
|
return 0;
|
|
}
|
|
|
|
void CScriptSavePathWnd::LayoutChildren(void) {
|
|
if (!GetSafeHwnd()) {
|
|
return;
|
|
}
|
|
CRect client;
|
|
GetClientRect(client);
|
|
const int margin = 12;
|
|
const int buttonW = 86;
|
|
const int buttonH = 25;
|
|
const int gap = 8;
|
|
|
|
if (m_title.GetSafeHwnd()) {
|
|
m_title.MoveWindow(margin, 8, client.Width() - margin * 2, 22, TRUE);
|
|
}
|
|
if (m_help.GetSafeHwnd()) {
|
|
m_help.MoveWindow(margin, 38, client.Width() - margin * 2, 24, TRUE);
|
|
}
|
|
if (m_path.GetSafeHwnd()) {
|
|
m_path.MoveWindow(margin, 72, client.Width() - margin * 2, 24, TRUE);
|
|
}
|
|
|
|
int y = client.bottom - 40;
|
|
int x = client.right - margin - buttonW;
|
|
if (m_cancel.GetSafeHwnd()) {
|
|
m_cancel.MoveWindow(x, y, buttonW, buttonH, TRUE);
|
|
}
|
|
x -= buttonW + gap;
|
|
if (m_save.GetSafeHwnd()) {
|
|
m_save.MoveWindow(x, y, buttonW, buttonH, TRUE);
|
|
}
|
|
if (m_local.GetSafeHwnd()) {
|
|
m_local.MoveWindow(margin, y, buttonW, buttonH, TRUE);
|
|
}
|
|
}
|
|
|
|
void CScriptSavePathWnd::Finish(INT_PTR result) {
|
|
m_result = result;
|
|
m_done = true;
|
|
}
|
|
|
|
void CScriptSavePathWnd::OnSize(UINT nType, int cx, int cy) {
|
|
CWnd::OnSize(nType, cx, cy);
|
|
LayoutChildren();
|
|
}
|
|
|
|
BOOL CScriptSavePathWnd::OnEraseBkgnd(CDC* pDC) {
|
|
CRect client;
|
|
GetClientRect(client);
|
|
pDC->FillSolidRect(client, SE_DARK_BG);
|
|
return TRUE;
|
|
}
|
|
|
|
HBRUSH CScriptSavePathWnd::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor) {
|
|
if (pDC) {
|
|
pDC->SetBkMode(TRANSPARENT);
|
|
pDC->SetTextColor(SE_DARK_TEXT);
|
|
}
|
|
if (nCtlColor == CTLCOLOR_EDIT) {
|
|
if (pDC) {
|
|
pDC->SetBkColor(SE_DARK_EDIT);
|
|
pDC->SetTextColor(SE_DARK_TEXT);
|
|
}
|
|
return (HBRUSH)m_editBrush.GetSafeHandle();
|
|
}
|
|
if (nCtlColor == CTLCOLOR_STATIC) {
|
|
return (HBRUSH)m_backBrush.GetSafeHandle();
|
|
}
|
|
return (HBRUSH)m_backBrush.GetSafeHandle();
|
|
}
|
|
|
|
void CScriptSavePathWnd::OnPaint() {
|
|
CPaintDC dc(this);
|
|
CRect client;
|
|
GetClientRect(client);
|
|
dc.FillSolidRect(client, SE_DARK_BG);
|
|
CRect header(client.left, client.top, client.right, 34);
|
|
dc.FillSolidRect(header, SE_DARK_PANEL);
|
|
dc.FillSolidRect(client.left, header.bottom - 1, client.Width(), 1, SE_DARK_BORDER);
|
|
}
|
|
|
|
void CScriptSavePathWnd::OnSave() {
|
|
m_path.GetWindowText(m_selectedPath);
|
|
m_selectedPath.TrimLeft();
|
|
m_selectedPath.TrimRight();
|
|
m_selectedPath.Replace("\\", "/");
|
|
if (m_selectedPath.IsEmpty()) {
|
|
MessageBox("Enter a virtual path such as script/my_script.script.", "Save Script As", MB_OK | MB_ICONINFORMATION);
|
|
return;
|
|
}
|
|
if (!ScriptEditorHasExtension(m_selectedPath, ".script") && !ScriptEditorHasExtension(m_selectedPath, ".gui") && !ScriptEditorHasExtension(m_selectedPath, ".txt")) {
|
|
m_selectedPath += ".script";
|
|
}
|
|
Finish(IDOK);
|
|
}
|
|
|
|
void CScriptSavePathWnd::OnCancel() {
|
|
Finish(IDCANCEL);
|
|
}
|
|
|
|
void CScriptSavePathWnd::OnLocalFile() {
|
|
CFileDialog dlg(
|
|
FALSE,
|
|
"script",
|
|
m_suggestedPath,
|
|
OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT,
|
|
"Script Files (*.script)|*.script|GUI Files (*.gui)|*.gui|Text Files (*.txt)|*.txt|All Files (*.*)|*.*||",
|
|
this
|
|
);
|
|
if (dlg.DoModal() == IDOK) {
|
|
m_selectedPath = dlg.GetPathName();
|
|
Finish(IDOK);
|
|
}
|
|
}
|
|
|
|
void CScriptSavePathWnd::OnClose() {
|
|
Finish(IDCANCEL);
|
|
}
|
|
|
|
//=============================================================================
|
|
// Custom editor control. This is deliberately implemented here instead of using
|
|
// the old syntax-rich edit control so the script editor owns all theme, syntax, selection,
|
|
// caret, scrolling, and IntelliSense behavior.
|
|
//=============================================================================
|
|
class CScriptEditorCtrl : public CWnd {
|
|
DECLARE_DYNAMIC(CScriptEditorCtrl)
|
|
|
|
public:
|
|
CScriptEditorCtrl();
|
|
virtual ~CScriptEditorCtrl();
|
|
|
|
BOOL Create(CWnd* parent, UINT id);
|
|
void LimitText(int maxChars);
|
|
void RefreshMetrics(void);
|
|
|
|
void SetText(const char* text);
|
|
void GetText(idStr& text) const;
|
|
int GetTextLength(void) const;
|
|
int GetLineCount(void) const;
|
|
void GetCursorPos(int& line, int& column, int& character) const;
|
|
void GoToLine(int line);
|
|
|
|
void GetSel(long& start, long& end) const;
|
|
void SetSel(long start, long end);
|
|
CString GetSelText(void) const;
|
|
void ReplaceSel(const char* text, BOOL canUndo);
|
|
|
|
bool FindNext(const char* find, bool matchCase, bool matchWholeWords, bool searchForward);
|
|
int ReplaceAll(const char* find, const char* replace, bool matchCase, bool matchWholeWords);
|
|
|
|
void ClearKeywords(void);
|
|
void AddKeyword(const char* keyword);
|
|
bool LoadKeyWordsFromFile(const char* fileName);
|
|
void ClearFunctionWords(void);
|
|
void AddFunctionWord(const char* word);
|
|
void SetCaseSensitive(bool caseSensitive);
|
|
|
|
CPoint GetCaretPoint(void) const;
|
|
CString GetCurrentWord(long* wordStart = NULL, long* wordEnd = NULL) const;
|
|
|
|
protected:
|
|
afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
|
|
afx_msg void OnPaint();
|
|
afx_msg BOOL OnEraseBkgnd(CDC* pDC);
|
|
afx_msg UINT OnGetDlgCode();
|
|
afx_msg void OnSetFocus(CWnd* oldWnd);
|
|
afx_msg void OnKillFocus(CWnd* newWnd);
|
|
afx_msg void OnSize(UINT nType, int cx, int cy);
|
|
afx_msg void OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar);
|
|
afx_msg void OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar);
|
|
afx_msg BOOL OnMouseWheel(UINT nFlags, short zDelta, CPoint pt);
|
|
afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
|
|
afx_msg void OnLButtonUp(UINT nFlags, CPoint point);
|
|
afx_msg void OnMouseMove(UINT nFlags, CPoint point);
|
|
afx_msg void OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags);
|
|
afx_msg void OnChar(UINT nChar, UINT nRepCnt, UINT nFlags);
|
|
|
|
DECLARE_MESSAGE_MAP()
|
|
|
|
private:
|
|
CString m_text;
|
|
CStringArray m_keywords;
|
|
CStringArray m_functionWords;
|
|
CArray<int, int> m_lineStarts;
|
|
CString m_undoText;
|
|
int m_undoCaret;
|
|
int m_undoAnchor;
|
|
bool m_hasUndo;
|
|
int m_textLimit;
|
|
int m_caret;
|
|
int m_selAnchor;
|
|
int m_firstLine;
|
|
int m_xOffset;
|
|
int m_charWidth;
|
|
int m_lineHeight;
|
|
int m_ascent;
|
|
int m_gutterWidth;
|
|
int m_maxColumns;
|
|
int m_preferredColumn;
|
|
bool m_dragging;
|
|
bool m_hasFocus;
|
|
bool m_caseSensitive;
|
|
bool m_inSetText;
|
|
|
|
private:
|
|
void RebuildLineCache(void);
|
|
void UpdateScrollBars(void);
|
|
void UpdateCaret(void);
|
|
void EnsureCaretVisible(void);
|
|
void NotifyChange(void);
|
|
void NotifySelectionChange(void);
|
|
void SaveUndo(void);
|
|
void RestoreUndo(void);
|
|
void QueueIntelliSenseUpdate(bool hide);
|
|
void ReplaceRange(int start, int end, const CString& replacement, bool canUndo, bool notify);
|
|
void DeleteSelectionOrRange(int start, int end);
|
|
void IndentSelection(bool unindent);
|
|
|
|
int ClampIndex(int index) const;
|
|
int GetSelectionStart(void) const;
|
|
int GetSelectionEnd(void) const;
|
|
bool HasSelection(void) const;
|
|
int GetLineFromChar(int index) const;
|
|
int GetLineStart(int line) const;
|
|
int GetLineEnd(int line) const;
|
|
CString GetLineText(int line) const;
|
|
int VisualColumnForLineOffset(int line, int offset) const;
|
|
int CharOffsetFromVisualColumn(int line, int column) const;
|
|
int CharFromPoint(CPoint point) const;
|
|
int VisualColumnFromIndex(int index) const;
|
|
int IndexFromLineAndVisualColumn(int line, int column) const;
|
|
void MoveCaretTo(int index, bool keepSelection, bool verticalMove);
|
|
void MoveCaretVertical(int deltaLines, bool keepSelection);
|
|
void CopySelectionToClipboard(bool cut);
|
|
void PasteFromClipboard(void);
|
|
|
|
bool IsKeyword(const CString& word) const;
|
|
bool IsFunctionWord(const CString& word) const;
|
|
bool IsWholeWordMatch(const CString& source, int index, int length) const;
|
|
int FindText(const CString& source, const CString& needle, int start, bool matchCase, bool wholeWord, bool forward) const;
|
|
bool IsBlockCommentAtLine(int line) const;
|
|
void ColorizeLine(const CString& lineText, bool& inBlockComment, COLORREF* colors) const;
|
|
void DrawEditorLine(CDC& dc, int line, int y, bool& inBlockComment, int selStart, int selEnd);
|
|
void DrawTextRun(CDC& dc, const CString& lineText, int lineStart, int tokenStart, int tokenEnd, int& visualColumn, int y, COLORREF color, int selStart, int selEnd);
|
|
};
|
|
|
|
IMPLEMENT_DYNAMIC(CScriptEditorCtrl, CWnd)
|
|
|
|
BEGIN_MESSAGE_MAP(CScriptEditorCtrl, CWnd)
|
|
ON_WM_CREATE()
|
|
ON_WM_PAINT()
|
|
ON_WM_ERASEBKGND()
|
|
ON_WM_GETDLGCODE()
|
|
ON_WM_SETFOCUS()
|
|
ON_WM_KILLFOCUS()
|
|
ON_WM_SIZE()
|
|
ON_WM_VSCROLL()
|
|
ON_WM_HSCROLL()
|
|
ON_WM_MOUSEWHEEL()
|
|
ON_WM_LBUTTONDOWN()
|
|
ON_WM_LBUTTONUP()
|
|
ON_WM_MOUSEMOVE()
|
|
ON_WM_KEYDOWN()
|
|
ON_WM_CHAR()
|
|
END_MESSAGE_MAP()
|
|
|
|
CScriptEditorCtrl::CScriptEditorCtrl() {
|
|
m_undoCaret = 0;
|
|
m_undoAnchor = 0;
|
|
m_hasUndo = false;
|
|
m_textLimit = 1024 * 1024;
|
|
m_caret = 0;
|
|
m_selAnchor = 0;
|
|
m_firstLine = 0;
|
|
m_xOffset = 0;
|
|
m_charWidth = 8;
|
|
m_lineHeight = 16;
|
|
m_ascent = 12;
|
|
m_gutterWidth = 48;
|
|
m_maxColumns = 0;
|
|
m_preferredColumn = -1;
|
|
m_dragging = false;
|
|
m_hasFocus = false;
|
|
m_caseSensitive = false;
|
|
m_inSetText = false;
|
|
RebuildLineCache();
|
|
}
|
|
|
|
CScriptEditorCtrl::~CScriptEditorCtrl() {
|
|
}
|
|
|
|
BOOL CScriptEditorCtrl::Create(CWnd* parent, UINT id) {
|
|
CString className = AfxRegisterWndClass(
|
|
CS_DBLCLKS,
|
|
::LoadCursor(NULL, IDC_IBEAM),
|
|
(HBRUSH)::GetStockObject(NULL_BRUSH),
|
|
NULL
|
|
);
|
|
|
|
return CWnd::CreateEx(
|
|
WS_EX_CLIENTEDGE,
|
|
className,
|
|
"IceTechScriptEditorTextView",
|
|
WS_CHILD | WS_VISIBLE | WS_TABSTOP | WS_VSCROLL | WS_HSCROLL | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
|
|
CRect(0, 0, 0, 0),
|
|
parent,
|
|
id
|
|
);
|
|
}
|
|
|
|
int CScriptEditorCtrl::OnCreate(LPCREATESTRUCT lpCreateStruct) {
|
|
if (CWnd::OnCreate(lpCreateStruct) == -1) {
|
|
return -1;
|
|
}
|
|
RefreshMetrics();
|
|
UpdateScrollBars();
|
|
return 0;
|
|
}
|
|
|
|
void CScriptEditorCtrl::LimitText(int maxChars) {
|
|
m_textLimit = maxChars;
|
|
}
|
|
|
|
void CScriptEditorCtrl::RefreshMetrics(void) {
|
|
CClientDC dc(this);
|
|
CFont* font = GetFont();
|
|
CFont* oldFont = font ? dc.SelectObject(font) : NULL;
|
|
|
|
TEXTMETRIC tm;
|
|
memset(&tm, 0, sizeof(tm));
|
|
dc.GetTextMetrics(&tm);
|
|
|
|
// Measure an average monospace run instead of only "M". Some DPI/font
|
|
// substitutions make "M" wider than the actual cell width, which makes the
|
|
// custom editor look oddly spaced and harder to read.
|
|
CSize tenChars = dc.GetTextExtent("0000000000", 10);
|
|
m_charWidth = max(1, tenChars.cx / 10);
|
|
|
|
// Give ClearType a little more vertical breathing room on the dark editor.
|
|
m_lineHeight = max(1, tm.tmHeight + tm.tmExternalLeading + 5);
|
|
m_ascent = tm.tmAscent;
|
|
|
|
if (oldFont) {
|
|
dc.SelectObject(oldFont);
|
|
}
|
|
|
|
UpdateScrollBars();
|
|
UpdateCaret();
|
|
Invalidate(FALSE);
|
|
}
|
|
|
|
void CScriptEditorCtrl::SetText(const char* text) {
|
|
m_inSetText = true;
|
|
m_text = ScriptEditorNormalizeText(text);
|
|
if (m_text.GetLength() > m_textLimit) {
|
|
m_text = m_text.Left(m_textLimit);
|
|
}
|
|
m_caret = 0;
|
|
m_selAnchor = 0;
|
|
m_firstLine = 0;
|
|
m_xOffset = 0;
|
|
m_preferredColumn = -1;
|
|
m_hasUndo = false;
|
|
RebuildLineCache();
|
|
UpdateScrollBars();
|
|
UpdateCaret();
|
|
Invalidate(FALSE);
|
|
m_inSetText = false;
|
|
NotifySelectionChange();
|
|
}
|
|
|
|
void CScriptEditorCtrl::GetText(idStr& text) const {
|
|
text = (LPCTSTR)m_text;
|
|
}
|
|
|
|
int CScriptEditorCtrl::GetTextLength(void) const {
|
|
return m_text.GetLength();
|
|
}
|
|
|
|
int CScriptEditorCtrl::GetLineCount(void) const {
|
|
return max(1, (int)m_lineStarts.GetSize());
|
|
}
|
|
|
|
void CScriptEditorCtrl::GetCursorPos(int& line, int& column, int& character) const {
|
|
line = GetLineFromChar(m_caret) + 1;
|
|
column = VisualColumnFromIndex(m_caret) + 1;
|
|
character = m_caret + 1;
|
|
}
|
|
|
|
void CScriptEditorCtrl::GoToLine(int line) {
|
|
line = max(0, min(line, GetLineCount() - 1));
|
|
MoveCaretTo(GetLineStart(line), false, false);
|
|
}
|
|
|
|
void CScriptEditorCtrl::GetSel(long& start, long& end) const {
|
|
start = GetSelectionStart();
|
|
end = GetSelectionEnd();
|
|
}
|
|
|
|
void CScriptEditorCtrl::SetSel(long start, long end) {
|
|
start = ClampIndex((int)start);
|
|
end = ClampIndex((int)end);
|
|
m_selAnchor = (int)start;
|
|
m_caret = (int)end;
|
|
m_preferredColumn = -1;
|
|
EnsureCaretVisible();
|
|
UpdateScrollBars();
|
|
UpdateCaret();
|
|
Invalidate(FALSE);
|
|
NotifySelectionChange();
|
|
}
|
|
|
|
CString CScriptEditorCtrl::GetSelText(void) const {
|
|
if (!HasSelection()) {
|
|
return "";
|
|
}
|
|
return m_text.Mid(GetSelectionStart(), GetSelectionEnd() - GetSelectionStart());
|
|
}
|
|
|
|
void CScriptEditorCtrl::ReplaceSel(const char* text, BOOL canUndo) {
|
|
CString replacement = ScriptEditorNormalizeText(text);
|
|
ReplaceRange(GetSelectionStart(), GetSelectionEnd(), replacement, canUndo ? true : false, true);
|
|
}
|
|
|
|
void CScriptEditorCtrl::ClearKeywords(void) {
|
|
m_keywords.RemoveAll();
|
|
Invalidate(FALSE);
|
|
}
|
|
|
|
void CScriptEditorCtrl::AddKeyword(const char* keyword) {
|
|
if (!keyword || !keyword[0]) {
|
|
return;
|
|
}
|
|
CString word = keyword;
|
|
for (int i = 0; i < m_keywords.GetSize(); i++) {
|
|
if (ScriptEditorCompareNoCase(m_keywords[i], word) == 0) {
|
|
return;
|
|
}
|
|
}
|
|
m_keywords.Add(word);
|
|
}
|
|
|
|
bool CScriptEditorCtrl::LoadKeyWordsFromFile(const char* fileName) {
|
|
idParser src;
|
|
idToken token, name, description;
|
|
if (!src.LoadFile(fileName)) {
|
|
return false;
|
|
}
|
|
|
|
while (src.ReadToken(&token)) {
|
|
if (token.Icmp("keywords") != 0) {
|
|
src.SkipBracedSection();
|
|
continue;
|
|
}
|
|
|
|
src.ExpectTokenString("{");
|
|
while (src.ReadToken(&token)) {
|
|
if (token == "}") {
|
|
break;
|
|
}
|
|
if (token != "{") {
|
|
continue;
|
|
}
|
|
|
|
// editors/*.def entries are { "keyword", ( r, g, b ), "description" }.
|
|
// This custom editor owns the actual dark palette, but still imports the names.
|
|
src.ExpectTokenType(TT_STRING, 0, &name);
|
|
AddKeyword(name.c_str());
|
|
src.ExpectTokenString(",");
|
|
src.ExpectTokenString("(");
|
|
src.ExpectTokenType(TT_NUMBER, TT_INTEGER, &token);
|
|
src.ExpectTokenString(",");
|
|
src.ExpectTokenType(TT_NUMBER, TT_INTEGER, &token);
|
|
src.ExpectTokenString(",");
|
|
src.ExpectTokenType(TT_NUMBER, TT_INTEGER, &token);
|
|
src.ExpectTokenString(")");
|
|
src.ExpectTokenString(",");
|
|
src.ExpectTokenType(TT_STRING, 0, &description);
|
|
src.ExpectTokenString("}");
|
|
}
|
|
}
|
|
Invalidate(FALSE);
|
|
return true;
|
|
}
|
|
|
|
void CScriptEditorCtrl::ClearFunctionWords(void) {
|
|
m_functionWords.RemoveAll();
|
|
Invalidate(FALSE);
|
|
}
|
|
|
|
void CScriptEditorCtrl::AddFunctionWord(const char* word) {
|
|
if (!word || !word[0]) {
|
|
return;
|
|
}
|
|
CString functionWord = word;
|
|
for (int i = 0; i < m_functionWords.GetSize(); i++) {
|
|
if (ScriptEditorCompareNoCase(m_functionWords[i], functionWord) == 0) {
|
|
return;
|
|
}
|
|
}
|
|
m_functionWords.Add(functionWord);
|
|
}
|
|
|
|
void CScriptEditorCtrl::SetCaseSensitive(bool caseSensitive) {
|
|
m_caseSensitive = caseSensitive;
|
|
Invalidate(FALSE);
|
|
}
|
|
|
|
int CScriptEditorCtrl::ClampIndex(int index) const {
|
|
if (index < 0) {
|
|
return 0;
|
|
}
|
|
if (index > m_text.GetLength()) {
|
|
return m_text.GetLength();
|
|
}
|
|
return index;
|
|
}
|
|
|
|
int CScriptEditorCtrl::GetSelectionStart(void) const {
|
|
return min(m_caret, m_selAnchor);
|
|
}
|
|
|
|
int CScriptEditorCtrl::GetSelectionEnd(void) const {
|
|
return max(m_caret, m_selAnchor);
|
|
}
|
|
|
|
bool CScriptEditorCtrl::HasSelection(void) const {
|
|
return m_caret != m_selAnchor;
|
|
}
|
|
|
|
void CScriptEditorCtrl::RebuildLineCache(void) {
|
|
m_lineStarts.RemoveAll();
|
|
m_lineStarts.Add(0);
|
|
|
|
m_maxColumns = 0;
|
|
int column = 0;
|
|
for (int i = 0; i < m_text.GetLength(); i++) {
|
|
char ch = m_text[i];
|
|
if (ch == '\n') {
|
|
if (column > m_maxColumns) {
|
|
m_maxColumns = column;
|
|
}
|
|
column = 0;
|
|
if (i + 1 <= m_text.GetLength()) {
|
|
m_lineStarts.Add(i + 1);
|
|
}
|
|
}
|
|
else if (ch == '\t') {
|
|
column += SE_TAB_SIZE - (column % SE_TAB_SIZE);
|
|
}
|
|
else {
|
|
column++;
|
|
}
|
|
}
|
|
if (column > m_maxColumns) {
|
|
m_maxColumns = column;
|
|
}
|
|
|
|
int digits = 1;
|
|
int lines = GetLineCount();
|
|
while (lines >= 10) {
|
|
lines /= 10;
|
|
digits++;
|
|
}
|
|
m_gutterWidth = max(48, digits * m_charWidth + 24);
|
|
}
|
|
|
|
int CScriptEditorCtrl::GetLineFromChar(int index) const {
|
|
index = ClampIndex(index);
|
|
int low = 0;
|
|
int high = (int)m_lineStarts.GetSize() - 1;
|
|
while (low <= high) {
|
|
int mid = (low + high) >> 1;
|
|
int start = m_lineStarts[mid];
|
|
int next = (mid + 1 < m_lineStarts.GetSize()) ? m_lineStarts[mid + 1] : m_text.GetLength() + 1;
|
|
if (index < start) {
|
|
high = mid - 1;
|
|
}
|
|
else if (index >= next) {
|
|
low = mid + 1;
|
|
}
|
|
else {
|
|
return mid;
|
|
}
|
|
}
|
|
return max(0, (int)m_lineStarts.GetSize() - 1);
|
|
}
|
|
|
|
int CScriptEditorCtrl::GetLineStart(int line) const {
|
|
line = max(0, min(line, GetLineCount() - 1));
|
|
return m_lineStarts[line];
|
|
}
|
|
|
|
int CScriptEditorCtrl::GetLineEnd(int line) const {
|
|
line = max(0, min(line, GetLineCount() - 1));
|
|
int end = (line + 1 < GetLineCount()) ? m_lineStarts[line + 1] - 1 : m_text.GetLength();
|
|
if (end > 0 && end <= m_text.GetLength() && m_text[end - 1] == '\r') {
|
|
end--;
|
|
}
|
|
return max(GetLineStart(line), end);
|
|
}
|
|
|
|
CString CScriptEditorCtrl::GetLineText(int line) const {
|
|
int start = GetLineStart(line);
|
|
int end = GetLineEnd(line);
|
|
return m_text.Mid(start, end - start);
|
|
}
|
|
|
|
int CScriptEditorCtrl::VisualColumnForLineOffset(int line, int offset) const {
|
|
CString lineText = GetLineText(line);
|
|
offset = max(0, min(offset, lineText.GetLength()));
|
|
int column = 0;
|
|
for (int i = 0; i < offset; i++) {
|
|
if (lineText[i] == '\t') {
|
|
column += SE_TAB_SIZE - (column % SE_TAB_SIZE);
|
|
}
|
|
else {
|
|
column++;
|
|
}
|
|
}
|
|
return column;
|
|
}
|
|
|
|
int CScriptEditorCtrl::CharOffsetFromVisualColumn(int line, int column) const {
|
|
CString lineText = GetLineText(line);
|
|
column = max(0, column);
|
|
int visual = 0;
|
|
for (int i = 0; i < lineText.GetLength(); i++) {
|
|
int next = visual;
|
|
if (lineText[i] == '\t') {
|
|
next += SE_TAB_SIZE - (next % SE_TAB_SIZE);
|
|
}
|
|
else {
|
|
next++;
|
|
}
|
|
if (column < next) {
|
|
return i;
|
|
}
|
|
visual = next;
|
|
}
|
|
return lineText.GetLength();
|
|
}
|
|
|
|
int CScriptEditorCtrl::VisualColumnFromIndex(int index) const {
|
|
int line = GetLineFromChar(index);
|
|
return VisualColumnForLineOffset(line, index - GetLineStart(line));
|
|
}
|
|
|
|
int CScriptEditorCtrl::IndexFromLineAndVisualColumn(int line, int column) const {
|
|
line = max(0, min(line, GetLineCount() - 1));
|
|
return GetLineStart(line) + CharOffsetFromVisualColumn(line, column);
|
|
}
|
|
|
|
CPoint CScriptEditorCtrl::GetCaretPoint(void) const {
|
|
int line = GetLineFromChar(m_caret);
|
|
int column = VisualColumnFromIndex(m_caret);
|
|
return CPoint(m_gutterWidth + column * m_charWidth - m_xOffset, (line - m_firstLine) * m_lineHeight);
|
|
}
|
|
|
|
int CScriptEditorCtrl::CharFromPoint(CPoint point) const {
|
|
CRect client;
|
|
GetClientRect(client);
|
|
int line = m_firstLine + max(0, point.y) / max(1, m_lineHeight);
|
|
line = max(0, min(line, GetLineCount() - 1));
|
|
int x = point.x - m_gutterWidth + m_xOffset;
|
|
int column = max(0, (x + m_charWidth / 2) / max(1, m_charWidth));
|
|
return IndexFromLineAndVisualColumn(line, column);
|
|
}
|
|
|
|
CString CScriptEditorCtrl::GetCurrentWord(long* wordStart, long* wordEnd) const {
|
|
int start = ClampIndex(m_caret);
|
|
int end = start;
|
|
|
|
while (start > 0 && ScriptEditorIsIdentifierChar(m_text[start - 1])) {
|
|
start--;
|
|
}
|
|
while (end < m_text.GetLength() && ScriptEditorIsIdentifierChar(m_text[end])) {
|
|
end++;
|
|
}
|
|
|
|
if (wordStart) {
|
|
*wordStart = start;
|
|
}
|
|
if (wordEnd) {
|
|
*wordEnd = end;
|
|
}
|
|
return m_text.Mid(start, m_caret - start);
|
|
}
|
|
|
|
void CScriptEditorCtrl::UpdateScrollBars(void) {
|
|
if (!GetSafeHwnd()) {
|
|
return;
|
|
}
|
|
|
|
CRect client;
|
|
GetClientRect(client);
|
|
int visibleLines = max(1, client.Height() / max(1, m_lineHeight));
|
|
|
|
SCROLLINFO si;
|
|
memset(&si, 0, sizeof(si));
|
|
si.cbSize = sizeof(si);
|
|
si.fMask = SIF_RANGE | SIF_PAGE | SIF_POS;
|
|
si.nMin = 0;
|
|
si.nMax = max(0, GetLineCount() - 1);
|
|
si.nPage = visibleLines;
|
|
m_firstLine = max(0, min(m_firstLine, max(0, GetLineCount() - visibleLines)));
|
|
si.nPos = m_firstLine;
|
|
SetScrollInfo(SB_VERT, &si, TRUE);
|
|
|
|
int contentWidth = max(0, m_maxColumns * m_charWidth);
|
|
int viewWidth = max(1, client.Width() - m_gutterWidth);
|
|
memset(&si, 0, sizeof(si));
|
|
si.cbSize = sizeof(si);
|
|
si.fMask = SIF_RANGE | SIF_PAGE | SIF_POS;
|
|
si.nMin = 0;
|
|
si.nMax = max(0, contentWidth);
|
|
si.nPage = viewWidth;
|
|
m_xOffset = max(0, min(m_xOffset, max(0, contentWidth - viewWidth)));
|
|
si.nPos = m_xOffset;
|
|
SetScrollInfo(SB_HORZ, &si, TRUE);
|
|
}
|
|
|
|
void CScriptEditorCtrl::UpdateCaret(void) {
|
|
if (!GetSafeHwnd() || !m_hasFocus) {
|
|
return;
|
|
}
|
|
CPoint pt = GetCaretPoint();
|
|
::SetCaretPos(pt.x, pt.y + 1);
|
|
}
|
|
|
|
void CScriptEditorCtrl::EnsureCaretVisible(void) {
|
|
CRect client;
|
|
GetClientRect(client);
|
|
int visibleLines = max(1, client.Height() / max(1, m_lineHeight));
|
|
int line = GetLineFromChar(m_caret);
|
|
|
|
if (line < m_firstLine) {
|
|
m_firstLine = line;
|
|
}
|
|
else if (line >= m_firstLine + visibleLines) {
|
|
m_firstLine = line - visibleLines + 1;
|
|
}
|
|
|
|
int columnX = VisualColumnFromIndex(m_caret) * m_charWidth;
|
|
int viewWidth = max(1, client.Width() - m_gutterWidth);
|
|
if (columnX < m_xOffset) {
|
|
m_xOffset = columnX;
|
|
}
|
|
else if (columnX + m_charWidth > m_xOffset + viewWidth) {
|
|
m_xOffset = columnX + m_charWidth - viewWidth;
|
|
}
|
|
m_firstLine = max(0, m_firstLine);
|
|
m_xOffset = max(0, m_xOffset);
|
|
}
|
|
|
|
void CScriptEditorCtrl::NotifyChange(void) {
|
|
if (m_inSetText || !GetParent() || !GetParent()->GetSafeHwnd()) {
|
|
return;
|
|
}
|
|
NMHDR hdr;
|
|
hdr.hwndFrom = GetSafeHwnd();
|
|
hdr.idFrom = GetDlgCtrlID();
|
|
hdr.code = EN_CHANGE;
|
|
GetParent()->SendMessage(WM_NOTIFY, (EN_CHANGE << 16) | GetDlgCtrlID(), (LPARAM)&hdr);
|
|
}
|
|
|
|
void CScriptEditorCtrl::NotifySelectionChange(void) {
|
|
if (!GetParent() || !GetParent()->GetSafeHwnd()) {
|
|
return;
|
|
}
|
|
NMHDR hdr;
|
|
hdr.hwndFrom = GetSafeHwnd();
|
|
hdr.idFrom = GetDlgCtrlID();
|
|
hdr.code = EN_SELCHANGE;
|
|
GetParent()->SendMessage(WM_NOTIFY, (EN_SELCHANGE << 16) | GetDlgCtrlID(), (LPARAM)&hdr);
|
|
}
|
|
|
|
void CScriptEditorCtrl::SaveUndo(void) {
|
|
m_undoText = m_text;
|
|
m_undoCaret = m_caret;
|
|
m_undoAnchor = m_selAnchor;
|
|
m_hasUndo = true;
|
|
}
|
|
|
|
void CScriptEditorCtrl::RestoreUndo(void) {
|
|
if (!m_hasUndo) {
|
|
return;
|
|
}
|
|
CString oldText = m_text;
|
|
int oldCaret = m_caret;
|
|
int oldAnchor = m_selAnchor;
|
|
m_text = m_undoText;
|
|
m_caret = ClampIndex(m_undoCaret);
|
|
m_selAnchor = ClampIndex(m_undoAnchor);
|
|
m_undoText = oldText;
|
|
m_undoCaret = oldCaret;
|
|
m_undoAnchor = oldAnchor;
|
|
RebuildLineCache();
|
|
EnsureCaretVisible();
|
|
UpdateScrollBars();
|
|
UpdateCaret();
|
|
Invalidate(FALSE);
|
|
NotifyChange();
|
|
NotifySelectionChange();
|
|
QueueIntelliSenseUpdate(false);
|
|
}
|
|
|
|
void CScriptEditorCtrl::QueueIntelliSenseUpdate(bool hide) {
|
|
CWnd* parent = GetParent();
|
|
if (parent && parent->GetSafeHwnd()) {
|
|
parent->PostMessage(WM_SCRIPTEDITOR_DEFERRED_INTELLISENSE, hide ? 2 : 1, 0);
|
|
}
|
|
}
|
|
|
|
void CScriptEditorCtrl::ReplaceRange(int start, int end, const CString& replacement, bool canUndo, bool notify) {
|
|
start = ClampIndex(start);
|
|
end = ClampIndex(end);
|
|
if (end < start) {
|
|
int temp = start;
|
|
start = end;
|
|
end = temp;
|
|
}
|
|
|
|
CString insert = replacement;
|
|
insert = ScriptEditorNormalizeText(insert);
|
|
int newLength = m_text.GetLength() - (end - start) + insert.GetLength();
|
|
if (newLength > m_textLimit) {
|
|
int allowed = m_textLimit - (m_text.GetLength() - (end - start));
|
|
if (allowed < 0) {
|
|
allowed = 0;
|
|
}
|
|
insert = insert.Left(allowed);
|
|
}
|
|
|
|
if (canUndo) {
|
|
SaveUndo();
|
|
}
|
|
|
|
m_text = m_text.Left(start) + insert + m_text.Mid(end);
|
|
m_caret = start + insert.GetLength();
|
|
m_selAnchor = m_caret;
|
|
m_preferredColumn = -1;
|
|
RebuildLineCache();
|
|
EnsureCaretVisible();
|
|
UpdateScrollBars();
|
|
UpdateCaret();
|
|
Invalidate(FALSE);
|
|
if (notify) {
|
|
NotifyChange();
|
|
NotifySelectionChange();
|
|
}
|
|
}
|
|
|
|
void CScriptEditorCtrl::DeleteSelectionOrRange(int start, int end) {
|
|
ReplaceRange(start, end, "", true, true);
|
|
}
|
|
|
|
void CScriptEditorCtrl::IndentSelection(bool unindent) {
|
|
int selStart = GetSelectionStart();
|
|
int selEnd = GetSelectionEnd();
|
|
int startLine = GetLineFromChar(selStart);
|
|
int endLine = GetLineFromChar(selEnd);
|
|
if (selEnd > selStart && selEnd == GetLineStart(endLine) && endLine > startLine) {
|
|
endLine--;
|
|
}
|
|
|
|
SaveUndo();
|
|
int delta = 0;
|
|
for (int line = startLine; line <= endLine; line++) {
|
|
int pos = GetLineStart(line) + delta;
|
|
if (unindent) {
|
|
if (pos < m_text.GetLength() && m_text[pos] == '\t') {
|
|
m_text = m_text.Left(pos) + m_text.Mid(pos + 1);
|
|
delta -= 1;
|
|
}
|
|
else {
|
|
int remove = 0;
|
|
while (remove < SE_TAB_SIZE && pos + remove < m_text.GetLength() && m_text[pos + remove] == ' ') {
|
|
remove++;
|
|
}
|
|
if (remove > 0) {
|
|
m_text = m_text.Left(pos) + m_text.Mid(pos + remove);
|
|
delta -= remove;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
m_text = m_text.Left(pos) + "\t" + m_text.Mid(pos);
|
|
delta += 1;
|
|
}
|
|
}
|
|
|
|
RebuildLineCache();
|
|
int newStart = GetLineStart(startLine);
|
|
int newEnd = GetLineEnd(endLine);
|
|
m_selAnchor = newStart;
|
|
m_caret = newEnd;
|
|
EnsureCaretVisible();
|
|
UpdateScrollBars();
|
|
UpdateCaret();
|
|
Invalidate(FALSE);
|
|
NotifyChange();
|
|
NotifySelectionChange();
|
|
}
|
|
|
|
void CScriptEditorCtrl::MoveCaretTo(int index, bool keepSelection, bool verticalMove) {
|
|
m_caret = ClampIndex(index);
|
|
if (!keepSelection) {
|
|
m_selAnchor = m_caret;
|
|
}
|
|
if (!verticalMove) {
|
|
m_preferredColumn = -1;
|
|
}
|
|
EnsureCaretVisible();
|
|
UpdateScrollBars();
|
|
UpdateCaret();
|
|
Invalidate(FALSE);
|
|
NotifySelectionChange();
|
|
}
|
|
|
|
void CScriptEditorCtrl::MoveCaretVertical(int deltaLines, bool keepSelection) {
|
|
int line = GetLineFromChar(m_caret);
|
|
if (m_preferredColumn < 0) {
|
|
m_preferredColumn = VisualColumnFromIndex(m_caret);
|
|
}
|
|
line = max(0, min(line + deltaLines, GetLineCount() - 1));
|
|
MoveCaretTo(IndexFromLineAndVisualColumn(line, m_preferredColumn), keepSelection, true);
|
|
}
|
|
|
|
void CScriptEditorCtrl::CopySelectionToClipboard(bool cut) {
|
|
if (!HasSelection()) {
|
|
return;
|
|
}
|
|
|
|
CString selection = ScriptEditorToCRLF(GetSelText());
|
|
if (OpenClipboard()) {
|
|
EmptyClipboard();
|
|
HGLOBAL hMem = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, selection.GetLength() + 1);
|
|
if (hMem) {
|
|
char* dst = (char*)GlobalLock(hMem);
|
|
if (dst) {
|
|
memcpy(dst, (LPCTSTR)selection, selection.GetLength());
|
|
dst[selection.GetLength()] = '\0';
|
|
GlobalUnlock(hMem);
|
|
SetClipboardData(CF_TEXT, hMem);
|
|
}
|
|
else {
|
|
GlobalFree(hMem);
|
|
}
|
|
}
|
|
CloseClipboard();
|
|
}
|
|
|
|
if (cut) {
|
|
DeleteSelectionOrRange(GetSelectionStart(), GetSelectionEnd());
|
|
}
|
|
}
|
|
|
|
void CScriptEditorCtrl::PasteFromClipboard(void) {
|
|
if (!OpenClipboard()) {
|
|
return;
|
|
}
|
|
HGLOBAL hMem = GetClipboardData(CF_TEXT);
|
|
if (hMem) {
|
|
char* src = (char*)GlobalLock(hMem);
|
|
if (src) {
|
|
ReplaceRange(GetSelectionStart(), GetSelectionEnd(), ScriptEditorNormalizeText(src), true, true);
|
|
GlobalUnlock(hMem);
|
|
}
|
|
}
|
|
CloseClipboard();
|
|
}
|
|
|
|
bool CScriptEditorCtrl::IsKeyword(const CString& word) const {
|
|
for (int i = 0; i < m_keywords.GetSize(); i++) {
|
|
if (m_caseSensitive) {
|
|
if (m_keywords[i] == word) {
|
|
return true;
|
|
}
|
|
}
|
|
else if (ScriptEditorCompareNoCase(m_keywords[i], word) == 0) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CScriptEditorCtrl::IsFunctionWord(const CString& word) const {
|
|
for (int i = 0; i < m_functionWords.GetSize(); i++) {
|
|
if (m_caseSensitive) {
|
|
if (m_functionWords[i] == word) {
|
|
return true;
|
|
}
|
|
}
|
|
else if (ScriptEditorCompareNoCase(m_functionWords[i], word) == 0) {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CScriptEditorCtrl::IsWholeWordMatch(const CString& source, int index, int length) const {
|
|
if (index > 0 && ScriptEditorIsIdentifierChar(source[index - 1])) {
|
|
return false;
|
|
}
|
|
if (index + length < source.GetLength() && ScriptEditorIsIdentifierChar(source[index + length])) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
int CScriptEditorCtrl::FindText(const CString& source, const CString& needle, int start, bool matchCase, bool wholeWord, bool forward) const {
|
|
if (needle.GetLength() == 0 || source.GetLength() == 0) {
|
|
return -1;
|
|
}
|
|
|
|
CString hay = source;
|
|
CString find = needle;
|
|
if (!matchCase) {
|
|
hay.MakeLower();
|
|
find.MakeLower();
|
|
}
|
|
|
|
start = max(0, min(start, source.GetLength()));
|
|
if (forward) {
|
|
for (int i = start; i <= hay.GetLength() - find.GetLength(); i++) {
|
|
if (hay.Mid(i, find.GetLength()) == find && (!wholeWord || IsWholeWordMatch(source, i, find.GetLength()))) {
|
|
return i;
|
|
}
|
|
}
|
|
for (int i = 0; i < start && i <= hay.GetLength() - find.GetLength(); i++) {
|
|
if (hay.Mid(i, find.GetLength()) == find && (!wholeWord || IsWholeWordMatch(source, i, find.GetLength()))) {
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
int begin = min(start, hay.GetLength() - find.GetLength());
|
|
for (int i = begin; i >= 0; i--) {
|
|
if (hay.Mid(i, find.GetLength()) == find && (!wholeWord || IsWholeWordMatch(source, i, find.GetLength()))) {
|
|
return i;
|
|
}
|
|
}
|
|
for (int i = hay.GetLength() - find.GetLength(); i > start; i--) {
|
|
if (hay.Mid(i, find.GetLength()) == find && (!wholeWord || IsWholeWordMatch(source, i, find.GetLength()))) {
|
|
return i;
|
|
}
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
bool CScriptEditorCtrl::FindNext(const char* find, bool matchCase, bool matchWholeWords, bool searchForward) {
|
|
CString needle = find ? find : "";
|
|
if (needle.IsEmpty()) {
|
|
return false;
|
|
}
|
|
int start = searchForward ? GetSelectionEnd() : GetSelectionStart() - 1;
|
|
int index = FindText(m_text, needle, start, matchCase, matchWholeWords, searchForward);
|
|
if (index < 0) {
|
|
return false;
|
|
}
|
|
SetSel(index, index + needle.GetLength());
|
|
return true;
|
|
}
|
|
|
|
int CScriptEditorCtrl::ReplaceAll(const char* find, const char* replace, bool matchCase, bool matchWholeWords) {
|
|
CString needle = find ? find : "";
|
|
CString replacement = ScriptEditorNormalizeText(replace ? replace : "");
|
|
if (needle.IsEmpty()) {
|
|
return 0;
|
|
}
|
|
|
|
SaveUndo();
|
|
int count = 0;
|
|
int index = FindText(m_text, needle, 0, matchCase, matchWholeWords, true);
|
|
while (index >= 0) {
|
|
m_text = m_text.Left(index) + replacement + m_text.Mid(index + needle.GetLength());
|
|
count++;
|
|
int nextStart = index + replacement.GetLength();
|
|
int nextIndex = FindText(m_text, needle, nextStart, matchCase, matchWholeWords, true);
|
|
if (nextIndex < 0 || nextIndex <= index) {
|
|
break;
|
|
}
|
|
index = nextIndex;
|
|
}
|
|
|
|
if (count > 0) {
|
|
m_caret = 0;
|
|
m_selAnchor = 0;
|
|
RebuildLineCache();
|
|
EnsureCaretVisible();
|
|
UpdateScrollBars();
|
|
UpdateCaret();
|
|
Invalidate(FALSE);
|
|
NotifyChange();
|
|
NotifySelectionChange();
|
|
}
|
|
return count;
|
|
}
|
|
|
|
bool CScriptEditorCtrl::IsBlockCommentAtLine(int line) const {
|
|
bool inComment = false;
|
|
for (int l = 0; l < line; l++) {
|
|
CString text = GetLineText(l);
|
|
for (int i = 0; i < text.GetLength(); i++) {
|
|
if (!inComment && i + 1 < text.GetLength() && text[i] == '/' && text[i + 1] == '*') {
|
|
inComment = true;
|
|
i++;
|
|
}
|
|
else if (inComment && i + 1 < text.GetLength() && text[i] == '*' && text[i + 1] == '/') {
|
|
inComment = false;
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
return inComment;
|
|
}
|
|
|
|
void CScriptEditorCtrl::ColorizeLine(const CString& lineText, bool& inBlockComment, COLORREF* colors) const {
|
|
int len = lineText.GetLength();
|
|
for (int i = 0; i < len; i++) {
|
|
colors[i] = SE_DARK_TEXT;
|
|
}
|
|
|
|
for (int i = 0; i < len; ) {
|
|
if (inBlockComment) {
|
|
colors[i] = SE_DARK_COMMENT;
|
|
if (i + 1 < len && lineText[i] == '*' && lineText[i + 1] == '/') {
|
|
colors[i + 1] = SE_DARK_COMMENT;
|
|
inBlockComment = false;
|
|
i += 2;
|
|
}
|
|
else {
|
|
i++;
|
|
}
|
|
continue;
|
|
}
|
|
|
|
char ch = lineText[i];
|
|
if (ch == '/' && i + 1 < len && lineText[i + 1] == '/') {
|
|
for (int j = i; j < len; j++) {
|
|
colors[j] = SE_DARK_COMMENT;
|
|
}
|
|
break;
|
|
}
|
|
if (ch == '/' && i + 1 < len && lineText[i + 1] == '*') {
|
|
colors[i] = SE_DARK_COMMENT;
|
|
colors[i + 1] = SE_DARK_COMMENT;
|
|
inBlockComment = true;
|
|
i += 2;
|
|
continue;
|
|
}
|
|
if (ch == '"' || ch == '\'') {
|
|
char quote = ch;
|
|
COLORREF stringColor = (quote == '"') ? SE_DARK_STRING : SE_DARK_ALT_STRING;
|
|
colors[i++] = stringColor;
|
|
while (i < len) {
|
|
colors[i] = stringColor;
|
|
if (lineText[i] == quote && (i == 0 || lineText[i - 1] != '\\')) {
|
|
i++;
|
|
break;
|
|
}
|
|
i++;
|
|
}
|
|
continue;
|
|
}
|
|
if (ch >= '0' && ch <= '9') {
|
|
int start = i;
|
|
while (i < len && ((lineText[i] >= '0' && lineText[i] <= '9') || lineText[i] == '.' || lineText[i] == 'x' || lineText[i] == 'X' || (lineText[i] >= 'a' && lineText[i] <= 'f') || (lineText[i] >= 'A' && lineText[i] <= 'F'))) {
|
|
i++;
|
|
}
|
|
for (int j = start; j < i; j++) {
|
|
colors[j] = SE_DARK_NUMBER;
|
|
}
|
|
continue;
|
|
}
|
|
if (ScriptEditorIsIdentifierStart(ch)) {
|
|
int start = i;
|
|
while (i < len && ScriptEditorIsIdentifierChar(lineText[i])) {
|
|
i++;
|
|
}
|
|
CString word = lineText.Mid(start, i - start);
|
|
COLORREF color = SE_DARK_TEXT;
|
|
if (IsFunctionWord(word)) {
|
|
color = SE_DARK_FUNCTION;
|
|
}
|
|
else if (ScriptEditorIsTypeKeyword(word)) {
|
|
color = SE_DARK_TYPE;
|
|
}
|
|
else if (IsKeyword(word)) {
|
|
color = SE_DARK_KEYWORD;
|
|
}
|
|
for (int j = start; j < i; j++) {
|
|
colors[j] = color;
|
|
}
|
|
continue;
|
|
}
|
|
if (strchr("{}[]().,;:+-*/%=!<>|&", ch)) {
|
|
colors[i] = SE_DARK_OPERATOR;
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
|
|
void CScriptEditorCtrl::DrawTextRun(CDC& dc, const CString& lineText, int lineStart, int tokenStart, int tokenEnd, int& visualColumn, int y, COLORREF color, int selStart, int selEnd) {
|
|
for (int i = tokenStart; i < tokenEnd; ) {
|
|
const int charIndex = lineStart + i;
|
|
const bool selected = (charIndex >= selStart && charIndex < selEnd);
|
|
|
|
// Tabs still need fixed-cell expansion.
|
|
if (lineText[i] == '\t') {
|
|
const int widthColumns = SE_TAB_SIZE - (visualColumn % SE_TAB_SIZE);
|
|
|
|
CString drawText;
|
|
for (int s = 0; s < widthColumns; s++) {
|
|
drawText += ' ';
|
|
}
|
|
|
|
CRect cell(
|
|
m_gutterWidth + visualColumn * m_charWidth - m_xOffset,
|
|
y,
|
|
m_gutterWidth + (visualColumn + widthColumns) * m_charWidth - m_xOffset,
|
|
y + m_lineHeight
|
|
);
|
|
|
|
if (selected) {
|
|
dc.FillSolidRect(cell, SE_DARK_SELECTION);
|
|
dc.SetTextColor(SE_DARK_SELECTION_TEXT);
|
|
}
|
|
else {
|
|
dc.SetTextColor(color);
|
|
}
|
|
|
|
dc.TextOut(cell.left, y + 2, drawText);
|
|
visualColumn += widthColumns;
|
|
i++;
|
|
continue;
|
|
}
|
|
|
|
// Draw contiguous non-tab text as a run instead of one character at a time.
|
|
// This preserves ClearType/subpixel rendering much better and removes the
|
|
// "weird spacing" look in the editor.
|
|
int j = i + 1;
|
|
while (j < tokenEnd && lineText[j] != '\t') {
|
|
const int nextCharIndex = lineStart + j;
|
|
const bool nextSelected = (nextCharIndex >= selStart && nextCharIndex < selEnd);
|
|
if (nextSelected != selected) {
|
|
break;
|
|
}
|
|
j++;
|
|
}
|
|
|
|
const int columns = j - i;
|
|
CString drawText = lineText.Mid(i, columns);
|
|
|
|
CRect cell(
|
|
m_gutterWidth + visualColumn * m_charWidth - m_xOffset,
|
|
y,
|
|
m_gutterWidth + (visualColumn + columns) * m_charWidth - m_xOffset,
|
|
y + m_lineHeight
|
|
);
|
|
|
|
if (selected) {
|
|
dc.FillSolidRect(cell, SE_DARK_SELECTION);
|
|
dc.SetTextColor(SE_DARK_SELECTION_TEXT);
|
|
}
|
|
else {
|
|
dc.SetTextColor(color);
|
|
}
|
|
|
|
dc.TextOut(cell.left, y + 2, drawText);
|
|
|
|
visualColumn += columns;
|
|
i = j;
|
|
}
|
|
}
|
|
|
|
void CScriptEditorCtrl::DrawEditorLine(CDC& dc, int line, int y, bool& inBlockComment, int selStart, int selEnd) {
|
|
CRect client;
|
|
GetClientRect(client);
|
|
CString lineText = GetLineText(line);
|
|
int lineStart = GetLineStart(line);
|
|
|
|
if (line == GetLineFromChar(m_caret)) {
|
|
CRect currentLine(client.left, y, client.right, y + m_lineHeight);
|
|
dc.FillSolidRect(currentLine, SE_DARK_EDIT_LINE);
|
|
}
|
|
|
|
CRect gutter(client.left, y, client.left + m_gutterWidth - 1, y + m_lineHeight);
|
|
dc.FillSolidRect(gutter, SE_DARK_GUTTER);
|
|
dc.SetTextColor(SE_DARK_LINE_NUMBER);
|
|
dc.SetBkMode(TRANSPARENT);
|
|
CString lineNumber;
|
|
lineNumber.Format("%d", line + 1);
|
|
dc.DrawText(lineNumber, gutter, DT_RIGHT | DT_VCENTER | DT_SINGLELINE);
|
|
|
|
if (lineText.GetLength() <= 0) {
|
|
return;
|
|
}
|
|
|
|
COLORREF* colors = new COLORREF[lineText.GetLength()];
|
|
ColorizeLine(lineText, inBlockComment, colors);
|
|
|
|
int visualColumn = 0;
|
|
int runStart = 0;
|
|
COLORREF runColor = colors[0];
|
|
for (int i = 1; i <= lineText.GetLength(); i++) {
|
|
if (i == lineText.GetLength() || colors[i] != runColor) {
|
|
DrawTextRun(dc, lineText, lineStart, runStart, i, visualColumn, y, runColor, selStart, selEnd);
|
|
if (i < lineText.GetLength()) {
|
|
runStart = i;
|
|
runColor = colors[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
delete[] colors;
|
|
}
|
|
|
|
void CScriptEditorCtrl::OnPaint() {
|
|
CPaintDC paintDC(this);
|
|
CRect client;
|
|
GetClientRect(client);
|
|
|
|
if (client.Width() <= 0 || client.Height() <= 0) {
|
|
return;
|
|
}
|
|
|
|
CDC memDC;
|
|
CBitmap backBuffer;
|
|
CBitmap* oldBitmap = NULL;
|
|
CDC* drawDC = &paintDC;
|
|
|
|
if (memDC.CreateCompatibleDC(&paintDC) && backBuffer.CreateCompatibleBitmap(&paintDC, client.Width(), client.Height())) {
|
|
oldBitmap = memDC.SelectObject(&backBuffer);
|
|
drawDC = &memDC;
|
|
}
|
|
|
|
CDC& dc = *drawDC;
|
|
dc.FillSolidRect(client, SE_DARK_EDIT);
|
|
|
|
CFont* font = GetFont();
|
|
CFont* oldFont = font ? dc.SelectObject(font) : NULL;
|
|
dc.SetBkMode(TRANSPARENT);
|
|
|
|
CRect gutter(client.left, client.top, client.left + m_gutterWidth, client.bottom);
|
|
dc.FillSolidRect(gutter, SE_DARK_GUTTER);
|
|
dc.FillSolidRect(m_gutterWidth - 1, client.top, 1, client.Height(), SE_DARK_BORDER);
|
|
|
|
int selStart = GetSelectionStart();
|
|
int selEnd = GetSelectionEnd();
|
|
bool inBlockComment = IsBlockCommentAtLine(m_firstLine);
|
|
int visibleLines = client.Height() / max(1, m_lineHeight) + 1;
|
|
for (int i = 0; i < visibleLines; i++) {
|
|
int line = m_firstLine + i;
|
|
if (line >= GetLineCount()) {
|
|
break;
|
|
}
|
|
DrawEditorLine(dc, line, i * m_lineHeight, inBlockComment, selStart, selEnd);
|
|
}
|
|
|
|
if (oldFont) {
|
|
dc.SelectObject(oldFont);
|
|
}
|
|
|
|
if (drawDC != &paintDC) {
|
|
paintDC.BitBlt(0, 0, client.Width(), client.Height(), &memDC, 0, 0, SRCCOPY);
|
|
if (oldBitmap) {
|
|
memDC.SelectObject(oldBitmap);
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOL CScriptEditorCtrl::OnEraseBkgnd(CDC* pDC) {
|
|
return TRUE;
|
|
}
|
|
|
|
UINT CScriptEditorCtrl::OnGetDlgCode() {
|
|
return DLGC_WANTALLKEYS | DLGC_WANTARROWS | DLGC_WANTCHARS | DLGC_WANTMESSAGE | DLGC_WANTTAB;
|
|
}
|
|
|
|
void CScriptEditorCtrl::OnSetFocus(CWnd* oldWnd) {
|
|
CWnd::OnSetFocus(oldWnd);
|
|
m_hasFocus = true;
|
|
::CreateCaret(GetSafeHwnd(), NULL, 2, max(1, m_lineHeight - 2));
|
|
UpdateCaret();
|
|
::ShowCaret(GetSafeHwnd());
|
|
}
|
|
|
|
void CScriptEditorCtrl::OnKillFocus(CWnd* newWnd) {
|
|
::HideCaret(GetSafeHwnd());
|
|
::DestroyCaret();
|
|
m_hasFocus = false;
|
|
CWnd::OnKillFocus(newWnd);
|
|
}
|
|
|
|
void CScriptEditorCtrl::OnSize(UINT nType, int cx, int cy) {
|
|
CWnd::OnSize(nType, cx, cy);
|
|
EnsureCaretVisible();
|
|
UpdateScrollBars();
|
|
UpdateCaret();
|
|
Invalidate(FALSE);
|
|
}
|
|
|
|
void CScriptEditorCtrl::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) {
|
|
SCROLLINFO si;
|
|
memset(&si, 0, sizeof(si));
|
|
si.cbSize = sizeof(si);
|
|
si.fMask = SIF_ALL;
|
|
GetScrollInfo(SB_VERT, &si);
|
|
|
|
int pos = si.nPos;
|
|
switch (nSBCode) {
|
|
case SB_LINEUP: pos--; break;
|
|
case SB_LINEDOWN: pos++; break;
|
|
case SB_PAGEUP: pos -= (int)si.nPage; break;
|
|
case SB_PAGEDOWN: pos += (int)si.nPage; break;
|
|
case SB_THUMBTRACK:
|
|
case SB_THUMBPOSITION: pos = si.nTrackPos; break;
|
|
}
|
|
m_firstLine = max(si.nMin, min(pos, si.nMax - (int)si.nPage + 1));
|
|
UpdateScrollBars();
|
|
UpdateCaret();
|
|
Invalidate(FALSE);
|
|
}
|
|
|
|
void CScriptEditorCtrl::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) {
|
|
SCROLLINFO si;
|
|
memset(&si, 0, sizeof(si));
|
|
si.cbSize = sizeof(si);
|
|
si.fMask = SIF_ALL;
|
|
GetScrollInfo(SB_HORZ, &si);
|
|
|
|
int pos = si.nPos;
|
|
switch (nSBCode) {
|
|
case SB_LINELEFT: pos -= m_charWidth; break;
|
|
case SB_LINERIGHT: pos += m_charWidth; break;
|
|
case SB_PAGELEFT: pos -= (int)si.nPage; break;
|
|
case SB_PAGERIGHT: pos += (int)si.nPage; break;
|
|
case SB_THUMBTRACK:
|
|
case SB_THUMBPOSITION: pos = si.nTrackPos; break;
|
|
}
|
|
m_xOffset = max(si.nMin, min(pos, si.nMax - (int)si.nPage + 1));
|
|
UpdateScrollBars();
|
|
UpdateCaret();
|
|
Invalidate(FALSE);
|
|
}
|
|
|
|
BOOL CScriptEditorCtrl::OnMouseWheel(UINT nFlags, short zDelta, CPoint pt) {
|
|
int lines = -3 * ((int)zDelta) / WHEEL_DELTA;
|
|
m_firstLine = max(0, min(m_firstLine + lines, GetLineCount() - 1));
|
|
UpdateScrollBars();
|
|
UpdateCaret();
|
|
Invalidate(FALSE);
|
|
return TRUE;
|
|
}
|
|
|
|
void CScriptEditorCtrl::OnLButtonDown(UINT nFlags, CPoint point) {
|
|
SetFocus();
|
|
m_dragging = true;
|
|
SetCapture();
|
|
int index = CharFromPoint(point);
|
|
MoveCaretTo(index, (nFlags & MK_SHIFT) != 0, false);
|
|
QueueIntelliSenseUpdate(true);
|
|
}
|
|
|
|
void CScriptEditorCtrl::OnLButtonUp(UINT nFlags, CPoint point) {
|
|
if (m_dragging) {
|
|
m_dragging = false;
|
|
if (GetCapture() == this) {
|
|
ReleaseCapture();
|
|
}
|
|
}
|
|
CWnd::OnLButtonUp(nFlags, point);
|
|
}
|
|
|
|
void CScriptEditorCtrl::OnMouseMove(UINT nFlags, CPoint point) {
|
|
if (m_dragging) {
|
|
MoveCaretTo(CharFromPoint(point), true, false);
|
|
return;
|
|
}
|
|
CWnd::OnMouseMove(nFlags, point);
|
|
}
|
|
|
|
void CScriptEditorCtrl::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) {
|
|
CWnd* parent = GetParent();
|
|
if (parent && parent->GetSafeHwnd() && parent->SendMessage(WM_SCRIPTEDITOR_INTELLISENSE_KEY, nChar, nFlags) != 0) {
|
|
return;
|
|
}
|
|
|
|
bool ctrl = (::GetKeyState(VK_CONTROL) & 0x8000) != 0;
|
|
bool shift = (::GetKeyState(VK_SHIFT) & 0x8000) != 0;
|
|
|
|
if (ctrl) {
|
|
switch (nChar) {
|
|
case 'A':
|
|
SetSel(0, m_text.GetLength());
|
|
return;
|
|
case 'C':
|
|
CopySelectionToClipboard(false);
|
|
return;
|
|
case 'X':
|
|
CopySelectionToClipboard(true);
|
|
QueueIntelliSenseUpdate(false);
|
|
return;
|
|
case 'V':
|
|
PasteFromClipboard();
|
|
QueueIntelliSenseUpdate(false);
|
|
return;
|
|
case 'Z':
|
|
RestoreUndo();
|
|
return;
|
|
case VK_SPACE:
|
|
if (GetParent() && GetParent()->GetSafeHwnd()) {
|
|
GetParent()->SendMessage(WM_COMMAND, MAKEWPARAM(IDC_SCRIPTEDITOR_BUTTON_INTELLISENSE, BN_CLICKED), (LPARAM)GetSafeHwnd());
|
|
}
|
|
return;
|
|
case VK_HOME:
|
|
MoveCaretTo(0, shift, false);
|
|
return;
|
|
case VK_END:
|
|
MoveCaretTo(m_text.GetLength(), shift, false);
|
|
return;
|
|
}
|
|
}
|
|
|
|
switch (nChar) {
|
|
case VK_LEFT:
|
|
if (HasSelection() && !shift) {
|
|
MoveCaretTo(GetSelectionStart(), false, false);
|
|
}
|
|
else {
|
|
MoveCaretTo(m_caret - 1, shift, false);
|
|
}
|
|
return;
|
|
case VK_RIGHT:
|
|
if (HasSelection() && !shift) {
|
|
MoveCaretTo(GetSelectionEnd(), false, false);
|
|
}
|
|
else {
|
|
MoveCaretTo(m_caret + 1, shift, false);
|
|
}
|
|
return;
|
|
case VK_UP:
|
|
MoveCaretVertical(-1, shift);
|
|
return;
|
|
case VK_DOWN:
|
|
MoveCaretVertical(1, shift);
|
|
return;
|
|
case VK_PRIOR:
|
|
MoveCaretVertical(-max(1, 10), shift);
|
|
return;
|
|
case VK_NEXT:
|
|
MoveCaretVertical(max(1, 10), shift);
|
|
return;
|
|
case VK_HOME:
|
|
MoveCaretTo(GetLineStart(GetLineFromChar(m_caret)), shift, false);
|
|
return;
|
|
case VK_END:
|
|
MoveCaretTo(GetLineEnd(GetLineFromChar(m_caret)), shift, false);
|
|
return;
|
|
case VK_BACK:
|
|
if (HasSelection()) {
|
|
DeleteSelectionOrRange(GetSelectionStart(), GetSelectionEnd());
|
|
}
|
|
else if (m_caret > 0) {
|
|
DeleteSelectionOrRange(m_caret - 1, m_caret);
|
|
}
|
|
QueueIntelliSenseUpdate(false);
|
|
return;
|
|
case VK_DELETE:
|
|
if (HasSelection()) {
|
|
DeleteSelectionOrRange(GetSelectionStart(), GetSelectionEnd());
|
|
}
|
|
else if (m_caret < m_text.GetLength()) {
|
|
DeleteSelectionOrRange(m_caret, m_caret + 1);
|
|
}
|
|
QueueIntelliSenseUpdate(false);
|
|
return;
|
|
case VK_TAB:
|
|
if (HasSelection()) {
|
|
IndentSelection(shift);
|
|
}
|
|
else if (!shift) {
|
|
ReplaceRange(GetSelectionStart(), GetSelectionEnd(), "\t", true, true);
|
|
}
|
|
QueueIntelliSenseUpdate(true);
|
|
return;
|
|
case VK_RETURN:
|
|
{
|
|
int line = GetLineFromChar(m_caret);
|
|
CString current = GetLineText(line);
|
|
int offset = m_caret - GetLineStart(line);
|
|
CString indent = "\n";
|
|
for (int i = 0; i < current.GetLength() && ScriptEditorIsSpaceOrTab(current[i]); i++) {
|
|
indent += current[i];
|
|
}
|
|
int prev = offset - 1;
|
|
while (prev >= 0 && ScriptEditorIsSpaceOrTab(current[prev])) {
|
|
prev--;
|
|
}
|
|
if (prev >= 0 && current[prev] == '{') {
|
|
indent += '\t';
|
|
}
|
|
ReplaceRange(GetSelectionStart(), GetSelectionEnd(), indent, true, true);
|
|
QueueIntelliSenseUpdate(true);
|
|
return;
|
|
}
|
|
}
|
|
|
|
CWnd::OnKeyDown(nChar, nRepCnt, nFlags);
|
|
}
|
|
|
|
void CScriptEditorCtrl::OnChar(UINT nChar, UINT nRepCnt, UINT nFlags) {
|
|
if (nChar == VK_TAB || nChar == VK_RETURN || nChar == VK_BACK || nChar == 0) {
|
|
return;
|
|
}
|
|
if (nChar < 32) {
|
|
return;
|
|
}
|
|
|
|
CString insert;
|
|
insert.Format("%c", (char)nChar);
|
|
ReplaceRange(GetSelectionStart(), GetSelectionEnd(), insert, true, true);
|
|
|
|
CWnd* parent = GetParent();
|
|
if (parent && parent->GetSafeHwnd()) {
|
|
if (nChar == '(' || nChar == ',') {
|
|
parent->PostMessage(WM_SCRIPTEDITOR_DEFERRED_INTELLISENSE, 3, 0);
|
|
return;
|
|
}
|
|
if (nChar == ')' || nChar == ';' || nChar == '{' || nChar == '}') {
|
|
parent->PostMessage(WM_SCRIPTEDITOR_DEFERRED_INTELLISENSE, 4, 0);
|
|
QueueIntelliSenseUpdate(true);
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (nChar == '(' || nChar == ',') {
|
|
QueueIntelliSenseUpdate(false);
|
|
return;
|
|
}
|
|
if (nChar == ')' || nChar == ';') {
|
|
QueueIntelliSenseUpdate(true);
|
|
return;
|
|
}
|
|
|
|
const bool canPredict = ScriptEditorIsIdentifierChar(nChar) || nChar == '.' || nChar == ':';
|
|
QueueIntelliSenseUpdate(!canPredict);
|
|
}
|
|
|
|
//=============================================================================
|
|
// Dark owner-drawn helper controls
|
|
//=============================================================================
|
|
static const char* SE_DARK_BUTTON_OLDPROC = "IceTech.ScriptEditor.DarkButtonOldProc";
|
|
static const char* SE_DARK_STATIC_OLDPROC = "IceTech.ScriptEditor.DarkStaticOldProc";
|
|
static const char* SE_DARK_LIST_OLDPROC = "IceTech.ScriptEditor.DarkListOldProc";
|
|
|
|
#ifndef BS_TYPEMASK
|
|
#define BS_TYPEMASK 0x0000000F
|
|
#endif
|
|
|
|
static void ScriptEditorDrawButton(HWND hWnd, HDC hDC) {
|
|
RECT rc;
|
|
::GetClientRect(hWnd, &rc);
|
|
|
|
const UINT style = (UINT)::GetWindowLong(hWnd, GWL_STYLE);
|
|
const UINT type = style & BS_TYPEMASK;
|
|
const bool enabled = ::IsWindowEnabled(hWnd) ? true : false;
|
|
const bool pushed = (::SendMessage(hWnd, BM_GETSTATE, 0, 0) & BST_PUSHED) != 0;
|
|
const bool defaultButton = (type == BS_DEFPUSHBUTTON);
|
|
|
|
char text[128];
|
|
text[0] = '\0';
|
|
::GetWindowTextA(hWnd, text, sizeof(text));
|
|
|
|
COLORREF face = pushed ? RGB(18, 22, 28) : RGB(31, 36, 45);
|
|
if (defaultButton && enabled) {
|
|
face = pushed ? RGB(42, 82, 126) : RGB(33, 68, 107);
|
|
}
|
|
|
|
ScriptEditorFillRect(hDC, rc, face);
|
|
ScriptEditorFrameRect(hDC, rc, enabled ? (defaultButton ? SE_DARK_ACCENT : SE_DARK_BORDER) : RGB(42, 48, 56));
|
|
|
|
HFONT font = (HFONT)::SendMessage(hWnd, WM_GETFONT, 0, 0);
|
|
HFONT oldFont = font ? (HFONT)::SelectObject(hDC, font) : NULL;
|
|
::SetBkMode(hDC, TRANSPARENT);
|
|
::SetTextColor(hDC, enabled ? SE_DARK_TEXT : SE_DARK_DISABLED);
|
|
|
|
RECT textRect = rc;
|
|
if (pushed) {
|
|
::OffsetRect(&textRect, 1, 1);
|
|
}
|
|
::DrawTextA(hDC, text, -1, &textRect, DT_CENTER | DT_VCENTER | DT_SINGLELINE | DT_END_ELLIPSIS);
|
|
|
|
if (oldFont) {
|
|
::SelectObject(hDC, oldFont);
|
|
}
|
|
}
|
|
|
|
static LRESULT CALLBACK ScriptEditorDarkButtonProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
|
|
WNDPROC oldProc = (WNDPROC)::GetPropA(hWnd, SE_DARK_BUTTON_OLDPROC);
|
|
if (!oldProc) {
|
|
return ::DefWindowProc(hWnd, uMsg, wParam, lParam);
|
|
}
|
|
|
|
switch (uMsg) {
|
|
case WM_ERASEBKGND:
|
|
return 1;
|
|
case WM_PAINT:
|
|
{
|
|
PAINTSTRUCT ps;
|
|
HDC hDC = ::BeginPaint(hWnd, &ps);
|
|
ScriptEditorDrawButton(hWnd, hDC);
|
|
::EndPaint(hWnd, &ps);
|
|
return 0;
|
|
}
|
|
case WM_PRINTCLIENT:
|
|
ScriptEditorDrawButton(hWnd, (HDC)wParam);
|
|
return 0;
|
|
case WM_MOUSEMOVE:
|
|
case WM_LBUTTONDOWN:
|
|
case WM_LBUTTONUP:
|
|
case WM_ENABLE:
|
|
case WM_SETTEXT:
|
|
case BM_SETSTATE:
|
|
{
|
|
LRESULT result = ::CallWindowProc(oldProc, hWnd, uMsg, wParam, lParam);
|
|
::InvalidateRect(hWnd, NULL, FALSE);
|
|
return result;
|
|
}
|
|
case WM_NCDESTROY:
|
|
{
|
|
::SetWindowLongPtr(hWnd, GWLP_WNDPROC, (LONG_PTR)oldProc);
|
|
::RemovePropA(hWnd, SE_DARK_BUTTON_OLDPROC);
|
|
return ::CallWindowProc(oldProc, hWnd, uMsg, wParam, lParam);
|
|
}
|
|
}
|
|
|
|
return ::CallWindowProc(oldProc, hWnd, uMsg, wParam, lParam);
|
|
}
|
|
|
|
static void ScriptEditorSubclassButton(CWnd& wnd) {
|
|
HWND hWnd = wnd.GetSafeHwnd();
|
|
if (!hWnd || ::GetPropA(hWnd, SE_DARK_BUTTON_OLDPROC)) {
|
|
return;
|
|
}
|
|
WNDPROC oldProc = (WNDPROC)::GetWindowLongPtr(hWnd, GWLP_WNDPROC);
|
|
::SetPropA(hWnd, SE_DARK_BUTTON_OLDPROC, (HANDLE)oldProc);
|
|
::SetWindowLongPtr(hWnd, GWLP_WNDPROC, (LONG_PTR)ScriptEditorDarkButtonProc);
|
|
::InvalidateRect(hWnd, NULL, TRUE);
|
|
}
|
|
|
|
static void ScriptEditorDrawStatic(HWND hWnd, HDC hDC) {
|
|
RECT rc;
|
|
::GetClientRect(hWnd, &rc);
|
|
ScriptEditorFillRect(hDC, rc, SE_DARK_PANEL);
|
|
|
|
char text[512];
|
|
text[0] = '\0';
|
|
::GetWindowTextA(hWnd, text, sizeof(text));
|
|
|
|
HFONT font = (HFONT)::SendMessage(hWnd, WM_GETFONT, 0, 0);
|
|
HFONT oldFont = font ? (HFONT)::SelectObject(hDC, font) : NULL;
|
|
::SetBkMode(hDC, TRANSPARENT);
|
|
|
|
COLORREF textColor = SE_DARK_TEXT;
|
|
const int id = ::GetDlgCtrlID(hWnd);
|
|
if (id == IDC_SCRIPTEDITOR_PATH || id == IDC_SCRIPTEDITOR_STATUS || id == IDC_SCRIPTEDITOR_LANGUAGE) {
|
|
textColor = SE_DARK_MUTED;
|
|
}
|
|
::SetTextColor(hDC, textColor);
|
|
|
|
RECT textRect = rc;
|
|
textRect.left += 4;
|
|
textRect.right -= 4;
|
|
UINT flags = DT_LEFT | DT_VCENTER | DT_SINGLELINE | DT_END_ELLIPSIS;
|
|
if (id == IDC_SCRIPTEDITOR_LANGUAGE) {
|
|
flags = DT_RIGHT | DT_VCENTER | DT_SINGLELINE | DT_END_ELLIPSIS;
|
|
}
|
|
::DrawTextA(hDC, text, -1, &textRect, flags);
|
|
|
|
if (oldFont) {
|
|
::SelectObject(hDC, oldFont);
|
|
}
|
|
}
|
|
|
|
static LRESULT CALLBACK ScriptEditorDarkStaticProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
|
|
WNDPROC oldProc = (WNDPROC)::GetPropA(hWnd, SE_DARK_STATIC_OLDPROC);
|
|
if (!oldProc) {
|
|
return ::DefWindowProc(hWnd, uMsg, wParam, lParam);
|
|
}
|
|
if (uMsg == WM_PAINT) {
|
|
PAINTSTRUCT ps;
|
|
HDC hDC = ::BeginPaint(hWnd, &ps);
|
|
ScriptEditorDrawStatic(hWnd, hDC);
|
|
::EndPaint(hWnd, &ps);
|
|
return 0;
|
|
}
|
|
if (uMsg == WM_ERASEBKGND) {
|
|
return 1;
|
|
}
|
|
if (uMsg == WM_SETTEXT) {
|
|
LRESULT result = ::CallWindowProc(oldProc, hWnd, uMsg, wParam, lParam);
|
|
::InvalidateRect(hWnd, NULL, FALSE);
|
|
return result;
|
|
}
|
|
if (uMsg == WM_NCDESTROY) {
|
|
::SetWindowLongPtr(hWnd, GWLP_WNDPROC, (LONG_PTR)oldProc);
|
|
::RemovePropA(hWnd, SE_DARK_STATIC_OLDPROC);
|
|
return ::CallWindowProc(oldProc, hWnd, uMsg, wParam, lParam);
|
|
}
|
|
return ::CallWindowProc(oldProc, hWnd, uMsg, wParam, lParam);
|
|
}
|
|
|
|
static void ScriptEditorSubclassStatic(CWnd& wnd) {
|
|
HWND hWnd = wnd.GetSafeHwnd();
|
|
if (!hWnd || ::GetPropA(hWnd, SE_DARK_STATIC_OLDPROC)) {
|
|
return;
|
|
}
|
|
WNDPROC oldProc = (WNDPROC)::GetWindowLongPtr(hWnd, GWLP_WNDPROC);
|
|
::SetPropA(hWnd, SE_DARK_STATIC_OLDPROC, (HANDLE)oldProc);
|
|
::SetWindowLongPtr(hWnd, GWLP_WNDPROC, (LONG_PTR)ScriptEditorDarkStaticProc);
|
|
}
|
|
|
|
static LRESULT CALLBACK ScriptEditorDarkListProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
|
|
WNDPROC oldProc = (WNDPROC)::GetPropA(hWnd, SE_DARK_LIST_OLDPROC);
|
|
if (!oldProc) {
|
|
return ::DefWindowProc(hWnd, uMsg, wParam, lParam);
|
|
}
|
|
if (uMsg == WM_NCDESTROY) {
|
|
::SetWindowLongPtr(hWnd, GWLP_WNDPROC, (LONG_PTR)oldProc);
|
|
::RemovePropA(hWnd, SE_DARK_LIST_OLDPROC);
|
|
return ::CallWindowProc(oldProc, hWnd, uMsg, wParam, lParam);
|
|
}
|
|
if (uMsg == WM_KEYDOWN && (wParam == VK_RETURN || wParam == VK_TAB)) {
|
|
::SendMessage(::GetParent(hWnd), WM_COMMAND, MAKEWPARAM(IDC_SCRIPTEDITOR_INTELLISENSE_LIST, LBN_DBLCLK), (LPARAM)hWnd);
|
|
return 0;
|
|
}
|
|
return ::CallWindowProc(oldProc, hWnd, uMsg, wParam, lParam);
|
|
}
|
|
|
|
static void ScriptEditorSubclassList(CWnd& wnd) {
|
|
HWND hWnd = wnd.GetSafeHwnd();
|
|
if (!hWnd || ::GetPropA(hWnd, SE_DARK_LIST_OLDPROC)) {
|
|
return;
|
|
}
|
|
WNDPROC oldProc = (WNDPROC)::GetWindowLongPtr(hWnd, GWLP_WNDPROC);
|
|
::SetPropA(hWnd, SE_DARK_LIST_OLDPROC, (HANDLE)oldProc);
|
|
::SetWindowLongPtr(hWnd, GWLP_WNDPROC, (LONG_PTR)ScriptEditorDarkListProc);
|
|
}
|
|
|
|
/*
|
|
================
|
|
Script editor event helpers
|
|
================
|
|
*/
|
|
static bool GetFunctionParms(const char* funcName, CString& parmString) {
|
|
for (int i = 0; i < scriptEvents.Num(); i++) {
|
|
if (scriptEvents[i].name.Cmp(funcName) == 0) {
|
|
parmString = scriptEvents[i].parms;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static bool GetToolTip(const char* name, CString& string) {
|
|
for (int i = 0; i < scriptEvents.Num(); i++) {
|
|
if (scriptEvents[i].name.Cmp(name) == 0) {
|
|
string = scriptEvents[i].help + scriptEvents[i].parms;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
toolTip_t DialogScriptEditor::toolTips[] = {
|
|
{ IDC_SCRIPTEDITOR_BUTTON_NEW, "Create a new script buffer" },
|
|
{ IDC_SCRIPTEDITOR_BUTTON_OPEN, "Open a script from the loaded pk5/dev filesystem" },
|
|
{ IDOK, "Save script" },
|
|
{ IDC_SCRIPTEDITOR_BUTTON_SAVEAS, "Save script to a new file" },
|
|
{ IDCANCEL, "Revert to last saved version" },
|
|
{ IDC_SCRIPTEDITOR_BUTTON_FIND, "Find" },
|
|
{ IDC_SCRIPTEDITOR_BUTTON_REPLACE, "Replace" },
|
|
{ IDC_SCRIPTEDITOR_BUTTON_GOTOLINE, "Go to line" },
|
|
{ 0, NULL }
|
|
};
|
|
|
|
IMPLEMENT_DYNAMIC(DialogScriptEditor, CWnd)
|
|
|
|
BEGIN_MESSAGE_MAP(DialogScriptEditor, CWnd)
|
|
ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTW, 0, 0xFFFF, OnToolTipNotify)
|
|
ON_NOTIFY_EX_RANGE(TTN_NEEDTEXTA, 0, 0xFFFF, OnToolTipNotify)
|
|
ON_WM_CREATE()
|
|
ON_WM_DESTROY()
|
|
ON_WM_ACTIVATE()
|
|
ON_WM_MOVE()
|
|
ON_WM_SIZE()
|
|
ON_WM_SIZING()
|
|
ON_WM_SETFOCUS()
|
|
ON_WM_TIMER()
|
|
ON_WM_ERASEBKGND()
|
|
ON_WM_CTLCOLOR()
|
|
ON_WM_PAINT()
|
|
ON_WM_DRAWITEM()
|
|
ON_WM_MEASUREITEM()
|
|
ON_COMMAND(ID_FILE_NEW, OnFileNew)
|
|
ON_COMMAND(ID_FILE_OPEN, OnFileOpen)
|
|
ON_COMMAND(ID_FILE_SAVE_AS, OnFileSaveAs)
|
|
ON_COMMAND(ID_EDIT_FIND, OnEditFind)
|
|
ON_COMMAND(ID_EDIT_REPLACE, OnEditReplace)
|
|
ON_COMMAND(ID_SCRIPTEDITOR_FIND_NEXT, OnEditFindNext)
|
|
ON_COMMAND(ID_SCRIPTEDITOR_GOTOLINE, OnEditGoToLine)
|
|
ON_COMMAND(IDC_SCRIPTEDITOR_BUTTON_NEW, OnFileNew)
|
|
ON_COMMAND(IDC_SCRIPTEDITOR_BUTTON_OPEN, OnFileOpen)
|
|
ON_COMMAND(IDC_SCRIPTEDITOR_BUTTON_SAVEAS, OnFileSaveAs)
|
|
ON_COMMAND(IDC_SCRIPTEDITOR_BUTTON_FIND, OnEditFind)
|
|
ON_COMMAND(IDC_SCRIPTEDITOR_BUTTON_REPLACE, OnEditReplace)
|
|
ON_COMMAND(IDC_SCRIPTEDITOR_BUTTON_GOTOLINE, OnEditGoToLine)
|
|
ON_COMMAND(IDC_SCRIPTEDITOR_BUTTON_INTELLISENSE, OnEditShowIntelliSense)
|
|
ON_REGISTERED_MESSAGE(FindDialogMessage, OnFindDialogMessage)
|
|
ON_MESSAGE(WM_SCRIPTEDITOR_DEFERRED_INTELLISENSE, OnDeferredIntelliSense)
|
|
ON_MESSAGE(WM_SCRIPTEDITOR_INTELLISENSE_KEY, OnIntelliSenseKey)
|
|
ON_NOTIFY(EN_CHANGE, IDC_SCRIPTEDITOR_EDIT_TEXT, OnEnChangeEdit)
|
|
ON_NOTIFY(EN_SELCHANGE, IDC_SCRIPTEDITOR_EDIT_TEXT, OnEditorSelectionChanged)
|
|
ON_LBN_DBLCLK(IDC_SCRIPTEDITOR_INTELLISENSE_LIST, OnIntelliSenseDblClick)
|
|
ON_LBN_SELCHANGE(IDC_SCRIPTEDITOR_INTELLISENSE_LIST, OnIntelliSenseSelChange)
|
|
ON_BN_CLICKED(IDOK, OnBnClickedOk)
|
|
ON_BN_CLICKED(IDCANCEL, OnBnClickedCancel)
|
|
END_MESSAGE_MAP()
|
|
|
|
DialogScriptEditor::DialogScriptEditor(CWnd* pParent /*=NULL*/)
|
|
: CWnd()
|
|
, scriptEdit(NULL)
|
|
, findDlg(NULL)
|
|
, matchCase(false)
|
|
, matchWholeWords(false)
|
|
, searchForward(true)
|
|
, firstLine(1)
|
|
, isDirty(false)
|
|
, internalChange(false)
|
|
, isActive(FALSE)
|
|
, m_intelliSenseReady(false)
|
|
, m_intelliSenseCoreReady(false)
|
|
, m_virtualFileListReady(false)
|
|
, m_backgroundScanActive(false)
|
|
, m_backgroundScanNextFile(0)
|
|
, m_intelliSenseTimer(0)
|
|
, m_indexedScriptFiles(0)
|
|
, m_indexedSymbols(0) {
|
|
m_hAccel = NULL;
|
|
initialRect.SetRect(0, 0, 960, 640);
|
|
m_backBrush.CreateSolidBrush(SE_DARK_BG);
|
|
m_panelBrush.CreateSolidBrush(SE_DARK_PANEL);
|
|
m_editBrush.CreateSolidBrush(SE_DARK_EDIT);
|
|
m_hotBrush.CreateSolidBrush(SE_DARK_PANEL_2);
|
|
}
|
|
|
|
DialogScriptEditor::~DialogScriptEditor() {
|
|
if (primaryEditor == this) {
|
|
primaryEditor = NULL;
|
|
}
|
|
delete scriptEdit;
|
|
scriptEdit = NULL;
|
|
}
|
|
|
|
BOOL DialogScriptEditor::Create(CWnd* pParent, UINT nID) {
|
|
CRect rect(0, 0, 0, 0);
|
|
return Create(rect, pParent, nID);
|
|
}
|
|
|
|
BOOL DialogScriptEditor::Create(const RECT& rect, CWnd* pParent, UINT nID) {
|
|
CString className = AfxRegisterWndClass(
|
|
CS_DBLCLKS,
|
|
::LoadCursor(NULL, IDC_ARROW),
|
|
(HBRUSH)m_backBrush.GetSafeHandle(),
|
|
NULL
|
|
);
|
|
|
|
DWORD style = WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
|
|
DWORD exStyle = 0;
|
|
if (pParent) {
|
|
style |= WS_CHILD;
|
|
}
|
|
else {
|
|
style |= WS_OVERLAPPEDWINDOW | WS_VISIBLE;
|
|
exStyle |= WS_EX_APPWINDOW;
|
|
}
|
|
|
|
return CWnd::CreateEx(
|
|
exStyle,
|
|
className,
|
|
"Script Editor",
|
|
style,
|
|
rect,
|
|
pParent,
|
|
nID
|
|
);
|
|
}
|
|
|
|
DialogScriptEditor* DialogScriptEditor::GetPrimaryEditor(void) {
|
|
return primaryEditor;
|
|
}
|
|
|
|
DialogScriptEditor* ScriptEditorGetPrimaryEditor(void) {
|
|
return DialogScriptEditor::GetPrimaryEditor();
|
|
}
|
|
|
|
int DialogScriptEditor::OnCreate(LPCREATESTRUCT lpCreateStruct) {
|
|
if (CWnd::OnCreate(lpCreateStruct) == -1) {
|
|
return -1;
|
|
}
|
|
|
|
primaryEditor = this;
|
|
com_editors |= EDITOR_SCRIPT;
|
|
|
|
InitEditorChrome();
|
|
ApplyDarkTheme();
|
|
|
|
m_hAccel = ::LoadAccelerators(AfxGetResourceHandle(), MAKEINTRESOURCE(IDR_ACCELERATOR_SCRIPTEDITOR));
|
|
|
|
EnableToolTips(TRUE);
|
|
EnsureIntelliSenseCore();
|
|
// Do not enumerate or parse every pk5 script synchronously while the dock tab
|
|
// is being created. A short timer starts the incremental background indexer
|
|
// after the window is visible and responsive.
|
|
if (m_intelliSenseTimer == 0) {
|
|
m_intelliSenseTimer = SetTimer(SE_INTELLISENSE_TIMER_ID, 250, NULL);
|
|
}
|
|
UpdateLanguageLabel("TEXT");
|
|
UpdateTitle();
|
|
UpdateStatusBar();
|
|
LayoutChildren();
|
|
SetDirty(false);
|
|
|
|
return 0;
|
|
}
|
|
|
|
void DialogScriptEditor::InitEditorChrome(void) {
|
|
ScriptEditorCreateFontPixels(m_uiFont, "Segoe UI", 9, false);
|
|
ScriptEditorCreateFontPixels(m_editorFont, "Consolas", 11, true);
|
|
|
|
m_titleLabel.Create("SCRIPT EDITOR", WS_CHILD | WS_VISIBLE | SS_CENTERIMAGE, CRect(0, 0, 0, 0), this, IDC_SCRIPTEDITOR_TITLE);
|
|
m_pathLabel.Create("No file loaded", WS_CHILD | WS_VISIBLE | SS_CENTERIMAGE, CRect(0, 0, 0, 0), this, IDC_SCRIPTEDITOR_PATH);
|
|
m_languageLabel.Create("", WS_CHILD | WS_VISIBLE | SS_CENTERIMAGE, CRect(0, 0, 0, 0), this, IDC_SCRIPTEDITOR_LANGUAGE);
|
|
m_statusLine.Create("", WS_CHILD | WS_VISIBLE | SS_CENTERIMAGE, CRect(0, 0, 0, 0), this, IDC_SCRIPTEDITOR_STATUS);
|
|
m_signatureHelp.Create("", WS_CHILD | SS_CENTERIMAGE | SS_LEFT, CRect(0, 0, 0, 0), this, IDC_SCRIPTEDITOR_SIGNATURE_HELP);
|
|
m_signatureHelp.ShowWindow(SW_HIDE);
|
|
|
|
newButton.Create("New", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, CRect(0, 0, 0, 0), this, IDC_SCRIPTEDITOR_BUTTON_NEW);
|
|
openButton.Create("Open Script...", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, CRect(0, 0, 0, 0), this, IDC_SCRIPTEDITOR_BUTTON_OPEN);
|
|
okButton.Create("Save", WS_CHILD | WS_VISIBLE | BS_DEFPUSHBUTTON, CRect(0, 0, 0, 0), this, IDOK);
|
|
saveAsButton.Create("Save As...", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, CRect(0, 0, 0, 0), this, IDC_SCRIPTEDITOR_BUTTON_SAVEAS);
|
|
cancelButton.Create("Revert", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, CRect(0, 0, 0, 0), this, IDCANCEL);
|
|
findButton.Create("Find", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, CRect(0, 0, 0, 0), this, IDC_SCRIPTEDITOR_BUTTON_FIND);
|
|
replaceButton.Create("Replace", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, CRect(0, 0, 0, 0), this, IDC_SCRIPTEDITOR_BUTTON_REPLACE);
|
|
goToButton.Create("Go To", WS_CHILD | WS_VISIBLE | BS_PUSHBUTTON, CRect(0, 0, 0, 0), this, IDC_SCRIPTEDITOR_BUTTON_GOTOLINE);
|
|
|
|
scriptEdit = new CScriptEditorCtrl();
|
|
scriptEdit->Create(this, IDC_SCRIPTEDITOR_EDIT_TEXT);
|
|
scriptEdit->LimitText(1024 * 1024);
|
|
scriptEdit->SetFont(&m_editorFont);
|
|
scriptEdit->RefreshMetrics();
|
|
|
|
m_intellisenseList.Create(
|
|
WS_CHILD | WS_BORDER | WS_VSCROLL | LBS_NOTIFY | LBS_NOINTEGRALHEIGHT | LBS_OWNERDRAWFIXED | LBS_HASSTRINGS,
|
|
CRect(0, 0, 0, 0),
|
|
this,
|
|
IDC_SCRIPTEDITOR_INTELLISENSE_LIST
|
|
);
|
|
m_intellisenseList.ShowWindow(SW_HIDE);
|
|
|
|
CWnd* fontWindows[] = {
|
|
&m_titleLabel, &m_pathLabel, &m_languageLabel, &m_statusLine, &m_signatureHelp,
|
|
&newButton, &openButton, &okButton, &saveAsButton, &cancelButton, &findButton, &replaceButton, &goToButton,
|
|
&m_intellisenseList
|
|
};
|
|
for (int i = 0; i < sizeof(fontWindows) / sizeof(fontWindows[0]); i++) {
|
|
if (fontWindows[i] && fontWindows[i]->GetSafeHwnd()) {
|
|
fontWindows[i]->SetFont(&m_uiFont);
|
|
}
|
|
}
|
|
}
|
|
|
|
void DialogScriptEditor::ApplyDarkTheme(void) {
|
|
ScriptEditorSubclassStatic(m_titleLabel);
|
|
ScriptEditorSubclassStatic(m_pathLabel);
|
|
ScriptEditorSubclassStatic(m_languageLabel);
|
|
ScriptEditorSubclassStatic(m_statusLine);
|
|
ScriptEditorSubclassStatic(m_signatureHelp);
|
|
|
|
ScriptEditorSubclassButton(newButton);
|
|
ScriptEditorSubclassButton(openButton);
|
|
ScriptEditorSubclassButton(okButton);
|
|
ScriptEditorSubclassButton(saveAsButton);
|
|
ScriptEditorSubclassButton(cancelButton);
|
|
ScriptEditorSubclassButton(findButton);
|
|
ScriptEditorSubclassButton(replaceButton);
|
|
ScriptEditorSubclassButton(goToButton);
|
|
ScriptEditorSubclassList(m_intellisenseList);
|
|
|
|
ScriptEditorApplyNativeDarkTheme(newButton.GetSafeHwnd());
|
|
ScriptEditorApplyNativeDarkTheme(openButton.GetSafeHwnd());
|
|
ScriptEditorApplyNativeDarkTheme(okButton.GetSafeHwnd());
|
|
ScriptEditorApplyNativeDarkTheme(saveAsButton.GetSafeHwnd());
|
|
ScriptEditorApplyNativeDarkTheme(cancelButton.GetSafeHwnd());
|
|
ScriptEditorApplyNativeDarkTheme(findButton.GetSafeHwnd());
|
|
ScriptEditorApplyNativeDarkTheme(replaceButton.GetSafeHwnd());
|
|
ScriptEditorApplyNativeDarkTheme(goToButton.GetSafeHwnd());
|
|
ScriptEditorApplyNativeDarkTheme(m_intellisenseList.GetSafeHwnd());
|
|
}
|
|
|
|
BOOL DialogScriptEditor::PreTranslateMessage(MSG* pMsg) {
|
|
if (HandleIntelliSenseKey(pMsg)) {
|
|
return TRUE;
|
|
}
|
|
if (pMsg && WM_KEYFIRST <= pMsg->message && pMsg->message <= WM_KEYLAST) {
|
|
if (m_hAccel && GetSafeHwnd() && ::TranslateAccelerator(m_hWnd, m_hAccel, pMsg)) {
|
|
return TRUE;
|
|
}
|
|
}
|
|
return CWnd::PreTranslateMessage(pMsg);
|
|
}
|
|
|
|
BOOL DialogScriptEditor::OnCmdMsg(UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* pHandlerInfo) {
|
|
if (CWnd::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo)) {
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
void DialogScriptEditor::InitScriptEvents(void) {
|
|
int index;
|
|
idParser src;
|
|
idToken token;
|
|
idStr whiteSpace;
|
|
scriptEventInfo_t info;
|
|
|
|
if (!src.LoadFile("script/doom_events.script")) {
|
|
return;
|
|
}
|
|
|
|
scriptEvents.Clear();
|
|
|
|
while (src.ReadToken(&token)) {
|
|
if (token == "scriptEvent") {
|
|
src.GetLastWhiteSpace(whiteSpace);
|
|
index = whiteSpace.Find("//");
|
|
if (index != -1) {
|
|
info.help = whiteSpace.Right(whiteSpace.Length() - index);
|
|
info.help.Replace("\r", "");
|
|
info.help.Replace("\n", "\r\n");
|
|
}
|
|
else {
|
|
info.help = "";
|
|
}
|
|
|
|
src.ExpectTokenType(TT_NAME, 0, &token);
|
|
info.parms = token;
|
|
|
|
src.ExpectTokenType(TT_NAME, 0, &token);
|
|
info.name = token;
|
|
|
|
src.ExpectTokenString("(");
|
|
|
|
info.parms += " " + info.name + "(";
|
|
while (src.ReadToken(&token) && token != ";") {
|
|
info.parms.Append(" " + token);
|
|
}
|
|
|
|
scriptEvents.Append(info);
|
|
}
|
|
}
|
|
}
|
|
|
|
void DialogScriptEditor::EnsureIntelliSenseCore(void) {
|
|
if (scriptCoreBuilt) {
|
|
m_intelliSenseCoreReady = true;
|
|
m_intelliSenseReady = true;
|
|
m_indexedSymbols = scriptCompletions.Num();
|
|
return;
|
|
}
|
|
|
|
// Fast path only: keywords and the engine event definitions. This deliberately
|
|
// does not scan every script file so the editor tab can open immediately.
|
|
InitScriptEvents();
|
|
for (int k = 0; scriptKeywords[k]; k++) {
|
|
ScriptEditorAddCompletion(scriptKeywords[k], scriptKeywords[k], "keyword", "built-in", "script keyword", 100);
|
|
}
|
|
for (int k = 0; guiKeywords[k]; k++) {
|
|
ScriptEditorAddCompletion(guiKeywords[k], guiKeywords[k], "gui", "built-in", "gui keyword", 90);
|
|
}
|
|
for (int i = 0; i < scriptEvents.Num(); i++) {
|
|
ScriptEditorAddCompletion(scriptEvents[i].name.c_str(), scriptEvents[i].name.c_str(), "event", "script/doom_events.script", scriptEvents[i].parms.c_str(), 140);
|
|
}
|
|
|
|
scriptCoreBuilt = true;
|
|
m_intelliSenseCoreReady = true;
|
|
m_intelliSenseReady = true;
|
|
m_indexedSymbols = scriptCompletions.Num();
|
|
}
|
|
|
|
void DialogScriptEditor::RebuildVirtualScriptFileList(void) {
|
|
scriptVirtualFiles.Clear();
|
|
|
|
if (fileSystem) {
|
|
// Try both common extension spellings. Different idTech file-system forks
|
|
// disagree about whether ListFilesTree wants ".script" or "script".
|
|
ScriptEditorListVirtualFilesFromTree("script", ".script");
|
|
ScriptEditorListVirtualFilesFromTree("script", "script");
|
|
ScriptEditorListVirtualFilesFromTree("scripts", ".script");
|
|
ScriptEditorListVirtualFilesFromTree("scripts", "script");
|
|
ScriptEditorListVirtualFilesFromTree("guis", ".gui");
|
|
ScriptEditorListVirtualFilesFromTree("guis", "gui");
|
|
ScriptEditorListVirtualFilesFromTree("gui", ".gui");
|
|
ScriptEditorListVirtualFilesFromTree("gui", "gui");
|
|
|
|
// Last-resort root scan. This catches pk5s that do not expose the expected
|
|
// directory listing under script/ but do expose extension queries globally.
|
|
if (scriptVirtualFiles.Num() <= 1) {
|
|
ScriptEditorListVirtualFilesFromTree("", ".script");
|
|
ScriptEditorListVirtualFilesFromTree("", "script");
|
|
ScriptEditorListVirtualFilesFromTree("", ".gui");
|
|
ScriptEditorListVirtualFilesFromTree("", "gui");
|
|
}
|
|
}
|
|
|
|
// Keep the core event file available even if a particular filesystem backend
|
|
// does not include it in a directory listing.
|
|
ScriptEditorAddVirtualFile("", "script/doom_events.script");
|
|
scriptVirtualFileListBuilt = true;
|
|
m_virtualFileListReady = true;
|
|
}
|
|
|
|
void DialogScriptEditor::EnsureVirtualScriptFileList(bool forceRebuild) {
|
|
if (forceRebuild || !scriptVirtualFileListBuilt) {
|
|
RebuildVirtualScriptFileList();
|
|
}
|
|
else {
|
|
m_virtualFileListReady = true;
|
|
}
|
|
}
|
|
|
|
void DialogScriptEditor::StartIntelliSenseBackgroundScan(bool forceRebuild) {
|
|
if (forceRebuild) {
|
|
if (m_intelliSenseTimer) {
|
|
KillTimer(m_intelliSenseTimer);
|
|
m_intelliSenseTimer = 0;
|
|
}
|
|
scriptCompletions.Clear();
|
|
scriptEvents.Clear();
|
|
scriptCoreBuilt = false;
|
|
scriptDatabaseBuilt = false;
|
|
scriptVirtualFileListBuilt = false;
|
|
m_intelliSenseCoreReady = false;
|
|
m_virtualFileListReady = false;
|
|
m_backgroundScanNextFile = 0;
|
|
m_indexedScriptFiles = 0;
|
|
m_indexedSymbols = 0;
|
|
}
|
|
|
|
EnsureIntelliSenseCore();
|
|
if (scriptDatabaseBuilt && !forceRebuild) {
|
|
m_backgroundScanActive = false;
|
|
return;
|
|
}
|
|
|
|
// Directory enumeration is cheap compared to parsing every file and is needed
|
|
// for the Open Script browser. The heavier parsing below happens by timer.
|
|
EnsureVirtualScriptFileList(forceRebuild);
|
|
|
|
if (scriptVirtualFiles.Num() <= 0) {
|
|
m_backgroundScanActive = false;
|
|
return;
|
|
}
|
|
|
|
m_backgroundScanActive = true;
|
|
if (m_intelliSenseTimer == 0 && GetSafeHwnd()) {
|
|
m_intelliSenseTimer = SetTimer(SE_INTELLISENSE_TIMER_ID, 40, NULL);
|
|
}
|
|
}
|
|
|
|
void DialogScriptEditor::IndexNextScriptFiles(int maxFiles) {
|
|
if (!m_backgroundScanActive) {
|
|
return;
|
|
}
|
|
|
|
EnsureIntelliSenseCore();
|
|
EnsureVirtualScriptFileList(false);
|
|
|
|
int indexedThisTick = 0;
|
|
while (m_backgroundScanNextFile < scriptVirtualFiles.Num() && indexedThisTick < maxFiles) {
|
|
const char* path = scriptVirtualFiles[m_backgroundScanNextFile].c_str();
|
|
m_backgroundScanNextFile++;
|
|
|
|
// doom_events.script is already parsed by InitScriptEvents(), but scanning it
|
|
// again is harmless. Skipping it avoids duplicated generic function symbols.
|
|
if (idStr::Icmp(path, "script/doom_events.script") == 0) {
|
|
continue;
|
|
}
|
|
|
|
idStr text;
|
|
if (LoadTextFromFile(path, text)) {
|
|
ScriptEditorRemoveCompletionsFromSource(path);
|
|
ScriptEditorScanTextForCompletions(path, text.c_str());
|
|
m_indexedScriptFiles++;
|
|
}
|
|
indexedThisTick++;
|
|
}
|
|
|
|
m_indexedSymbols = scriptCompletions.Num();
|
|
if (m_backgroundScanNextFile >= scriptVirtualFiles.Num()) {
|
|
m_backgroundScanActive = false;
|
|
scriptDatabaseBuilt = true;
|
|
if (m_intelliSenseTimer) {
|
|
KillTimer(m_intelliSenseTimer);
|
|
m_intelliSenseTimer = 0;
|
|
}
|
|
if (m_statusLine.GetSafeHwnd()) {
|
|
CString status;
|
|
status.Format("IntelliSense ready: indexed %d script/gui files and %d symbols.", m_indexedScriptFiles, m_indexedSymbols);
|
|
m_statusLine.SetWindowText(status);
|
|
}
|
|
}
|
|
else if (m_statusLine.GetSafeHwnd()) {
|
|
CString status;
|
|
status.Format("IntelliSense indexing %d/%d files...", m_backgroundScanNextFile, scriptVirtualFiles.Num());
|
|
m_statusLine.SetWindowText(status);
|
|
}
|
|
}
|
|
|
|
void DialogScriptEditor::UpdateLiveCompletions(void) {
|
|
ScriptEditorRemoveCompletionsFromSource("<current buffer>");
|
|
if (!scriptEdit) {
|
|
return;
|
|
}
|
|
idStr text;
|
|
scriptEdit->GetText(text);
|
|
if (text.Length() > 0) {
|
|
ScriptEditorScanTextForCompletions("<current buffer>", text.c_str());
|
|
}
|
|
m_indexedSymbols = scriptCompletions.Num();
|
|
}
|
|
|
|
void DialogScriptEditor::BuildIntelliSenseDatabase(bool forceRebuild) {
|
|
StartIntelliSenseBackgroundScan(forceRebuild);
|
|
}
|
|
|
|
void DialogScriptEditor::ConfigureEditorForFile(const char* newFileName) {
|
|
idStr extension;
|
|
idStr(newFileName ? newFileName : "").ExtractFileExtension(extension);
|
|
|
|
if (!scriptEdit) {
|
|
return;
|
|
}
|
|
|
|
EnsureIntelliSenseCore();
|
|
|
|
scriptEdit->SetCaseSensitive(false);
|
|
scriptEdit->ClearKeywords();
|
|
scriptEdit->ClearFunctionWords();
|
|
|
|
if (extension.Icmp("script") == 0) {
|
|
scriptEdit->SetCaseSensitive(true);
|
|
for (int k = 0; scriptKeywords[k]; k++) {
|
|
scriptEdit->AddKeyword(scriptKeywords[k]);
|
|
}
|
|
scriptEdit->LoadKeyWordsFromFile("editors/script.def");
|
|
for (int i = 0; i < scriptCompletions.Num(); i++) {
|
|
if (scriptCompletions[i].kind.Icmp("function") == 0 || scriptCompletions[i].kind.Icmp("event") == 0) {
|
|
scriptEdit->AddFunctionWord(scriptCompletions[i].name.c_str());
|
|
}
|
|
}
|
|
UpdateLanguageLabel("SCRIPT");
|
|
}
|
|
else if (extension.Icmp("gui") == 0) {
|
|
for (int k = 0; guiKeywords[k]; k++) {
|
|
scriptEdit->AddKeyword(guiKeywords[k]);
|
|
}
|
|
scriptEdit->LoadKeyWordsFromFile("editors/gui.def");
|
|
UpdateLanguageLabel("GUI");
|
|
}
|
|
else {
|
|
for (int k = 0; scriptKeywords[k]; k++) {
|
|
scriptEdit->AddKeyword(scriptKeywords[k]);
|
|
}
|
|
UpdateLanguageLabel(extension.Length() ? extension.c_str() : "TEXT");
|
|
}
|
|
}
|
|
|
|
bool DialogScriptEditor::IsNativeFilePath(const char* path) const {
|
|
if (!path || !path[0]) {
|
|
return false;
|
|
}
|
|
if (path[0] && path[1] == ':') {
|
|
return true;
|
|
}
|
|
if (path[0] == '\\' || path[0] == '/') {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool DialogScriptEditor::LoadTextFromFile(const char* path, idStr& text) const {
|
|
text = "";
|
|
if (!path || !path[0]) {
|
|
return false;
|
|
}
|
|
|
|
void* buffer = NULL;
|
|
if (fileSystem && fileSystem->ReadFile(path, &buffer) != -1) {
|
|
text = (char*)buffer;
|
|
fileSystem->FreeFile(buffer);
|
|
return true;
|
|
}
|
|
|
|
FILE* fp = fopen(path, "rb");
|
|
if (!fp) {
|
|
return false;
|
|
}
|
|
fseek(fp, 0, SEEK_END);
|
|
long len = ftell(fp);
|
|
fseek(fp, 0, SEEK_SET);
|
|
if (len < 0) {
|
|
fclose(fp);
|
|
return false;
|
|
}
|
|
char* raw = new char[len + 1];
|
|
long readLen = (long)fread(raw, 1, len, fp);
|
|
raw[readLen] = '\0';
|
|
fclose(fp);
|
|
text = raw;
|
|
delete[] raw;
|
|
return true;
|
|
}
|
|
|
|
bool DialogScriptEditor::WriteTextToFile(const char* path, const char* text, int textLength) const {
|
|
if (!path || !path[0]) {
|
|
return false;
|
|
}
|
|
|
|
if (IsNativeFilePath(path)) {
|
|
FILE* fp = fopen(path, "wb");
|
|
if (!fp) {
|
|
return false;
|
|
}
|
|
int written = (int)fwrite(text, 1, textLength, fp);
|
|
fclose(fp);
|
|
return written == textLength;
|
|
}
|
|
|
|
return fileSystem && fileSystem->WriteFile(path, text, textLength, "fs_devpath") != -1;
|
|
}
|
|
|
|
bool DialogScriptEditor::OpenFileFromDialog(void) {
|
|
EnsureVirtualScriptFileList(true);
|
|
StartIntelliSenseBackgroundScan(false);
|
|
|
|
CString selectedPath;
|
|
CScriptFileBrowserWnd browser;
|
|
if (browser.DoModal(this, selectedPath) != IDOK || selectedPath.IsEmpty()) {
|
|
FocusEditor();
|
|
return false;
|
|
}
|
|
|
|
OpenFile(selectedPath);
|
|
return true;
|
|
}
|
|
|
|
bool DialogScriptEditor::PromptSavePath(CString& selectedPath) {
|
|
CString suggested;
|
|
if (fileName.Length() > 0) {
|
|
suggested = fileName.c_str();
|
|
}
|
|
else {
|
|
suggested = "script/new_script.script";
|
|
}
|
|
|
|
CScriptSavePathWnd prompt;
|
|
return prompt.DoModal(this, selectedPath, suggested) == IDOK && !selectedPath.IsEmpty();
|
|
}
|
|
|
|
|
|
bool DialogScriptEditor::SaveFileAs(void) {
|
|
return SaveFileAsDialog();
|
|
}
|
|
|
|
bool DialogScriptEditor::SaveFileAsDialog(void) {
|
|
CString selectedPath;
|
|
if (!PromptSavePath(selectedPath)) {
|
|
FocusEditor();
|
|
return false;
|
|
}
|
|
|
|
idStr oldFileName = fileName;
|
|
fileName = (LPCTSTR)selectedPath;
|
|
ConfigureEditorForFile(fileName.c_str());
|
|
|
|
if (!SaveFile()) {
|
|
fileName = oldFileName;
|
|
UpdateTitle();
|
|
FocusEditor();
|
|
return false;
|
|
}
|
|
|
|
ScriptEditorAddVirtualFile("", fileName.c_str());
|
|
scriptVirtualFileListBuilt = true;
|
|
m_virtualFileListReady = true;
|
|
UpdateTitle();
|
|
FocusEditor();
|
|
return true;
|
|
}
|
|
|
|
void DialogScriptEditor::NewFile(void) {
|
|
if (!ConfirmDiscardChanges()) {
|
|
FocusEditor();
|
|
return;
|
|
}
|
|
|
|
fileName = "";
|
|
loadedText = "";
|
|
ConfigureEditorForFile("script/new_script.script");
|
|
SetEditorTextNormalized("");
|
|
SetDirty(false);
|
|
UpdateTitle();
|
|
UpdateStatusBar();
|
|
FocusEditor();
|
|
}
|
|
|
|
void DialogScriptEditor::OpenFile(const char* newFileName) {
|
|
if (!GetSafeHwnd() || !newFileName || !newFileName[0] || !scriptEdit) {
|
|
return;
|
|
}
|
|
|
|
if (!ConfirmDiscardChanges()) {
|
|
return;
|
|
}
|
|
|
|
idStr scriptText;
|
|
if (!LoadTextFromFile(newFileName, scriptText)) {
|
|
MessageBox(va("Couldn't open: %s", newFileName), "Script Editor", MB_OK | MB_ICONERROR);
|
|
return;
|
|
}
|
|
|
|
fileName = newFileName;
|
|
ConfigureEditorForFile(fileName.c_str());
|
|
SetEditorTextNormalized(scriptText.c_str());
|
|
loadedText = scriptText;
|
|
loadedText.Replace("\r\n", "\n");
|
|
loadedText.Replace("\r", "\n");
|
|
loadedText.Replace("\v", "\n");
|
|
SetDirty(false);
|
|
UpdateTitle();
|
|
UpdateStatusBar();
|
|
FocusEditor();
|
|
}
|
|
|
|
void DialogScriptEditor::SetEditorTextNormalized(const char* text) {
|
|
internalChange = true;
|
|
if (scriptEdit) {
|
|
scriptEdit->SetText(text ? text : "");
|
|
}
|
|
internalChange = false;
|
|
}
|
|
|
|
bool DialogScriptEditor::GetEditorTextNormalized(idStr& text) const {
|
|
if (!scriptEdit || !scriptEdit->GetSafeHwnd()) {
|
|
text = "";
|
|
return false;
|
|
}
|
|
|
|
idStr raw;
|
|
scriptEdit->GetText(raw);
|
|
CString crlf = ScriptEditorToCRLF(CString(raw.c_str()));
|
|
text = (LPCTSTR)crlf;
|
|
return true;
|
|
}
|
|
|
|
bool DialogScriptEditor::SaveFile(void) {
|
|
if (fileName.Length() == 0) {
|
|
return SaveFileAsDialog();
|
|
}
|
|
|
|
idStr scriptText;
|
|
GetEditorTextNormalized(scriptText);
|
|
|
|
common->Printf("Writing '%s'...\n", fileName.c_str());
|
|
if (!WriteTextToFile(fileName.c_str(), scriptText.c_str(), scriptText.Length())) {
|
|
MessageBox(va("Couldn't save: %s", fileName.c_str()), va("Error saving: %s", fileName.c_str()), MB_OK | MB_ICONERROR);
|
|
return false;
|
|
}
|
|
|
|
loadedText = scriptText;
|
|
loadedText.Replace("\r\n", "\n");
|
|
loadedText.Replace("\r", "\n");
|
|
SetDirty(false);
|
|
UpdateStatusBar();
|
|
return true;
|
|
}
|
|
|
|
bool DialogScriptEditor::ReloadFile(void) {
|
|
if (fileName.Length() == 0) {
|
|
return false;
|
|
}
|
|
idStr oldName = fileName;
|
|
fileName = "";
|
|
OpenFile(oldName.c_str());
|
|
return true;
|
|
}
|
|
|
|
bool DialogScriptEditor::HasOpenFile(void) const {
|
|
return fileName.Length() > 0;
|
|
}
|
|
|
|
bool DialogScriptEditor::IsDirty(void) const {
|
|
return isDirty;
|
|
}
|
|
|
|
const char* DialogScriptEditor::GetFileName(void) const {
|
|
return fileName.c_str();
|
|
}
|
|
|
|
bool DialogScriptEditor::ConfirmDiscardChanges(void) {
|
|
if (!isDirty) {
|
|
return true;
|
|
}
|
|
|
|
int result = MessageBox("The current script has unsaved changes. Save them before continuing?", "Script Editor", MB_YESNOCANCEL | MB_ICONQUESTION);
|
|
if (result == IDCANCEL) {
|
|
return false;
|
|
}
|
|
if (result == IDYES) {
|
|
return SaveFile();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void DialogScriptEditor::SetDirty(bool dirty) {
|
|
isDirty = dirty;
|
|
if (okButton.GetSafeHwnd()) {
|
|
okButton.EnableWindow(dirty || fileName.Length() == 0);
|
|
}
|
|
if (saveAsButton.GetSafeHwnd()) {
|
|
saveAsButton.EnableWindow(TRUE);
|
|
}
|
|
if (cancelButton.GetSafeHwnd()) {
|
|
cancelButton.EnableWindow(fileName.Length() > 0);
|
|
}
|
|
UpdateTitle();
|
|
}
|
|
|
|
void DialogScriptEditor::UpdateTitle(void) {
|
|
CString title;
|
|
if (fileName.Length() > 0) {
|
|
title.Format("SCRIPT EDITOR%s", isDirty ? " *" : "");
|
|
m_pathLabel.SetWindowText(fileName.c_str());
|
|
}
|
|
else {
|
|
title.Format("SCRIPT EDITOR%s", isDirty ? " *" : "");
|
|
m_pathLabel.SetWindowText(isDirty ? "New script (not saved yet)" : "No file loaded");
|
|
}
|
|
m_titleLabel.SetWindowText(title);
|
|
SetWindowText(fileName.Length() > 0 ? va("Script Editor (%s)%s", fileName.c_str(), isDirty ? " *" : "") : "Script Editor");
|
|
}
|
|
|
|
void DialogScriptEditor::UpdateLanguageLabel(const char* extension) {
|
|
CString text;
|
|
if (m_intelliSenseReady) {
|
|
text.Format("%s | IntelliSense: %d symbols", extension && extension[0] ? extension : "TEXT", m_indexedSymbols);
|
|
}
|
|
else {
|
|
text.Format("%s | IntelliSense indexing...", extension && extension[0] ? extension : "TEXT");
|
|
}
|
|
m_languageLabel.SetWindowText(text);
|
|
}
|
|
|
|
void DialogScriptEditor::UpdateStatusBar(void) {
|
|
if (!scriptEdit || !scriptEdit->GetSafeHwnd() || !m_statusLine.GetSafeHwnd()) {
|
|
return;
|
|
}
|
|
|
|
int line = 0;
|
|
int column = 0;
|
|
int character = 0;
|
|
scriptEdit->GetCursorPos(line, column, character);
|
|
|
|
CString status;
|
|
status.Format("Line: %d Column: %d Character: %d%s", line, column, character, isDirty ? " Modified" : "");
|
|
m_statusLine.SetWindowText(status);
|
|
}
|
|
|
|
void DialogScriptEditor::LayoutChildren(void) {
|
|
if (!GetSafeHwnd()) {
|
|
return;
|
|
}
|
|
|
|
CRect client;
|
|
GetClientRect(client);
|
|
|
|
const int margin = 8;
|
|
const int topH = 58;
|
|
const int bottomH = 24;
|
|
const int buttonH = 24;
|
|
const int buttonGap = 6;
|
|
int x = client.left + margin;
|
|
int y = client.top + 6;
|
|
|
|
if (m_titleLabel.GetSafeHwnd()) {
|
|
m_titleLabel.MoveWindow(x, y, 160, 22, TRUE);
|
|
}
|
|
|
|
int rightX = client.right - margin;
|
|
CWnd* buttons[] = { &newButton, &openButton, &okButton, &saveAsButton, &cancelButton, &findButton, &replaceButton, &goToButton };
|
|
int widths[] = { 58, 112, 66, 86, 72, 64, 74, 68 };
|
|
for (int i = sizeof(buttons) / sizeof(buttons[0]) - 1; i >= 0; i--) {
|
|
if (buttons[i]->GetSafeHwnd()) {
|
|
rightX -= widths[i];
|
|
buttons[i]->MoveWindow(rightX, y, widths[i], buttonH, TRUE);
|
|
rightX -= buttonGap;
|
|
}
|
|
}
|
|
|
|
CRect pathRect(x, y + 26, client.right - margin - 250, y + 48);
|
|
if (pathRect.right < pathRect.left + 80) {
|
|
pathRect.right = pathRect.left + 80;
|
|
}
|
|
if (m_pathLabel.GetSafeHwnd()) {
|
|
m_pathLabel.MoveWindow(pathRect, TRUE);
|
|
}
|
|
if (m_languageLabel.GetSafeHwnd()) {
|
|
m_languageLabel.MoveWindow(client.right - margin - 240, y + 26, 240, 22, TRUE);
|
|
}
|
|
|
|
CRect editRect(
|
|
client.left + margin,
|
|
client.top + topH,
|
|
client.right - margin,
|
|
client.bottom - bottomH - margin
|
|
);
|
|
if (editRect.Width() < SE_MIN_EDITOR_WIDTH) {
|
|
editRect.right = editRect.left + SE_MIN_EDITOR_WIDTH;
|
|
}
|
|
if (editRect.Height() < SE_MIN_EDITOR_HEIGHT) {
|
|
editRect.bottom = editRect.top + SE_MIN_EDITOR_HEIGHT;
|
|
}
|
|
if (scriptEdit && scriptEdit->GetSafeHwnd()) {
|
|
scriptEdit->MoveWindow(editRect, TRUE);
|
|
}
|
|
|
|
if (m_statusLine.GetSafeHwnd()) {
|
|
m_statusLine.MoveWindow(client.left + margin, client.bottom - bottomH, client.Width() - margin * 2, bottomH - 2, TRUE);
|
|
}
|
|
|
|
if (m_intellisenseList.GetSafeHwnd() && m_intellisenseList.IsWindowVisible()) {
|
|
PositionIntelliSenseWindow();
|
|
}
|
|
if (m_signatureHelp.GetSafeHwnd() && m_signatureHelp.IsWindowVisible()) {
|
|
PositionParameterHint();
|
|
}
|
|
}
|
|
|
|
void DialogScriptEditor::SetActive(BOOL bActive) {
|
|
isActive = bActive;
|
|
if (bActive) {
|
|
FocusEditor();
|
|
}
|
|
}
|
|
|
|
void DialogScriptEditor::FocusEditor(void) {
|
|
if (scriptEdit && scriptEdit->GetSafeHwnd()) {
|
|
scriptEdit->SetFocus();
|
|
}
|
|
}
|
|
|
|
void DialogScriptEditor::OnSize(UINT nType, int cx, int cy) {
|
|
CWnd::OnSize(nType, cx, cy);
|
|
LayoutChildren();
|
|
}
|
|
|
|
void DialogScriptEditor::OnSizing(UINT nSide, LPRECT lpRect) {
|
|
CWnd::OnSizing(nSide, lpRect);
|
|
if (!lpRect) {
|
|
return;
|
|
}
|
|
if (lpRect->right - lpRect->left < initialRect.Width()) {
|
|
lpRect->right = lpRect->left + initialRect.Width();
|
|
}
|
|
if (lpRect->bottom - lpRect->top < initialRect.Height()) {
|
|
lpRect->bottom = lpRect->top + initialRect.Height();
|
|
}
|
|
}
|
|
|
|
void DialogScriptEditor::OnMove(int x, int y) {
|
|
CWnd::OnMove(x, y);
|
|
}
|
|
|
|
void DialogScriptEditor::OnActivate(UINT nState, CWnd* pWndOther, BOOL bMinimized) {
|
|
CWnd::OnActivate(nState, pWndOther, bMinimized);
|
|
}
|
|
|
|
void DialogScriptEditor::OnSetFocus(CWnd* pOldWnd) {
|
|
CWnd::OnSetFocus(pOldWnd);
|
|
FocusEditor();
|
|
}
|
|
|
|
void DialogScriptEditor::OnTimer(UINT_PTR nIDEvent) {
|
|
if (nIDEvent == SE_INTELLISENSE_TIMER_ID) {
|
|
if (!m_backgroundScanActive) {
|
|
if (scriptDatabaseBuilt) {
|
|
KillTimer(m_intelliSenseTimer);
|
|
m_intelliSenseTimer = 0;
|
|
return;
|
|
}
|
|
StartIntelliSenseBackgroundScan(false);
|
|
}
|
|
if (m_backgroundScanActive) {
|
|
IndexNextScriptFiles(2);
|
|
}
|
|
else if (m_intelliSenseTimer) {
|
|
KillTimer(m_intelliSenseTimer);
|
|
m_intelliSenseTimer = 0;
|
|
}
|
|
return;
|
|
}
|
|
CWnd::OnTimer(nIDEvent);
|
|
}
|
|
|
|
void DialogScriptEditor::OnDestroy() {
|
|
if (m_intelliSenseTimer) {
|
|
KillTimer(m_intelliSenseTimer);
|
|
m_intelliSenseTimer = 0;
|
|
}
|
|
if (findDlg) {
|
|
if (findDlg->GetSafeHwnd()) {
|
|
findDlg->DestroyWindow();
|
|
}
|
|
delete findDlg;
|
|
findDlg = NULL;
|
|
}
|
|
if (primaryEditor == this) {
|
|
primaryEditor = NULL;
|
|
}
|
|
CWnd::OnDestroy();
|
|
}
|
|
|
|
BOOL DialogScriptEditor::OnEraseBkgnd(CDC* pDC) {
|
|
CRect client;
|
|
GetClientRect(client);
|
|
pDC->FillSolidRect(client, SE_DARK_BG);
|
|
return TRUE;
|
|
}
|
|
|
|
void DialogScriptEditor::OnPaint() {
|
|
CPaintDC dc(this);
|
|
CRect client;
|
|
GetClientRect(client);
|
|
dc.FillSolidRect(client, SE_DARK_BG);
|
|
|
|
CRect header(client.left, client.top, client.right, client.top + 56);
|
|
dc.FillSolidRect(header, SE_DARK_PANEL);
|
|
dc.FillSolidRect(client.left, header.bottom - 1, client.Width(), 1, SE_DARK_BORDER);
|
|
|
|
CRect editFrame;
|
|
if (scriptEdit && scriptEdit->GetSafeHwnd()) {
|
|
scriptEdit->GetWindowRect(editFrame);
|
|
ScreenToClient(editFrame);
|
|
editFrame.InflateRect(1, 1);
|
|
dc.Draw3dRect(editFrame, SE_DARK_BORDER, RGB(4, 6, 10));
|
|
}
|
|
}
|
|
|
|
HBRUSH DialogScriptEditor::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor) {
|
|
if (pDC) {
|
|
pDC->SetBkMode(TRANSPARENT);
|
|
pDC->SetTextColor(SE_DARK_TEXT);
|
|
}
|
|
|
|
if (nCtlColor == CTLCOLOR_LISTBOX) {
|
|
if (pDC) {
|
|
pDC->SetBkColor(SE_DARK_EDIT);
|
|
pDC->SetTextColor(SE_DARK_TEXT);
|
|
}
|
|
return (HBRUSH)m_editBrush.GetSafeHandle();
|
|
}
|
|
|
|
if (nCtlColor == CTLCOLOR_STATIC) {
|
|
return (HBRUSH)m_panelBrush.GetSafeHandle();
|
|
}
|
|
|
|
return (HBRUSH)m_backBrush.GetSafeHandle();
|
|
}
|
|
|
|
void DialogScriptEditor::OnDrawItem(int nIDCtl, LPDRAWITEMSTRUCT dis) {
|
|
if (nIDCtl == IDC_SCRIPTEDITOR_INTELLISENSE_LIST && dis) {
|
|
HDC hDC = dis->hDC;
|
|
RECT rc = dis->rcItem;
|
|
bool selected = (dis->itemState & ODS_SELECTED) != 0;
|
|
ScriptEditorFillRect(hDC, rc, selected ? SE_DARK_SELECTION : SE_DARK_PANEL_2);
|
|
if (dis->itemID != (UINT)-1) {
|
|
CString text;
|
|
m_intellisenseList.GetText(dis->itemID, text);
|
|
HFONT font = (HFONT)m_uiFont.GetSafeHandle();
|
|
HFONT oldFont = font ? (HFONT)::SelectObject(hDC, font) : NULL;
|
|
::SetBkMode(hDC, TRANSPARENT);
|
|
::SetTextColor(hDC, selected ? SE_DARK_SELECTION_TEXT : SE_DARK_TEXT);
|
|
rc.left += 8;
|
|
rc.right -= 4;
|
|
::DrawTextA(hDC, text, -1, &rc, DT_LEFT | DT_VCENTER | DT_SINGLELINE | DT_END_ELLIPSIS);
|
|
if (oldFont) {
|
|
::SelectObject(hDC, oldFont);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
CWnd::OnDrawItem(nIDCtl, dis);
|
|
}
|
|
|
|
void DialogScriptEditor::OnMeasureItem(int nIDCtl, LPMEASUREITEMSTRUCT mis) {
|
|
if (nIDCtl == IDC_SCRIPTEDITOR_INTELLISENSE_LIST && mis) {
|
|
mis->itemHeight = 20;
|
|
return;
|
|
}
|
|
CWnd::OnMeasureItem(nIDCtl, mis);
|
|
}
|
|
|
|
BOOL DialogScriptEditor::OnToolTipNotify(UINT id, NMHDR* pNMHDR, LRESULT* pResult) {
|
|
return DefaultOnToolTipNotify(toolTips, id, pNMHDR, pResult);
|
|
}
|
|
|
|
void DialogScriptEditor::OnFileNew() {
|
|
NewFile();
|
|
}
|
|
|
|
void DialogScriptEditor::OnFileOpen() {
|
|
OpenFileFromDialog();
|
|
}
|
|
|
|
void DialogScriptEditor::OnFileSaveAs() {
|
|
SaveFileAsDialog();
|
|
}
|
|
|
|
void DialogScriptEditor::OnEditGoToLine() {
|
|
if (!scriptEdit || !scriptEdit->GetSafeHwnd()) {
|
|
return;
|
|
}
|
|
|
|
DialogGoToLine goToLineDlg;
|
|
goToLineDlg.SetRange(1, scriptEdit->GetLineCount());
|
|
if (goToLineDlg.DoModal() != IDOK) {
|
|
return;
|
|
}
|
|
scriptEdit->GoToLine(goToLineDlg.GetLine() - 1);
|
|
FocusEditor();
|
|
UpdateStatusBar();
|
|
}
|
|
|
|
void DialogScriptEditor::OnEditFind() {
|
|
CString selText = scriptEdit ? scriptEdit->GetSelText() : "";
|
|
if (selText.GetLength()) {
|
|
findStr = selText;
|
|
}
|
|
|
|
if (!findDlg) {
|
|
findDlg = new CFindReplaceDialog();
|
|
findDlg->Create(TRUE, findStr, "", FR_DOWN, this);
|
|
}
|
|
}
|
|
|
|
void DialogScriptEditor::OnEditFindNext() {
|
|
if (findStr.GetLength() == 0) {
|
|
OnEditFind();
|
|
return;
|
|
}
|
|
|
|
if (scriptEdit && scriptEdit->FindNext(findStr, matchCase, matchWholeWords, searchForward)) {
|
|
FocusEditor();
|
|
UpdateStatusBar();
|
|
}
|
|
else {
|
|
AfxMessageBox("The specified text was not found.", MB_OK | MB_ICONINFORMATION, 0);
|
|
}
|
|
}
|
|
|
|
void DialogScriptEditor::OnEditReplace() {
|
|
CString selText = scriptEdit ? scriptEdit->GetSelText() : "";
|
|
if (selText.GetLength()) {
|
|
findStr = selText;
|
|
}
|
|
|
|
if (!findDlg) {
|
|
findDlg = new CFindReplaceDialog();
|
|
findDlg->Create(FALSE, findStr, "", FR_DOWN, this);
|
|
}
|
|
}
|
|
|
|
void DialogScriptEditor::OnEditShowIntelliSense() {
|
|
ShowIntelliSense(true);
|
|
}
|
|
|
|
LRESULT DialogScriptEditor::OnFindDialogMessage(WPARAM wParam, LPARAM lParam) {
|
|
if (findDlg == NULL) {
|
|
return 0;
|
|
}
|
|
|
|
if (findDlg->IsTerminating()) {
|
|
findDlg = NULL;
|
|
return 0;
|
|
}
|
|
|
|
if (findDlg->FindNext()) {
|
|
findStr = findDlg->GetFindString();
|
|
matchCase = findDlg->MatchCase() != FALSE;
|
|
matchWholeWords = findDlg->MatchWholeWord() != FALSE;
|
|
searchForward = findDlg->SearchDown() != FALSE;
|
|
OnEditFindNext();
|
|
}
|
|
|
|
if (findDlg->ReplaceCurrent()) {
|
|
long selStart, selEnd;
|
|
replaceStr = findDlg->GetReplaceString();
|
|
|
|
scriptEdit->GetSel(selStart, selEnd);
|
|
if (selEnd > selStart) {
|
|
scriptEdit->ReplaceSel(replaceStr, TRUE);
|
|
SetDirty(true);
|
|
}
|
|
}
|
|
|
|
if (findDlg->ReplaceAll()) {
|
|
replaceStr = findDlg->GetReplaceString();
|
|
findStr = findDlg->GetFindString();
|
|
matchCase = findDlg->MatchCase() != FALSE;
|
|
matchWholeWords = findDlg->MatchWholeWord() != FALSE;
|
|
|
|
int numReplaces = scriptEdit ? scriptEdit->ReplaceAll(findStr, replaceStr, matchCase, matchWholeWords) : 0;
|
|
if (numReplaces == 0) {
|
|
AfxMessageBox("The specified text was not found.", MB_OK | MB_ICONINFORMATION, 0);
|
|
}
|
|
else {
|
|
SetDirty(true);
|
|
AfxMessageBox(va("Replaced %d occurrences.", numReplaces), MB_OK | MB_ICONINFORMATION, 0);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void DialogScriptEditor::OnEnChangeEdit(NMHDR* pNMHDR, LRESULT* pResult) {
|
|
if (!internalChange) {
|
|
SetDirty(true);
|
|
UpdateStatusBar();
|
|
}
|
|
if (pResult) {
|
|
*pResult = 0;
|
|
}
|
|
}
|
|
|
|
void DialogScriptEditor::OnEditorSelectionChanged(NMHDR* pNMHDR, LRESULT* pResult) {
|
|
if (m_signatureHelp.GetSafeHwnd() && m_signatureHelp.IsWindowVisible() && !IsFunctionArgumentContext()) {
|
|
HideFunctionParameterHint();
|
|
}
|
|
UpdateStatusBar();
|
|
if (pResult) {
|
|
*pResult = 0;
|
|
}
|
|
}
|
|
|
|
LRESULT DialogScriptEditor::OnDeferredIntelliSense(WPARAM wParam, LPARAM lParam) {
|
|
if (wParam == 2) {
|
|
HideIntelliSense();
|
|
HideFunctionParameterHint();
|
|
return 0;
|
|
}
|
|
|
|
if (wParam == 3) {
|
|
HideIntelliSense();
|
|
ShowFunctionParameterHint();
|
|
return 0;
|
|
}
|
|
|
|
if (wParam == 4) {
|
|
HideFunctionParameterHint();
|
|
return 0;
|
|
}
|
|
|
|
ShowIntelliSense(false);
|
|
if (IsFunctionArgumentContext()) {
|
|
ShowFunctionParameterHint();
|
|
}
|
|
else {
|
|
HideFunctionParameterHint();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
LRESULT DialogScriptEditor::OnIntelliSenseKey(WPARAM wParam, LPARAM lParam) {
|
|
MSG msg;
|
|
memset(&msg, 0, sizeof(msg));
|
|
msg.hwnd = scriptEdit ? scriptEdit->GetSafeHwnd() : GetSafeHwnd();
|
|
msg.message = WM_KEYDOWN;
|
|
msg.wParam = wParam;
|
|
msg.lParam = lParam;
|
|
return HandleIntelliSenseKey(&msg) ? 1 : 0;
|
|
}
|
|
|
|
bool DialogScriptEditor::HandleIntelliSenseKey(MSG* msg) {
|
|
if (!msg || msg->message != WM_KEYDOWN) {
|
|
return false;
|
|
}
|
|
|
|
if (msg->wParam == VK_SPACE && (::GetKeyState(VK_CONTROL) & 0x8000)) {
|
|
ShowIntelliSense(true);
|
|
return true;
|
|
}
|
|
|
|
if (!m_intellisenseList.GetSafeHwnd() || !m_intellisenseList.IsWindowVisible()) {
|
|
return false;
|
|
}
|
|
|
|
int count = m_intellisenseList.GetCount();
|
|
int sel = m_intellisenseList.GetCurSel();
|
|
if (sel == LB_ERR) {
|
|
sel = 0;
|
|
}
|
|
|
|
switch (msg->wParam) {
|
|
case VK_ESCAPE:
|
|
HideIntelliSense();
|
|
HideFunctionParameterHint();
|
|
return true;
|
|
case VK_RETURN:
|
|
case VK_TAB:
|
|
CompleteIntelliSense();
|
|
return true;
|
|
case VK_UP:
|
|
if (count > 0) {
|
|
sel = max(0, sel - 1);
|
|
m_intellisenseList.SetCurSel(sel);
|
|
OnIntelliSenseSelChange();
|
|
}
|
|
return true;
|
|
case VK_DOWN:
|
|
if (count > 0) {
|
|
sel = min(count - 1, sel + 1);
|
|
m_intellisenseList.SetCurSel(sel);
|
|
OnIntelliSenseSelChange();
|
|
}
|
|
return true;
|
|
case VK_LEFT:
|
|
case VK_RIGHT:
|
|
case VK_HOME:
|
|
case VK_END:
|
|
HideIntelliSense();
|
|
return false;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void DialogScriptEditor::ShowIntelliSense(bool forced) {
|
|
if (!m_intellisenseList.GetSafeHwnd() || !scriptEdit) {
|
|
return;
|
|
}
|
|
|
|
EnsureIntelliSenseCore();
|
|
StartIntelliSenseBackgroundScan(false);
|
|
UpdateLiveCompletions();
|
|
|
|
long wordStart = 0;
|
|
long wordEnd = 0;
|
|
CString prefix = GetCurrentWord(&wordStart, &wordEnd);
|
|
if (!forced && prefix.GetLength() < 2 && !IsMemberCompletionContext(wordStart)) {
|
|
HideIntelliSense();
|
|
return;
|
|
}
|
|
|
|
PopulateIntelliSense(prefix, forced);
|
|
|
|
if (m_intellisenseList.GetCount() <= 0) {
|
|
HideIntelliSense();
|
|
if (forced) {
|
|
m_statusLine.SetWindowText("No IntelliSense matches.");
|
|
}
|
|
return;
|
|
}
|
|
|
|
m_intellisenseList.SetCurSel(0);
|
|
PositionIntelliSenseWindow();
|
|
m_intellisenseList.ShowWindow(SW_SHOWNA);
|
|
m_intellisenseList.Invalidate(FALSE);
|
|
FocusEditor();
|
|
OnIntelliSenseSelChange();
|
|
}
|
|
|
|
void DialogScriptEditor::HideIntelliSense(void) {
|
|
if (m_intellisenseList.GetSafeHwnd() && m_intellisenseList.IsWindowVisible()) {
|
|
m_intellisenseList.ShowWindow(SW_HIDE);
|
|
UpdateStatusBar();
|
|
}
|
|
}
|
|
|
|
void DialogScriptEditor::PopulateIntelliSense(const CString& prefix, bool forced) {
|
|
m_intellisenseList.ResetContent();
|
|
|
|
CString needle = prefix;
|
|
needle.MakeLower();
|
|
const int maxItems = forced ? 256 : 96;
|
|
int added = 0;
|
|
long memberWordStart = 0;
|
|
long memberWordEnd = 0;
|
|
GetCurrentWord(&memberWordStart, &memberWordEnd);
|
|
const bool memberContext = IsMemberCompletionContext(memberWordStart);
|
|
|
|
// First pass: strong prefix matches, with high-weight entries naturally coming
|
|
// first because the database is built as keywords/events/functions/symbols.
|
|
for (int pass = 0; pass < 2 && added < maxItems; pass++) {
|
|
for (int i = 0; i < scriptCompletions.Num() && added < maxItems; i++) {
|
|
if (memberContext && scriptCompletions[i].kind.Icmp("event") != 0) {
|
|
continue;
|
|
}
|
|
|
|
CString name = scriptCompletions[i].name.c_str();
|
|
CString lower = name;
|
|
lower.MakeLower();
|
|
|
|
bool match = false;
|
|
if (forced && needle.GetLength() == 0) {
|
|
match = true;
|
|
}
|
|
else if (pass == 0) {
|
|
match = StartsWithNoCase(name, prefix);
|
|
}
|
|
else if (forced && needle.GetLength() >= 2) {
|
|
match = lower.Find(needle) >= 0;
|
|
}
|
|
|
|
if (!match) {
|
|
continue;
|
|
}
|
|
|
|
CString display;
|
|
display.Format("%-32s %s", scriptCompletions[i].name.c_str(), scriptCompletions[i].kind.c_str());
|
|
if (m_intellisenseList.FindStringExact(-1, display) != LB_ERR) {
|
|
continue;
|
|
}
|
|
|
|
int item = m_intellisenseList.AddString(display);
|
|
if (item != LB_ERR) {
|
|
m_intellisenseList.SetItemData(item, (DWORD_PTR)i);
|
|
added++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool DialogScriptEditor::IsMemberCompletionContext(long wordStart) const {
|
|
if (!scriptEdit) {
|
|
return false;
|
|
}
|
|
idStr text;
|
|
scriptEdit->GetText(text);
|
|
int i = (int)wordStart - 1;
|
|
while (i >= 0 && (text[i] == ' ' || text[i] == '\t')) {
|
|
i--;
|
|
}
|
|
if (i >= 0 && text[i] == '.') {
|
|
return true;
|
|
}
|
|
if (i >= 1 && text[i] == ':' && text[i - 1] == ':') {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool DialogScriptEditor::IsFunctionArgumentContext(void) const {
|
|
CString functionName;
|
|
CString signature;
|
|
int argumentIndex = 0;
|
|
return GetFunctionSignatureBeforeCaret(functionName, signature, argumentIndex);
|
|
}
|
|
|
|
bool DialogScriptEditor::GetFunctionSignatureBeforeCaret(CString& functionName, CString& signature, int& argumentIndex) const {
|
|
functionName.Empty();
|
|
signature.Empty();
|
|
argumentIndex = 0;
|
|
|
|
if (!scriptEdit) {
|
|
return false;
|
|
}
|
|
|
|
long selStart = 0;
|
|
long selEnd = 0;
|
|
scriptEdit->GetSel(selStart, selEnd);
|
|
if (selStart != selEnd) {
|
|
return false;
|
|
}
|
|
|
|
idStr raw;
|
|
scriptEdit->GetText(raw);
|
|
CString text = raw.c_str();
|
|
int caret = max(0, min((int)selEnd, text.GetLength()));
|
|
|
|
int depth = 0;
|
|
int openParen = -1;
|
|
for (int i = caret - 1; i >= 0; i--) {
|
|
char ch = text[i];
|
|
if (ch == ')') {
|
|
depth++;
|
|
}
|
|
else if (ch == '(') {
|
|
if (depth == 0) {
|
|
openParen = i;
|
|
break;
|
|
}
|
|
depth--;
|
|
}
|
|
else if (depth == 0 && (ch == ';' || ch == '{' || ch == '}')) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
if (openParen < 0) {
|
|
return false;
|
|
}
|
|
|
|
functionName = ScriptEditorPreviousIdentifier(text, openParen);
|
|
if (functionName.IsEmpty() || ScriptEditorIsKeywordName(functionName)) {
|
|
return false;
|
|
}
|
|
|
|
int nested = 0;
|
|
for (int i = openParen + 1; i < caret; i++) {
|
|
char ch = text[i];
|
|
if (ch == '(') {
|
|
nested++;
|
|
}
|
|
else if (ch == ')' && nested > 0) {
|
|
nested--;
|
|
}
|
|
else if (ch == ',' && nested == 0) {
|
|
argumentIndex++;
|
|
}
|
|
}
|
|
|
|
int best = -1;
|
|
for (int i = 0; i < scriptCompletions.Num(); i++) {
|
|
if (scriptCompletions[i].name.Icmp(functionName) != 0) {
|
|
continue;
|
|
}
|
|
if (scriptCompletions[i].kind.Icmp("event") == 0 || scriptCompletions[i].kind.Icmp("function") == 0) {
|
|
best = i;
|
|
if (scriptCompletions[i].kind.Icmp("event") == 0) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (best >= 0) {
|
|
signature = scriptCompletions[best].help.c_str();
|
|
if (signature.IsEmpty()) {
|
|
signature.Format("%s( ... )", functionName);
|
|
}
|
|
}
|
|
else {
|
|
signature.Format("%s( ... )", functionName);
|
|
}
|
|
|
|
signature.Replace("\r\n", " ");
|
|
signature.Replace("\r", " ");
|
|
signature.Replace("\n", " ");
|
|
signature.Replace("\t", " ");
|
|
while (signature.Find(" ") >= 0) {
|
|
signature.Replace(" ", " ");
|
|
}
|
|
|
|
CString argText;
|
|
argText.Format(" arg %d", argumentIndex + 1);
|
|
signature += argText;
|
|
return true;
|
|
}
|
|
|
|
void DialogScriptEditor::ShowFunctionParameterHint(void) {
|
|
EnsureIntelliSenseCore();
|
|
UpdateLiveCompletions();
|
|
|
|
CString functionName;
|
|
CString signature;
|
|
int argumentIndex = 0;
|
|
if (!GetFunctionSignatureBeforeCaret(functionName, signature, argumentIndex)) {
|
|
HideFunctionParameterHint();
|
|
return;
|
|
}
|
|
|
|
if (!m_signatureHelp.GetSafeHwnd()) {
|
|
return;
|
|
}
|
|
|
|
m_signatureHelp.SetWindowText(signature);
|
|
PositionParameterHint();
|
|
m_signatureHelp.ShowWindow(SW_SHOWNA);
|
|
m_signatureHelp.SetWindowPos(&wndTop, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
|
|
if (m_statusLine.GetSafeHwnd()) {
|
|
m_statusLine.SetWindowText(signature);
|
|
}
|
|
}
|
|
|
|
void DialogScriptEditor::HideFunctionParameterHint(void) {
|
|
if (m_signatureHelp.GetSafeHwnd() && m_signatureHelp.IsWindowVisible()) {
|
|
m_signatureHelp.ShowWindow(SW_HIDE);
|
|
UpdateStatusBar();
|
|
}
|
|
}
|
|
|
|
void DialogScriptEditor::PositionParameterHint(void) {
|
|
if (!m_signatureHelp.GetSafeHwnd() || !scriptEdit || !scriptEdit->GetSafeHwnd()) {
|
|
return;
|
|
}
|
|
|
|
CPoint caret = scriptEdit->GetCaretPoint();
|
|
scriptEdit->ClientToScreen(&caret);
|
|
ScreenToClient(&caret);
|
|
|
|
CRect client;
|
|
GetClientRect(client);
|
|
|
|
const int width = 560;
|
|
const int height = 28;
|
|
CRect rc(caret.x, caret.y + 22, caret.x + width, caret.y + 22 + height);
|
|
if (m_intellisenseList.GetSafeHwnd() && m_intellisenseList.IsWindowVisible()) {
|
|
rc.OffsetRect(0, 206);
|
|
}
|
|
if (rc.right > client.right - 8) {
|
|
rc.OffsetRect((client.right - 8) - rc.right, 0);
|
|
}
|
|
if (rc.bottom > client.bottom - 32) {
|
|
rc.OffsetRect(0, -height - 46);
|
|
}
|
|
if (rc.left < client.left + 8) {
|
|
rc.OffsetRect(client.left + 8 - rc.left, 0);
|
|
}
|
|
if (rc.top < client.top + 8) {
|
|
rc.OffsetRect(0, client.top + 8 - rc.top);
|
|
}
|
|
|
|
m_signatureHelp.MoveWindow(rc, TRUE);
|
|
m_signatureHelp.SetWindowPos(&wndTop, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
|
|
}
|
|
|
|
void DialogScriptEditor::PositionIntelliSenseWindow(void) {
|
|
if (!m_intellisenseList.GetSafeHwnd() || !scriptEdit || !scriptEdit->GetSafeHwnd()) {
|
|
return;
|
|
}
|
|
|
|
CPoint caret = scriptEdit->GetCaretPoint();
|
|
scriptEdit->ClientToScreen(&caret);
|
|
ScreenToClient(&caret);
|
|
|
|
CRect client;
|
|
GetClientRect(client);
|
|
|
|
const int width = 320;
|
|
const int height = 200;
|
|
CRect rc(caret.x, caret.y + 20, caret.x + width, caret.y + 20 + height);
|
|
|
|
if (rc.right > client.right - 8) {
|
|
rc.OffsetRect((client.right - 8) - rc.right, 0);
|
|
}
|
|
if (rc.bottom > client.bottom - 32) {
|
|
rc.OffsetRect(0, -height - 28);
|
|
}
|
|
if (rc.left < client.left + 8) {
|
|
rc.OffsetRect(client.left + 8 - rc.left, 0);
|
|
}
|
|
if (rc.top < client.top + 8) {
|
|
rc.OffsetRect(0, client.top + 8 - rc.top);
|
|
}
|
|
|
|
m_intellisenseList.MoveWindow(rc, TRUE);
|
|
m_intellisenseList.SetWindowPos(&wndTop, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
|
|
}
|
|
|
|
void DialogScriptEditor::CompleteIntelliSense(void) {
|
|
int sel = m_intellisenseList.GetCurSel();
|
|
if (sel == LB_ERR) {
|
|
return;
|
|
}
|
|
|
|
CString completion;
|
|
DWORD_PTR data = m_intellisenseList.GetItemData(sel);
|
|
if (data != (DWORD_PTR)LB_ERR && data < (DWORD_PTR)scriptCompletions.Num()) {
|
|
completion = scriptCompletions[(int)data].insertText.c_str();
|
|
}
|
|
else {
|
|
m_intellisenseList.GetText(sel, completion);
|
|
int space = completion.Find(' ');
|
|
if (space > 0) {
|
|
completion = completion.Left(space);
|
|
}
|
|
}
|
|
|
|
InsertCompletion(completion);
|
|
HideIntelliSense();
|
|
FocusEditor();
|
|
}
|
|
|
|
void DialogScriptEditor::OnIntelliSenseDblClick() {
|
|
CompleteIntelliSense();
|
|
}
|
|
|
|
void DialogScriptEditor::OnIntelliSenseSelChange() {
|
|
int sel = m_intellisenseList.GetCurSel();
|
|
if (sel == LB_ERR) {
|
|
return;
|
|
}
|
|
|
|
DWORD_PTR data = m_intellisenseList.GetItemData(sel);
|
|
if (data != (DWORD_PTR)LB_ERR && data < (DWORD_PTR)scriptCompletions.Num()) {
|
|
const scriptCompletionInfo_t& completion = scriptCompletions[(int)data];
|
|
CString status;
|
|
if (completion.help.Length() > 0) {
|
|
status.Format("%s [%s] %s", completion.name.c_str(), completion.kind.c_str(), completion.help.c_str());
|
|
}
|
|
else if (completion.source.Length() > 0) {
|
|
status.Format("%s [%s] %s", completion.name.c_str(), completion.kind.c_str(), completion.source.c_str());
|
|
}
|
|
else {
|
|
status.Format("%s [%s]", completion.name.c_str(), completion.kind.c_str());
|
|
}
|
|
m_statusLine.SetWindowText(status);
|
|
return;
|
|
}
|
|
|
|
CString name;
|
|
m_intellisenseList.GetText(sel, name);
|
|
m_statusLine.SetWindowText(name);
|
|
}
|
|
|
|
CString DialogScriptEditor::GetCurrentWord(long* wordStart, long* wordEnd) const {
|
|
if (!scriptEdit) {
|
|
if (wordStart) {
|
|
*wordStart = 0;
|
|
}
|
|
if (wordEnd) {
|
|
*wordEnd = 0;
|
|
}
|
|
return "";
|
|
}
|
|
return scriptEdit->GetCurrentWord(wordStart, wordEnd);
|
|
}
|
|
|
|
bool DialogScriptEditor::IsIdentifierChar(int ch) const {
|
|
return ScriptEditorIsIdentifierChar(ch);
|
|
}
|
|
|
|
bool DialogScriptEditor::StartsWithNoCase(const CString& text, const CString& prefix) const {
|
|
if (prefix.GetLength() == 0) {
|
|
return true;
|
|
}
|
|
if (text.GetLength() < prefix.GetLength()) {
|
|
return false;
|
|
}
|
|
CString left = text.Left(prefix.GetLength());
|
|
CString a = left;
|
|
CString b = prefix;
|
|
a.MakeLower();
|
|
b.MakeLower();
|
|
return a == b;
|
|
}
|
|
|
|
void DialogScriptEditor::InsertCompletion(const CString& completion) {
|
|
if (!scriptEdit) {
|
|
return;
|
|
}
|
|
|
|
long wordStart = 0;
|
|
long wordEnd = 0;
|
|
GetCurrentWord(&wordStart, &wordEnd);
|
|
|
|
long selStart = 0;
|
|
long selEnd = 0;
|
|
scriptEdit->GetSel(selStart, selEnd);
|
|
if (selStart != selEnd) {
|
|
wordStart = min(selStart, selEnd);
|
|
wordEnd = max(selStart, selEnd);
|
|
}
|
|
|
|
scriptEdit->SetSel(wordStart, wordEnd);
|
|
scriptEdit->ReplaceSel(completion, TRUE);
|
|
SetDirty(true);
|
|
UpdateStatusBar();
|
|
}
|
|
|
|
void DialogScriptEditor::OnBnClickedOk() {
|
|
SaveFile();
|
|
FocusEditor();
|
|
}
|
|
|
|
void DialogScriptEditor::OnBnClickedCancel() {
|
|
if (fileName.Length() == 0) {
|
|
return;
|
|
}
|
|
|
|
if (isDirty) {
|
|
if (MessageBox("Discard changes and reload the last saved version?", "Revert", MB_YESNO | MB_ICONQUESTION) != IDYES) {
|
|
FocusEditor();
|
|
return;
|
|
}
|
|
}
|
|
ReloadFile();
|
|
FocusEditor();
|
|
}
|
|
|
|
void ScriptEditorInit(const idDict* spawnArgs) {
|
|
if (renderSystem->IsFullScreen()) {
|
|
common->Printf("Cannot run the script editor in fullscreen mode.\n"
|
|
"Set r_fullscreen to 0 and vid_restart.\n");
|
|
return;
|
|
}
|
|
|
|
InitAfx();
|
|
|
|
DialogScriptEditor* editor = DialogScriptEditor::GetPrimaryEditor();
|
|
if (editor && editor->GetSafeHwnd()) {
|
|
idKeyInput::ClearStates();
|
|
ScriptEditorActivateDockParent(editor);
|
|
editor->ShowWindow(SW_SHOW);
|
|
editor->SetActive(TRUE);
|
|
editor->FocusEditor();
|
|
return;
|
|
}
|
|
|
|
if (g_StandaloneScriptEditor == NULL) {
|
|
g_StandaloneScriptEditor = new DialogScriptEditor();
|
|
}
|
|
|
|
if (g_StandaloneScriptEditor->GetSafeHwnd() == NULL) {
|
|
CRect rct(80, 80, 1180, 820);
|
|
g_StandaloneScriptEditor->Create(rct, NULL, IDD_DIALOG_SCRIPTEDITOR);
|
|
}
|
|
|
|
idKeyInput::ClearStates();
|
|
g_StandaloneScriptEditor->ShowWindow(SW_SHOW);
|
|
g_StandaloneScriptEditor->SetActive(TRUE);
|
|
g_StandaloneScriptEditor->FocusEditor();
|
|
|
|
if (spawnArgs) {
|
|
const char* scriptFile = spawnArgs->GetString("file");
|
|
if (scriptFile && scriptFile[0]) {
|
|
g_StandaloneScriptEditor->OpenFile(scriptFile);
|
|
}
|
|
}
|
|
}
|
|
|
|
void ScriptEditorRun(void) {
|
|
#if _MSC_VER >= 1300
|
|
MSG* msg = AfxGetCurrentMessage();
|
|
#else
|
|
MSG* msg = &m_msgCur;
|
|
#endif
|
|
|
|
while (::PeekMessage(msg, NULL, NULL, NULL, PM_NOREMOVE)) {
|
|
if (!AfxGetApp()->PumpMessage()) {
|
|
}
|
|
}
|
|
}
|
|
|
|
void ScriptEditorShutdown(void) {
|
|
if (g_StandaloneScriptEditor) {
|
|
delete g_StandaloneScriptEditor;
|
|
g_StandaloneScriptEditor = NULL;
|
|
}
|
|
scriptEvents.Clear();
|
|
scriptCompletions.Clear();
|
|
scriptVirtualFiles.Clear();
|
|
scriptCoreBuilt = false;
|
|
scriptDatabaseBuilt = false;
|
|
scriptVirtualFileListBuilt = false;
|
|
}
|