How to use the zencad.gui function in zencad

client_communicator=None, 
			openned_path=None, 
			presentation=False,
			fastopen=None,
			display_mode=False,
			title = "ZenCad"):
		super().__init__()
		self.setWindowTitle(title)
		self.openlock = threading.Lock()
		self.console = zencad.gui.console.ConsoleWidget()
		self.texteditor = zencad.gui.texteditor.TextEditor()
		self.current_opened = None
		self.last_reopen_time = time.time()
		self.need_prescale = True

		self.nqueue = zencad.gui.nqueue.nqueue()
		self.client_communicator = client_communicator
		
		if self.client_communicator:
			self.client_communicator.newdata.connect(self.new_worker_message)
			#self.client_communicator.start_listen()

		if SLEEPED_OPTIMIZATION:
			self.sleeped_client = zencad.gui.application.spawn_sleeped_client(session_id=1)

		self.cw = QWidget()
		self.cw_layout = QVBoxLayout()
		self.hsplitter = QSplitter(Qt.Horizontal)
		self.vsplitter = QSplitter(Qt.Vertical)
		self.info_widget = InfoWidget()

		self.cw_layout.addWidget(self.hsplitter)

sys.stderr.flush()
			exit(0)
		
		while(True):
			if self.stop_token:
				if __RETRANSLER_TRACE__:
					print_to_stderr("finish console retransler... ok")
				return
			try:
				inputdata = self.readFile.readline()
			except:
				if __RETRANSLER_TRACE__:
					print_to_stderr("finish console retransler... except")
				return
			
			zencad.gui.application.MAIN_COMMUNICATOR.send({"cmd":"console","data":inputdata})

# Используется при создании gui из в ходе работы интерпретатора.
	if pargs.subproc:
		if pargs.tgtpath == None:
			print_to_stderr("Error: subproc mode without tgtpath")
			exit(0)

		trace("start_main_application")
		zencad.gui.application.start_main_application(pargs.tgtpath, display_mode=True, console_retrans=True)	
		trace("start_main_application ... ok")
		return

	retrans_out_file = None
	if pargs.replace and zencad.configure.CONFIGURE_CONSOLE_RETRANSLATE:
		# Теперь можно сделать поток для обработки данных, которые программа собирается 
		# посылать в stdout
		zencad.gui.application.CONSOLE_RETRANS_THREAD = zencad.gui.retransler.console_retransler(sys.stdout)
		zencad.gui.application.CONSOLE_RETRANS_THREAD.start()
		retrans_out_file = zencad.gui.application.CONSOLE_RETRANS_THREAD.new_file

	if pargs.sleeped:
		# Эксперементальная функциональность для ускорения обновления модели. 
		# Процесс для обновления модели создаётся заранее и ждёт, пока его пнут со стороны сервера.
		zencad.util.PROCNAME = f"sl({os.getpid()})"
		readFile = os.fdopen(zencad.gui.application.STDIN_FILENO)

		while 1:
			trace("SLEEPED THREAD: read")
			rawdata = readFile.readline()
			try:
				data = pickle.loads(base64.b64decode(bytes(rawdata, "utf-8")))
				trace("SLEEPED THREAD RECV:", data)
			except:

def __init__(self, 
			client_communicator=None, 
			openned_path=None, 
			presentation=False,
			fastopen=None,
			display_mode=False,
			title = "ZenCad"):
		super().__init__()
		self.setWindowTitle(title)
		self.openlock = threading.Lock()
		self.console = zencad.gui.console.ConsoleWidget()
		self.texteditor = zencad.gui.texteditor.TextEditor()
		self.current_opened = None
		self.last_reopen_time = time.time()
		self.need_prescale = True

		self.nqueue = zencad.gui.nqueue.nqueue()
		self.client_communicator = client_communicator
		
		if self.client_communicator:
			self.client_communicator.newdata.connect(self.new_worker_message)
			#self.client_communicator.start_listen()

		if SLEEPED_OPTIMIZATION:
			self.sleeped_client = zencad.gui.application.spawn_sleeped_client(session_id=1)

		self.cw = QWidget()

def __init__(self, 
			client_communicator=None, 
			openned_path=None, 
			presentation=False,
			fastopen=None,
			display_mode=False,
			title = "ZenCad"):
		super().__init__()
		self.setWindowTitle(title)
		self.openlock = threading.Lock()
		self.console = zencad.gui.console.ConsoleWidget()
		self.texteditor = zencad.gui.texteditor.TextEditor()
		self.current_opened = None
		self.last_reopen_time = time.time()
		self.need_prescale = True

		self.nqueue = zencad.gui.nqueue.nqueue()
		self.client_communicator = client_communicator
		
		if self.client_communicator:
			self.client_communicator.newdata.connect(self.new_worker_message)
			#self.client_communicator.start_listen()

		if SLEEPED_OPTIMIZATION:
			self.sleeped_client = zencad.gui.application.spawn_sleeped_client(session_id=1)

		self.cw = QWidget()
		self.cw_layout = QVBoxLayout()

break

		try:
			pargs.prescale = data["need_prescale"]
			pargs.size = data["size"]
			pargs.paths = [data["path"]]
		except:
			print_to_stderr("Unpickle error_2", data)
			exit(0)

		zencad.settings.restore()			

	if pargs.replace and zencad.configure.CONFIGURE_CONSOLE_RETRANSLATE:
		# Теперь можно сделать поток для обработки данных, которые программа собирается 
		# посылать в stdout
		zencad.gui.application.MAIN_COMMUNICATOR = zencad.gui.communicator.Communicator(
			ifile=sys.stdin, ofile=retrans_out_file)
		zencad.gui.application.MAIN_COMMUNICATOR.start_listen()
		#zencad.gui.application.MAIN_COMMUNICATOR.newdata.connect(hard_finish_checker)
		
		if OPPOSITE_PID_SAVE is not None:
			zencad.gui.application.MAIN_COMMUNICATOR.set_opposite_pid(OPPOSITE_PID_SAVE)

		zencad.lazifier.install_evalcahe_notication(zencad.gui.application.MAIN_COMMUNICATOR)

		#zencad.gui.application.MAIN_COMMUNICATOR.send({"cmd":"clientpid", "pid":int(os.getpid())})
	


	if len(pargs.paths) == 0 and not pargs.sleeped:
		# Если программа вызывается без указания файла, создаём gui. 
		# Режим презентации указывает gui, что оно предоставлено само себе

else:
		# Режим работы, когда указан файл.
		# Политика такова, что начало исполняется вычисляемый 
		# скрипт, а потом, после вызова zencad.show,
		# применяются указанные варианты вызова.
		# информация отсюда транслируется функции show
		# через глобальные переменные.

		if not os.path.abspath(pargs.paths[0]):
			path = os.path.join(os.getcwd(), pargs.paths[0])
		else:
			path = pargs.paths[0]
		zencad.showapi.EXECPATH = path

		if os.path.splitext(pargs.paths[0])[1] == ".brep":
			zencad.gui.viewadaptor.brep_hot_open(pargs.paths[0])
			return
	
		# Устанавливаем рабочей директорией дирректорию,
		# содержащую целевой файл.
		# TODO: Возможно, так делать нужно только
		# при загрузке через GUI. Вынести флаг?
		directory = os.path.dirname(os.path.abspath(path))
		os.chdir(directory)
		
		sys.path.append(directory)
		
		# По умолчанию приложение работает в режиме,
		# предполагающем вызов указанного скрипта. 
		# Далее скрипт сам должен создать GUI через showapi.
		zencad.showapi.SHOWMODE = "makeapp"

def do_main():
	#os.closerange(3, 100)

	OPPOSITE_PID_SAVE = None
	zencad.gui.signal_handling.setup_simple_interrupt_handling()

	parser = argparse.ArgumentParser()
	parser.add_argument("-i", "--info", action="store_true")
	parser.add_argument('-v', "--debug", action="store_true")
	parser.add_argument("--version", action="store_true")
	parser.add_argument("--pyservoce-version", action="store_true")
	parser.add_argument("-I", "--mpath", action="store_true")
	parser.add_argument("-m", "--module", default="zencad")
	parser.add_argument("--subproc", action="store_true")
	parser.add_argument("--replace", action="store_true")
	parser.add_argument("--widget", action="store_true")
	parser.add_argument("--prescale", action="store_true")
	parser.add_argument("--sleeped", action="store_true", help="Don't use manualy. Create sleeped thread.")
	parser.add_argument("--no-daemon", action="store_true")
	parser.add_argument("--no-show", action="store_true")
	parser.add_argument("--no-sleeped", action="store_true")

def handle_open(self):
		path = zencad.gui.util.open_file_dialog(self, directory=os.path.dirname(zencad.settings.Settings.get_recent()[0]))

		if len(path[0]) == 0:
			#self.reject()
			return

		self.openpath = path[0]
		self.accept()