Return handles of notepad, editor1, editor2 bruderstein#256

chcg · chcg · commit 2c178d8f4257 · 2022-11-21T22:36:50.000+01:00
- provide scintilla HWND of console dialog via console.getScintillaHwnd()
- some whitespace changes
diff --git a/PythonScript/src/PythonConsole.cpp b/PythonScript/src/PythonConsole.cpp
@@ -28,9 +28,9 @@ PythonConsole::PythonConsole(HWND hNotepad) :
 	m_nppData(new NppData)
 {
 }
-    /*
+	/*
 //lint -e1554  Direct pointer copy of member 'name' within copy constructor: 'PythonConsole::PythonConsole(const PythonConsole &)')
-// We indeed copy pointers, and it's okay. These are not allocated within the 
+// We indeed copy pointers, and it's okay. These are not allocated within the
 // scope of this class but rather passed in and copied anyway.
 PythonConsole::PythonConsole(const PythonConsole& other) :
 	PyProducerConsumer<std::string>(other),
@@ -56,7 +56,6 @@ PythonConsole::~PythonConsole()
 	{
 		delete mp_consoleDlg;
 		delete m_nppData;
-		
 	}
 	catch (...)
 	{
@@ -92,27 +91,27 @@ void PythonConsole::initPython(PythonHandler *pythonHandler)
 	try
 	{
 		mp_mainThreadState = pythonHandler->getMainThreadState();
-		
-        GILLock gilLock;
+
+		GILLock gilLock;
 
 		boost::python::object main_module(boost::python::handle<>(boost::python::borrowed(PyImport_AddModule("__main__"))));
 		boost::python::object main_namespace = main_module.attr("__dict__");
-		
+
 		// import code
 		boost::python::object code = boost::python::import("code");
 		main_namespace["code"] = code;
 
 		// import __main__
 		main_namespace["__main__"] = main_namespace;
-		
+
 		// get ref to code.InteractiveConsole().push()
 		m_console = eval("code.InteractiveConsole(__main__)", main_namespace, main_namespace);
 		m_pushFunc = m_console.attr("push");
 
 		m_sys = main_namespace["sys"];
-	
-		
-	} 
+
+
+	}
 	catch(...)
 	{
 		PyErr_Print();
@@ -146,7 +145,7 @@ void PythonConsole::showDialog()
 	assert(mp_consoleDlg);
 	if (mp_consoleDlg)
 	{
-        GILRelease release;
+		GILRelease release;
 		mp_consoleDlg->doDialog();
 	}
 }
@@ -156,7 +155,7 @@ void PythonConsole::hideDialog()
 	assert(mp_consoleDlg);
 	if (mp_consoleDlg)
 	{
-        GILRelease release;
+		GILRelease release;
 		mp_consoleDlg->hide();
 	}
 }
@@ -166,8 +165,8 @@ void PythonConsole::message(const char *msg)
 	assert(mp_consoleDlg);
 	if (mp_consoleDlg)
 	{
-        GILRelease release;
-		mp_consoleDlg->writeCmdText(strlen(msg), msg);	
+		GILRelease release;
+		mp_consoleDlg->writeCmdText(strlen(msg), msg);
 	}
 }
 
@@ -176,7 +175,7 @@ void PythonConsole::clear()
 	assert(mp_consoleDlg);
 	if (mp_consoleDlg)
 	{
-        GILRelease release;
+		GILRelease release;
 		mp_consoleDlg->clearText();
 	}
 }
@@ -191,12 +190,12 @@ void PythonConsole::writeText(boost::python::object text)
 	assert(mp_consoleDlg);
 	if (mp_consoleDlg)
 	{
-        if (PyUnicode_Check(text.ptr()))
+		if (PyUnicode_Check(text.ptr()))
 		{
 
 
-            std::string textToWrite((const char *)boost::python::extract<const char *>(text.attr("__str__")()));
-            GILRelease release;
+			std::string textToWrite((const char *)boost::python::extract<const char *>(text.attr("__str__")()));
+			GILRelease release;
 			if (m_runStatementExecuted)
 			{
 				mp_consoleDlg->writeColoredText(textToWrite.size(), textToWrite.c_str());
@@ -208,8 +207,8 @@ void PythonConsole::writeText(boost::python::object text)
 		}
 		else
 		{
-            std::string textToWrite((const char *)boost::python::extract<const char *>(text.attr("__str__")()), _len(text));
-            GILRelease release;
+			std::string textToWrite((const char *)boost::python::extract<const char *>(text.attr("__str__")()), _len(text));
+			GILRelease release;
 			if (m_runStatementExecuted)
 			{
 				mp_consoleDlg->writeColoredText(textToWrite.size(), textToWrite.c_str());
@@ -231,15 +230,15 @@ void PythonConsole::writeError(boost::python::object text)
 		{
 
 
-            std::string textToWrite((const char *)boost::python::extract<const char *>(text.attr("__str__")()));
-            GILRelease release;
-            mp_consoleDlg->writeError(textToWrite.size(), textToWrite.c_str());
+			std::string textToWrite((const char *)boost::python::extract<const char *>(text.attr("__str__")()));
+			GILRelease release;
+			mp_consoleDlg->writeError(textToWrite.size(), textToWrite.c_str());
 		}
 		else
 		{
-            std::string textToWrite((const char *)boost::python::extract<const char *>(text.attr("__str__")())); 
-            GILRelease release;
-		    mp_consoleDlg->writeError(textToWrite.size(),textToWrite.c_str()); 
+			std::string textToWrite((const char *)boost::python::extract<const char *>(text.attr("__str__")()));
+			GILRelease release;
+		    mp_consoleDlg->writeError(textToWrite.size(),textToWrite.c_str());
 		}
 	}
 }
@@ -248,7 +247,7 @@ void PythonConsole::stopStatement()
 {
 	DWORD threadID;
 	CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)PythonConsole::stopStatementWorker, this, 0, &threadID);
-	
+
 }
 
 DWORD PythonConsole::runCommand(boost::python::str text, boost::python::object pyStdout, boost::python::object pyStderr)
@@ -267,9 +266,9 @@ void PythonConsole::runStatement(const char *statement)
 		mp_consoleDlg->runEnabled(false);
 	}
 
-	// Console statements executed whilst a script is in progress MUST run on a separate 
+	// Console statements executed whilst a script is in progress MUST run on a separate
 	// thread.  Otherwise, we wait for the GIL, no problem, except that that blocks the UI thread
-	// so if the script happens to be sending a message to scintilla (likely), then 
+	// so if the script happens to be sending a message to scintilla (likely), then
 	// it will deadlock.
 	// PyProducerConsumer used here to keep one thread running the actual statements
 
@@ -326,10 +325,10 @@ void PythonConsole::consume(std::shared_ptr<std::string> statement)
 
 void PythonConsole::stopStatementWorker(PythonConsole *console)
 {
-    GILLock gilLock;
-	
+	GILLock gilLock;
+
 	PyThreadState_SetAsyncExc((long)console->getConsumerThreadID(), PyExc_KeyboardInterrupt);
-	
+
 }
 
 void export_console()
@@ -345,6 +344,7 @@ void export_console()
 		.def("run", &PythonConsole::runCommand, "Runs a command on the console")
 		.def("run", &PythonConsole::runCommandNoStderr, "Runs a command on the console")
 		.def("run", &PythonConsole::runCommandNoStdout, "Runs a command on the console")
+		.def("getScintillaHwnd", &PythonConsole::getScintillaHwndPython, "Provide HWnd for scintilla of console")
 		.add_static_property("encoding", &PythonConsole::getEncoding)
 		.add_property("editor", &PythonConsole::getScintillaWrapper);
 	//lint +e1793
diff --git a/PythonScript/src/PythonConsole.h b/PythonScript/src/PythonConsole.h
@@ -1,7 +1,7 @@
 #ifndef _PYTHONCONSOLE_H
 #define _PYTHONCONSOLE_H
 
-#ifndef _CONSOLEINTERFACE_H 
+#ifndef _CONSOLEINTERFACE_H
 #include "ConsoleInterface.h"
 #endif
 
@@ -24,7 +24,7 @@ class PythonConsole : public PyProducerConsumer<std::string>, public ConsoleInte
 public:
 	explicit PythonConsole(HWND hNotepad);
 	~PythonConsole();
-	
+
 	void init(HINSTANCE hInst, NppData& nppData);
 	void initPython(PythonHandler *pythonHandler);
 
@@ -42,37 +42,38 @@ class PythonConsole : public PyProducerConsumer<std::string>, public ConsoleInte
 	void runStatement(const char *statement);
 	void stopStatement();
 	void openFile(const char *filename, idx_t lineNumber);
-	
+
 	/* ConsoleInterface end */
 
 
 	static void stopStatementWorker(PythonConsole *console);
-	
+
 	DWORD runCommand(boost::python::str text, boost::python::object pyStdout, boost::python::object pyStderr);
 	DWORD runCommandNoStderr(boost::python::str text, boost::python::object pyStdout)
-	{ 
+	{
 		boost::python::object sys_module( (boost::python::handle<>(PyImport_ImportModule("sys"))) );
-		boost::python::object sys_namespace = sys_module.attr("__dict__");	
-		return runCommand(text, pyStdout, sys_namespace["stderr"]); 
-    }
+		boost::python::object sys_namespace = sys_module.attr("__dict__");
+		return runCommand(text, pyStdout, sys_namespace["stderr"]);
+	}
 
 	DWORD runCommandNoStdout(boost::python::str text)
-	{ 
+	{
 		boost::python::object sys_module( (boost::python::handle<>(PyImport_ImportModule("sys"))) );
-		boost::python::object sys_namespace = sys_module.attr("__dict__");	
+		boost::python::object sys_namespace = sys_module.attr("__dict__");
 		boost::python::object npp_module( (boost::python::handle<>(PyImport_ImportModule("Npp"))) );
-		boost::python::object npp_namespace = npp_module.attr("__dict__");	
-		return runCommand(text, npp_namespace["console"], sys_namespace["stderr"]); 
-    }
+		boost::python::object npp_namespace = npp_module.attr("__dict__");
+		return runCommand(text, npp_namespace["console"], sys_namespace["stderr"]);
+	}
 
 	HWND getScintillaHwnd();
+	intptr_t getScintillaHwndPython() { return (intptr_t)getScintillaHwnd(); }
 
 	boost::shared_ptr<ScintillaWrapper> getScintillaWrapper() { return mp_scintillaWrapper; }
 
 	boost::shared_ptr<ScintillaWrapper> mp_scintillaWrapper;
 
 	static boost::python::str getEncoding() { return boost::python::str("utf-8"); }
-	
+
 protected:
 	virtual void consume(std::shared_ptr<std::string> statement);
 	virtual void queueComplete();
@@ -83,7 +84,7 @@ class PythonConsole : public PyProducerConsumer<std::string>, public ConsoleInte
 	PythonConsole(const PythonConsole& other);
 
 	ConsoleDialog *mp_consoleDlg;
-	
+
 	boost::python::object m_console;
 	boost::python::object m_pushFunc;
 	boost::python::object m_sys;
diff --git a/PythonScript/src/PythonHandler.h b/PythonScript/src/PythonHandler.h
@@ -89,7 +89,7 @@ class PythonHandler : public PyProducerConsumer<RunScriptArgs>
 
 	// Private methods
 	void initModules();
-    void initSysArgv();
+	void initSysArgv();
 	static void stopScriptWorker(PythonHandler *handler);
 	bool containsExtendedChars(char *s);
 

Original file line number	Diff line number	Diff line change
`@@ -28,9 +28,9 @@ PythonConsole::PythonConsole(HWND hNotepad) :`
`28`	`28`	`m_nppData(new NppData)`
`29`	`29`	`{`
`30`	`30`	`}`
`31`		`- /*`
	`31`	`+ /*`
`32`	`32`	`//lint -e1554 Direct pointer copy of member 'name' within copy constructor: 'PythonConsole::PythonConsole(const PythonConsole &)')`
`33`		`-// We indeed copy pointers, and it's okay. These are not allocated within the`
	`33`	`+// We indeed copy pointers, and it's okay. These are not allocated within the`
`34`	`34`	`// scope of this class but rather passed in and copied anyway.`
`35`	`35`	`PythonConsole::PythonConsole(const PythonConsole& other) :`
`36`	`36`	`PyProducerConsumer<std::string>(other),`
`@@ -56,7 +56,6 @@ PythonConsole::~PythonConsole()`
`56`	`56`	`{`
`57`	`57`	`delete mp_consoleDlg;`
`58`	`58`	`delete m_nppData;`
`59`		`-`
`60`	`59`	`}`
`61`	`60`	`catch (...)`
`62`	`61`	`{`
`@@ -92,27 +91,27 @@ void PythonConsole::initPython(PythonHandler *pythonHandler)`
`92`	`91`	`try`
`93`	`92`	`{`
`94`	`93`	`mp_mainThreadState = pythonHandler->getMainThreadState();`
`95`		`-`
`96`		`- GILLock gilLock;`
	`94`	`+`
	`95`	`+ GILLock gilLock;`
`97`	`96`
`98`	`97`	`boost::python::object main_module(boost::python::handle<>(boost::python::borrowed(PyImport_AddModule("__main__"))));`
`99`	`98`	`boost::python::object main_namespace = main_module.attr("__dict__");`
`100`		`-`
	`99`	`+`
`101`	`100`	`// import code`
`102`	`101`	`boost::python::object code = boost::python::import("code");`
`103`	`102`	`main_namespace["code"] = code;`
`104`	`103`
`105`	`104`	`// import __main__`
`106`	`105`	`main_namespace["__main__"] = main_namespace;`
`107`		`-`
	`106`	`+`
`108`	`107`	`// get ref to code.InteractiveConsole().push()`
`109`	`108`	`m_console = eval("code.InteractiveConsole(__main__)", main_namespace, main_namespace);`
`110`	`109`	`m_pushFunc = m_console.attr("push");`
`111`	`110`
`112`	`111`	`m_sys = main_namespace["sys"];`
`113`		`-`
`114`		`-`
`115`		`- }`
	`112`	`+`
	`113`	`+`
	`114`	`+ }`
`116`	`115`	`catch(...)`
`117`	`116`	`{`
`118`	`117`	`PyErr_Print();`
`@@ -146,7 +145,7 @@ void PythonConsole::showDialog()`
`146`	`145`	`assert(mp_consoleDlg);`
`147`	`146`	`if (mp_consoleDlg)`
`148`	`147`	`{`
`149`		`- GILRelease release;`
	`148`	`+ GILRelease release;`
`150`	`149`	`mp_consoleDlg->doDialog();`
`151`	`150`	`}`
`152`	`151`	`}`
`@@ -156,7 +155,7 @@ void PythonConsole::hideDialog()`
`156`	`155`	`assert(mp_consoleDlg);`
`157`	`156`	`if (mp_consoleDlg)`
`158`	`157`	`{`
`159`		`- GILRelease release;`
	`158`	`+ GILRelease release;`
`160`	`159`	`mp_consoleDlg->hide();`
`161`	`160`	`}`
`162`	`161`	`}`
`@@ -166,8 +165,8 @@ void PythonConsole::message(const char *msg)`
`166`	`165`	`assert(mp_consoleDlg);`
`167`	`166`	`if (mp_consoleDlg)`
`168`	`167`	`{`
`169`		`- GILRelease release;`
`170`		`- mp_consoleDlg->writeCmdText(strlen(msg), msg);`
	`168`	`+ GILRelease release;`
	`169`	`+ mp_consoleDlg->writeCmdText(strlen(msg), msg);`
`171`	`170`	`}`
`172`	`171`	`}`
`173`	`172`
`@@ -176,7 +175,7 @@ void PythonConsole::clear()`
`176`	`175`	`assert(mp_consoleDlg);`
`177`	`176`	`if (mp_consoleDlg)`
`178`	`177`	`{`
`179`		`- GILRelease release;`
	`178`	`+ GILRelease release;`
`180`	`179`	`mp_consoleDlg->clearText();`
`181`	`180`	`}`
`182`	`181`	`}`
`@@ -191,12 +190,12 @@ void PythonConsole::writeText(boost::python::object text)`
`191`	`190`	`assert(mp_consoleDlg);`
`192`	`191`	`if (mp_consoleDlg)`
`193`	`192`	`{`
`194`		`- if (PyUnicode_Check(text.ptr()))`
	`193`	`+ if (PyUnicode_Check(text.ptr()))`
`195`	`194`	`{`
`196`	`195`
`197`	`196`
`198`		`- std::string textToWrite((const char )boost::python::extract<const char >(text.attr("__str__")()));`
`199`		`- GILRelease release;`
	`197`	`+ std::string textToWrite((const char )boost::python::extract<const char >(text.attr("__str__")()));`
	`198`	`+ GILRelease release;`
`200`	`199`	`if (m_runStatementExecuted)`
`201`	`200`	`{`
`202`	`201`	`mp_consoleDlg->writeColoredText(textToWrite.size(), textToWrite.c_str());`
`@@ -208,8 +207,8 @@ void PythonConsole::writeText(boost::python::object text)`
`208`	`207`	`}`
`209`	`208`	`else`
`210`	`209`	`{`
`211`		`- std::string textToWrite((const char )boost::python::extract<const char >(text.attr("__str__")()), _len(text));`
`212`		`- GILRelease release;`
	`210`	`+ std::string textToWrite((const char )boost::python::extract<const char >(text.attr("__str__")()), _len(text));`
	`211`	`+ GILRelease release;`
`213`	`212`	`if (m_runStatementExecuted)`
`214`	`213`	`{`
`215`	`214`	`mp_consoleDlg->writeColoredText(textToWrite.size(), textToWrite.c_str());`
`@@ -231,15 +230,15 @@ void PythonConsole::writeError(boost::python::object text)`
`231`	`230`	`{`
`232`	`231`
`233`	`232`
`234`		`- std::string textToWrite((const char )boost::python::extract<const char >(text.attr("__str__")()));`
`235`		`- GILRelease release;`
`236`		`- mp_consoleDlg->writeError(textToWrite.size(), textToWrite.c_str());`
	`233`	`+ std::string textToWrite((const char )boost::python::extract<const char >(text.attr("__str__")()));`
	`234`	`+ GILRelease release;`
	`235`	`+ mp_consoleDlg->writeError(textToWrite.size(), textToWrite.c_str());`
`237`	`236`	`}`
`238`	`237`	`else`
`239`	`238`	`{`
`240`		`- std::string textToWrite((const char )boost::python::extract<const char >(text.attr("__str__")()));`
`241`		`- GILRelease release;`
`242`		`- mp_consoleDlg->writeError(textToWrite.size(),textToWrite.c_str());`
	`239`	`+ std::string textToWrite((const char )boost::python::extract<const char >(text.attr("__str__")()));`
	`240`	`+ GILRelease release;`
	`241`	`+ mp_consoleDlg->writeError(textToWrite.size(),textToWrite.c_str());`
`243`	`242`	`}`
`244`	`243`	`}`
`245`	`244`	`}`
`@@ -248,7 +247,7 @@ void PythonConsole::stopStatement()`
`248`	`247`	`{`
`249`	`248`	`DWORD threadID;`
`250`	`249`	`CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)PythonConsole::stopStatementWorker, this, 0, &threadID);`
`251`		`-`
	`250`	`+`
`252`	`251`	`}`
`253`	`252`
`254`	`253`	`DWORD PythonConsole::runCommand(boost::python::str text, boost::python::object pyStdout, boost::python::object pyStderr)`
`@@ -267,9 +266,9 @@ void PythonConsole::runStatement(const char *statement)`
`267`	`266`	`mp_consoleDlg->runEnabled(false);`
`268`	`267`	`}`
`269`	`268`
`270`		`- // Console statements executed whilst a script is in progress MUST run on a separate`
	`269`	`+ // Console statements executed whilst a script is in progress MUST run on a separate`
`271`	`270`	`// thread. Otherwise, we wait for the GIL, no problem, except that that blocks the UI thread`
`272`		`- // so if the script happens to be sending a message to scintilla (likely), then`
	`271`	`+ // so if the script happens to be sending a message to scintilla (likely), then`
`273`	`272`	`// it will deadlock.`
`274`	`273`	`// PyProducerConsumer used here to keep one thread running the actual statements`
`275`	`274`
`@@ -326,10 +325,10 @@ void PythonConsole::consume(std::shared_ptr<std::string> statement)`
`326`	`325`
`327`	`326`	`void PythonConsole::stopStatementWorker(PythonConsole *console)`
`328`	`327`	`{`
`329`		`- GILLock gilLock;`
`330`		`-`
	`328`	`+ GILLock gilLock;`
	`329`	`+`
`331`	`330`	`PyThreadState_SetAsyncExc((long)console->getConsumerThreadID(), PyExc_KeyboardInterrupt);`
`332`		`-`
	`331`	`+`
`333`	`332`	`}`
`334`	`333`
`335`	`334`	`void export_console()`
`@@ -345,6 +344,7 @@ void export_console()`
`345`	`344`	`.def("run", &PythonConsole::runCommand, "Runs a command on the console")`
`346`	`345`	`.def("run", &PythonConsole::runCommandNoStderr, "Runs a command on the console")`
`347`	`346`	`.def("run", &PythonConsole::runCommandNoStdout, "Runs a command on the console")`
	`347`	`+ .def("getScintillaHwnd", &PythonConsole::getScintillaHwndPython, "Provide HWnd for scintilla of console")`
`348`	`348`	`.add_static_property("encoding", &PythonConsole::getEncoding)`
`349`	`349`	`.add_property("editor", &PythonConsole::getScintillaWrapper);`
`350`	`350`	`//lint +e1793`