def openLeoFile(self, fileName):
"""Open a .leo file, or create a new Leo frame if no fileName is given."""
g = self.g
g.app.silentMode = self.silentMode
useLog = False
if not self.isOpen():
return None
if self.useCaches:
self.reopen_cachers()
else:
g.app.db = g.NullObject()
fileName = self.completeFileName(fileName)
c = g.openWithFileName(fileName) # #2489.
# Leo 6.3: support leoInteg.
g.app.windowList.append(c.frame)
if not self.useCaches:
c.db = g.NullObject()
# New in Leo 5.1. An alternate fix for bug #130.
# When using a bridge Leo might open a file, modify it,
# close it, reopen it and change it all within one second.
# In that case, this code must properly compute the next
# available gnx by scanning the entire outline.
g.app.nodeIndices.compute_last_index(c)
if useLog:
g.app.gui.log = log = c.frame.log
log.isNull = False
log.enabled = True
return c
def finishCreate(self, c):
'''Create the entire Leo main window in the shim itself.'''
import leo.plugins.qt_frame as qt_frame
import leo.plugins.qt_text as qt_text
###
# import leo.plugins.qt_tree as qt_tree
# import leo.plugins.qt_menu as qt_menu
# import leo.core.leoFrame as leoFrame
self.c = c
g.pr('\n----- OutlineEditorShim.finishCreate: g.app.log: %r\n' %
g.app.log)
# Called by c.finishCreate.
f = c.frame
# A LeoFrame, *not* a QWidget.
c.frame.c = c
assert isinstance(c.frame, qt_frame.LeoQtFrame), repr(c.frame)
self.setStyleSheet('background: red')
# No longer seen, which is good.
#
# From SDIFrameFactory.createFrame
dw = qt_frame.DynamicWindow(c, parent=self)
dw.construct()
# This just creates frames for components.
dw.show()
f.top = dw
assert isinstance(dw.treeWidget,
qt_frame.LeoQTreeWidget), repr(dw.treeWidget)
#
# From LeoQtFrame.finishCreate.
f.createIconBar() # A base class method.
f.createSplitterComponents()
### f.createStatusLine() # A base class method.
f.createFirstTreeNode() # Call the base-class method.
# Does some basic inits.
if 1:
lm = g.app.loadManager
fn = c.fileName()
theFile = lm.openLeoOrZipFile(fn)
# Enable the log.
g.app.unlockLog()
c.frame.log.enable(True)
# Phase 2: Create the outline.
### g.doHook("open1", old_c=None, c=c, new_c=c, fileName=fn)
if theFile:
### readAtFileNodesFlag = bool(previousSettings)
readAtFileNodesFlag = True
# The log is not set properly here.
assert c.p
ok = lm.readOpenedLeoFile(c, fn, readAtFileNodesFlag, theFile)
# Call c.fileCommands.openLeoFile to read the .leo file.
if not ok:
g.trace('lm.readOpenedLeoFile FAILED', fn)
### f.menu = qt_menu.LeoQtMenu(c, f, label='top-level-menu')
f.menu = g.NullObject(tag='c.frame.menu')
g.app.windowList.append(f)
f.miniBufferWidget = qt_text.QMinibufferWrapper(c)
c.setLog()
c.redraw()
c.bodyWantsFocus()
def __getattr__(self, name):
aList = self.d.get(name, [])
callers = g.callers(4)
if callers not in aList:
aList.append(callers)
self.d[name] = aList
g.trace('%30s' % ('TemplateMenu.' + name), callers)
return g.NullObject()
def create_app():
"""
Create the Leo application, g.app, the Gui, g.app.gui, and a commander.
This method is expensive (about 1 sec) only the first time it is called.
Thereafter, recreating g.app, g.app.gui, and new commands is fast.
"""
# t1 = time.process_time()
from leo.core import leoGlobals as g
from leo.core import leoApp
g.app = leoApp.LeoApp() # Do this first, to avoid circular dependencies.
from leo.core import leoConfig
from leo.core import leoNodes
from leo.core import leoCommands
from leo.core import leoGui
# t2 = time.process_time()
g.app.recentFilesManager = leoApp.RecentFilesManager()
g.app.loadManager = leoApp.LoadManager()
g.app.loadManager.computeStandardDirectories()
if not g.app.setLeoID(useDialog=False, verbose=True):
raise ValueError("unable to set LeoID.")
g.app.nodeIndices = leoNodes.NodeIndices(g.app.leoID)
g.app.config = leoConfig.GlobalConfigManager()
g.app.db = g.TracingNullObject('g.app.db')
g.app.pluginsController = g.NullObject('g.app.pluginsController')
g.app.commander_cacher = g.NullObject('g.app.commander_cacher')
g.app.gui = leoGui.NullGui()
# t3 = time.process_time()
#
# Create a dummy commander, to do the imports in c.initObjects.
c = leoCommands.Commands(fileName=None, gui=g.app.gui)
# t4 = time.process_time()
# if t4 - t3 > 0.1:
# print('create_app\n'
# f" imports: {(t2-t1):.3f}\n"
# f" gui: {(t3-t2):.3f}\n"
# f"commander: {(t4-t2):.3f}\n"
# f" total: {(t4-t1):.3f}\n")
return c
def __init__(self, guiName='nullGui'):
'''ctor for the NullGui class.'''
LeoGui.__init__(self, guiName)
# init the base class.
self.clipboardContents = ''
self.theDict = {}
self.focusWidget = None
self.frameFactory = g.NullObject()
self.iconimages = {}
self.script = None
self.lastFrame = None
self.isNullGui = True
self.bodyTextWidget = leoFrame.StringTextWidget
self.plainTextWidget = leoFrame.StringTextWidget
def runMainLoop(self, fileName=None):
'''The main loop for the browser gui.'''
# pylint: disable=arguments-differ
if fileName:
print('LeoWapp running: %s...' % g.shortFileName(fileName))
else:
print('LeoWapp running...')
if 0: # Run all unit tests.
path = g.os_path_finalize_join(g.app.loadDir, '..', 'test',
'unittest.leo')
c = g.openWithFileName(path, gui=self)
c.findCommands.ftm = g.NullObject()
# A hack. Maybe the NullGui should do this.
c.debugCommands.runAllUnitTestsLocally()
print('calling sys.exit(0)')
sys.exit(0)
def __init__ (self,c):
'''Ctor for backlinkController class.'''
self.c = c
self.c.backlinkController = self
self.initIvars()
self.name_levels = c.config.getInt('backlink_name_levels') or 0
self.fixIDs(c)
if Tk:
self.ui = backlinkTkUI(self)
elif Qt:
self.ui = backlinkQtUI(self)
else:
# Fix part of #509. Ignore missing attributes.
self.ui = g.NullObject()
g.registerHandler('select3', self.updateTab)
g.registerHandler('open2', self.loadLinks)
# already missed initial 'open2' because of after-create-leo-frame, so
self.loadLinksInt()
self.updateTabInt()
def initLeo(self):
"""
Init the Leo app to which this class gives access.
This code is based on leo.run().
"""
if not self.isValidPython():
return
#@+<< initLeo imports >>
#@+node:ekr.20070227093629.1: *4* << initLeo imports >> initLeo (leoBridge)
try:
# #1472: Simplify import of g
from leo.core import leoGlobals as g
self.g = g
except ImportError:
print("Error importing leoGlobals.py")
#
# Create the application object.
try:
# Tell leoApp.createDefaultGui not to create a gui.
# This module will create the gui later.
g.in_bridge = self.vs_code_flag # #2098.
g.in_vs_code = True # 2098.
from leo.core import leoApp
g.app = leoApp.LeoApp()
except ImportError:
print("Error importing leoApp.py")
g.app.leoID = None
if self.tracePlugins:
g.app.debug.append('plugins')
g.app.silentMode = self.silentMode
#
# Create the g.app.pluginsController here.
from leo.core import leoPlugins
leoPlugins.init() # Necessary. Sets g.app.pluginsController.
try:
from leo.core import leoNodes
except ImportError:
print("Error importing leoNodes.py")
traceback.print_exc()
try:
from leo.core import leoConfig
except ImportError:
print("Error importing leoConfig.py")
traceback.print_exc()
#@-<< initLeo imports >>
g.app.recentFilesManager = leoApp.RecentFilesManager()
g.app.loadManager = lm = leoApp.LoadManager()
lm.computeStandardDirectories()
# #2519: Call sys.exit if leoID does not exist.
g.app.setLeoID(useDialog=False, verbose=True)
# Can be done early. Uses only g.app.loadDir & g.app.homeDir.
lm.createAllImporterData() # #1965.
g.app.inBridge = True # Support for g.getScript.
g.app.nodeIndices = leoNodes.NodeIndices(g.app.leoID)
g.app.config = leoConfig.GlobalConfigManager()
if self.useCaches:
g.app.setGlobalDb() # #556.
else:
g.app.db = g.NullObject()
g.app.commander_cacher = g.NullObject()
g.app.global_cacher = g.NullObject()
if self.readSettings:
# reads only standard settings files, using a null gui.
# uses lm.files[0] to compute the local directory
# that might contain myLeoSettings.leo.
lm.readGlobalSettingsFiles()
else:
# Bug fix: 2012/11/26: create default global settings dicts.
settings_d, bindings_d = lm.createDefaultSettingsDicts()
lm.globalSettingsDict = settings_d
lm.globalBindingsDict = bindings_d
self.createGui() # Create the gui *before* loading plugins.
if self.verbose:
self.reportDirectories()
self.adjustSysPath()
# Kill all event handling if plugins not loaded.
if not self.loadPlugins:
def dummyDoHook(tag, *args, **keys):
pass
g.doHook = dummyDoHook
g.doHook("start1") # Load plugins.
g.app.computeSignon()
g.app.initing = False
g.doHook("start2", c=None, p=None, v=None, fileName=None)
def create_app(gui_name='null'):
"""
Create the Leo application, g.app, the Gui, g.app.gui, and a commander.
This method is expensive (0.5 sec) only the first time it is called.
Thereafter, recreating g.app, g.app.gui, and new commands is fast.
"""
trace = False
t1 = time.process_time()
#
# Set g.unitTesting *early*, for guards, to suppress the splash screen, etc.
g.unitTesting = True
# Create g.app now, to avoid circular dependencies.
g.app = leoApp.LeoApp()
# Late imports.
warnings.simplefilter("ignore")
from leo.core import leoConfig
from leo.core import leoNodes
from leo.core import leoCommands
from leo.core.leoGui import NullGui
if gui_name == 'qt':
from leo.plugins.qt_gui import LeoQtGui
t2 = time.process_time()
g.app.recentFilesManager = leoApp.RecentFilesManager()
g.app.loadManager = lm = leoApp.LoadManager()
lm.computeStandardDirectories()
g.app.leoID = 'TestLeoId' # 2022/03/06: Use a standard user id for all tests.
g.app.nodeIndices = leoNodes.NodeIndices(g.app.leoID)
g.app.config = leoConfig.GlobalConfigManager()
g.app.db = g.NullObject('g.app.db') # type:ignore
g.app.pluginsController = g.NullObject(
'g.app.pluginsController') # type:ignore
g.app.commander_cacher = g.NullObject(
'g.app.commander_cacher') # type:ignore
if gui_name == 'null':
g.app.gui = NullGui()
elif gui_name == 'qt':
g.app.gui = LeoQtGui()
else:
raise TypeError(f"create_gui: unknown gui_name: {gui_name!r}")
t3 = time.process_time()
# Create a dummy commander, to do the imports in c.initObjects.
# Always use a null gui to avoid screen flash.
# setUp will create another commander.
c = leoCommands.Commands(fileName=None, gui=g.app.gui)
# Create minimal config dictionaries.
settings_d, bindings_d = lm.createDefaultSettingsDicts()
lm.globalSettingsDict = settings_d
lm.globalBindingsDict = bindings_d
c.config.settingsDict = settings_d
c.config.bindingsDict = bindings_d
assert g.unitTesting is True # Defensive.
t4 = time.process_time()
# Trace times. This trace happens only once:
# imports: 0.016
# gui: 0.000
# commander: 0.469
# total: 0.484
if trace and t4 - t3 > 0.1:
print('create_app:\n'
f" imports: {(t2-t1):.3f}\n"
f" gui: {(t3-t2):.3f}\n"
f"commander: {(t4-t2):.3f}\n"
f" total: {(t4-t1):.3f}\n")
return c
