def do_close_if_needed(self):
if (ShouldClose(self.node, self.fromState, self.newState)):
InsertClosed(self.view, self.node,
evt.Make(self.do_recurrence_if_needed))
else:
RemoveClosed(self.view, self.node,
evt.Make(self.do_recurrence_if_needed))
def UpdateProperty(view, node, key, value, onDone=None):
def OnDrawer():
# File is reloaded have to regrab node
n = db.Get().At(view, node.start_row)
if(not n):
log.error("Failed to look up property drawer! Something is wrong!")
start, end = n.property_drawer_location
lkey = key.lower().strip()
mrow = None
# Work backwards, want to find the latest incarnation of this
for row in range(end-1, start, -1):
line = view.getLine(row)
m = RE_PROPERTY_EXTRACT.search(line)
if(m):
k = m.group(1).strip()
v = m.group(2).strip()
if(k.lower() == lkey):
mrow = row
break
# We found our property, replace it!
if(mrow != None):
pt = view.text_point(mrow, 0)
rw = view.line(pt)
text = " {0}:{1}: {2}".format(n.indent(),key,value)
view.ReplaceRegion(rw,text,onDone)
# Otherwise add a new property
else:
AddProperty(view, n, key, value, onDone)
InsertDrawerIfNotPresent(view, node, ":PROPERTIES:", evt.Make(OnDrawer))
def OnPostPostProcess(self):
if (hasattr(self.curmod, "GeneratesImages")
and self.curmod.GeneratesImages(self)):
self.view.run_command("org_cycle_images",
{"onDone": evt.Make(self.OnDone)})
else:
self.OnDone()
def run(self, edit, dateval=None):
if (type(dateval) == str):
dateval = orgdate.OrgDateFreeFloating.from_str(dateval)
# TODO: Find scheduled and replace it as well.
node = db.Get().AtInView(self.view)
if (node and not node.is_root()):
self.oldsel = self.view.sel()[0]
pt = self.view.text_point(node.start_row, 0)
l = self.view.line(pt)
# Last row handling If we are the last row we can't jump over the newline
# we have to add one.
nl = ""
addnl = 1
if (self.view.isBeyondLastRow(node.start_row + 1)):
nl = "\n"
addnl = 0
insertpt = l.end() + addnl
endpt = insertpt + len(nl) + len(node.indent()) + len(self.prefix)
self.reg = sublime.Region(insertpt, endpt)
self.view.insert(edit, insertpt, nl + node.indent() + self.prefix)
pt = self.view.text_point(node.start_row + 1, 0)
l = self.view.line(pt)
self.view.sel().clear()
self.view.sel().add(l.end())
if (dateval == None):
datep.Pick(evt.Make(self.insert))
else:
self.insert(dateval)
def on_done(self, index):
if (index < 0):
return
newState = self.todoStates[index]
if (newState == "none"):
newState = ""
# if we don't have a TODO state then we have to handle that as well.
m = self.todoRe.search(self.bufferContents)
fromState = None
if (m == None):
self.todoRe = re.compile(r"^([*]+ (\[\#[a-zA-Z0-9]+\]\s+)?)( )*")
else:
fromState = m.group(3)
if (newState != ""):
newState += " "
self.bufferContents = self.todoRe.sub(r"\g<1>" + newState,
self.bufferContents)
# We have to do the editing in sequence because the reloads can get mixed up otherwise
if (fromState):
self.fromState = fromState.strip()
else:
self.fromState = ""
self.newState = newState.strip()
# Recurring events do not hit the done state when you toggle them
# They bounce back to TODO they just get a new note in them
if (ShouldRecur(self.node, self.fromState, self.newState)):
self.do_note_if_needed()
else:
self.view.ReplaceRegion(self.row, self.bufferContents,
evt.Make(self.do_note_if_needed))
def do_recurrence_if_needed(self):
self.rec = ShouldRecur(self.node, self.fromState, self.newState)
if (self.rec):
InsertRecurrence(self.view, self.node, self.fromState,
self.newState,
evt.Make(self.on_update_timestamps_if_needed))
else:
self.on_totally_done()
def run(self, edit, text=None, onDone=None):
self.onDone = onDone
self.text = text.strip() if text != None else text
if (self.text != None and self.text != ""):
self.OnDone(self.text)
else:
self.input = insSel.OrgInput()
self.input.run("Tag:", db.Get().tags, evt.Make(self.OnDone))
def on_panel_ready(self, index, openas, panel):
self.panel = panel
global captureBufferName
captureBufferName = sets.Get("captureBufferName", captureBufferName)
window = self.view.window()
template = self.templates[index]
target, capturePath, captureFile, at = GetCapturePath(
self.view, template)
if (panel.is_loading()):
sublime.set_timeout_async(
lambda: self.on_panel_ready(index, openas, panel), 100)
return
startPos = -1
# Try to store the capture index
panel.settings().set('cap_index', index)
panel.settings().set('cap_view', self.view.id())
self.openas = openas
if ('template' in template):
startPos = self.insert_template(template['template'], panel)
window.run_command('show_panel',
args={'panel': 'output.orgcapture'})
panel.sel().clear()
panel.sel().add(startPos)
window.focus_view(panel)
self.cleanup_capture_panel()
elif ('snippet' in template):
self.level = 0
self.pt = None
prefix = ""
if (self.openas):
insertAt = captureFile.At(at)
self.pt = panel.text_point(insertAt.end_row + 1, 0)
self.insertRow = insertAt.end_row + 1
linev = panel.line(self.pt)
linetxt = panel.substr(linev)
if (linetxt and not linetxt.strip() == ""):
prefix = "\n"
self.pt = linev.end()
self.insertRow += 1
else:
self.pt = linev.begin()
panel.sel().clear()
panel.sel().add(self.pt)
self.level = insertAt.level
else:
window.run_command('show_panel',
args={'panel': 'output.orgcapture'})
if (self.openas and self.level > 0):
self.index = index
self.panel = panel
self.panel.Insert(self.pt, prefix + ("*" * self.level),
evt.Make(self.on_added_stars))
else:
self.insert_snippet(index)
def InsertRecurrence(view, node, fromState, toState, onDone=None):
# - State "DONE" from "TODO" [2009-09-29 Tue]"
stamp = OrgDate.format_clock(datetime.datetime.now(), active=False)
def OnLogAdded():
props.UpdateProperty(view, node, "LAST_REPEAT", stamp, onDone)
props.AddLogbook(
view, node,
"- State {0:12} from {1:12} ".format('"' + toState + '"',
'"' + fromState + '"'), stamp,
evt.Make(OnLogAdded))
def run(self, edit):
n = db.Get().AtInView(self.view)
s = self.view.text_point(n.start_row, 0)
e = self.view.line(self.view.text_point(n.end_row, 0)).end()
r = sublime.Region(s, e)
ct = self.view.substr(r)
start = ""
#if "#+TITLE:" not in ct:
# start = "#+TITLE: " + os.path.splitext(os.path.basename(self.view.file_name()))[0]
tempFile = tf.CreateTempFileFromRegion(self.view, r, ".org", start)
#print("temp file: " + str(tempFile))
self.tempView = self.view.window().open_file(tempFile)
self.tempView.run_command('org_export_file_org_html',
{"onDone": evt.Make(self.onDone)})
def run(self,edit,onDone=None):
self.onDone = onDone
n = db.Get().AtInView(self.view)
if(n == None):
log.error(" Failed to find node! Subtree cannot be exported!")
return
index = 0
for i in range(0,len(n.env._nodes)):
if(n == n.env._nodes[i]):
index = i
if(index == 0):
log.error(" Failed to find node in file! Something is wrong. Cannot export subtree!")
return
self.view.run_command('org_export_file_org_html', {"onDone": evt.Make(self.OnDone), "index": index, "suffix":"_subtree"})
def run(self,edit, onDone=None, index=None, suffix=""):
self.file = db.Get().FindInfo(self.view)
self.onDone = onDone
self.suffix = suffix
if(index != None):
self.index = index
else:
self.index = None
if(None == self.file):
log.error("Not an org file? Cannot build reveal document")
evt.EmitIf(onDone)
return
if(sets.Get("htmlExecuteSourceOnExport",True)):
self.view.run_command('org_execute_all_source_blocks',{"onDone":evt.Make(self.OnDoneSourceBlockExecution),"amExporting": True})
else:
self.OnDoneSourceBlockExecution()
def run(self, edit, onDone=None):
self.onDone = onDone
# Schedule this item so it is in the agenda
self.view.run_command("org_schedule",
{"dateval": str(datetime.datetime.now())})
# Create a link to the current location so we can insert it in our today item
self.link = orglink.CreateLink(self.view)
curNode = db.Get().AtInView(self.view)
# Should we add a heading to this?
if (curNode and not curNode.is_root()):
self.ed = RunEditingCommandOnToday(
self.view, "org_insert_text_as_child_heading",
{'heading': curNode.heading})
self.ed.Run(evt.Make(self.InsertLink))
else:
self.InsertLink()
def ProcessPossibleSourceObjects(cmd, language, cmdArgs):
#BuildFullParamList(cmd,language,cmdArgs)
var = cmd.params.GetDict('var', None)
cmd.params.Replace('var', var)
cmd.deferedSources = 0
hadDeferred = False
if (var):
for k in var:
n = var[k]
if (not util.numberCheck(n)):
td = tbl.LookupTableFromNamedObject(n)
if (td):
# I think it's better to just pass through the table here.
# Each language may want to do something very different and abstracting away
# What the data source actually is may actually be a disservice
#var[k] = GetGeneratorForTable(td,cmd.params)
var[k] = td
else:
l = lst.LookupNamedListInFile(n)
if (l):
var[k] = l
else:
pt = LookupNamedSourceBlockInFile(n)
if (None != pt):
if (not n in cmd.sourcefns):
cmd.deferedSources += 1
hadDeferred = True
cmd.sourcefns[n] = {
'at': pt,
'key': k,
'name': n
}
cmd.view.run_command(
'org_execute_source_block', {
'at':
pt,
'onDoneResultsPos':
evt.Make(cmd.OnDoneFunction),
'onDoneFnName':
n
})
return hadDeferred
def run(self, edit, onDone=None):
self.onDone = onDone
self.input = insSel.OrgInput()
#print(str(db.Get().customids))
self.input.run("Custom Id:",
db.Get().customids, evt.Make(self.on_done))
def run(self, edit, onDone=None):
self.onDone = onDone
self.view.run_command("org_insert_tag", {
"onDone": evt.Make(self.OnDone),
"text": "ARCHIVE"
})
def OnHidden(self):
self.view.run_command("org_show_images",
{"onDone": evt.Make(self.OnShown)})
def run(self, edit, onDone=None):
self.onDone = onDone
self.cursor = self.view.sel()[0]
self.view.run_command("org_hide_images",
{"onDone": evt.Make(self.OnHidden)})
def run(self, edit):
datep.Pick(evt.Make(self.insert))
def on_insert_note(self, text):
InsertNote(self.view, self.node, text, self.fromState, self.newState,
evt.Make(self.do_close_if_needed))
def Execute(self):
view = self.view
self.outHandler = SetupOutputHandler(self)
self.outFormatter = SetupOutputFormatter(self)
# Run the "writer"
if (hasattr(self.curmod, "Execute")):
# Okay now time to replace the contents of the block
self.source = view.substr(self.region)
if (hasattr(self.curmod, "PreProcessSourceFile")):
self.curmod.PreProcessSourceFile(self)
if (hasattr(self.curmod, "Extension")):
tmp = tempfile.NamedTemporaryFile(
delete=False, suffix=self.curmod.Extension(self))
try:
self.filename = tmp.name
if (hasattr(self.curmod, "WrapStart")):
tmp.write((self.curmod.WrapStart(self) +
"\n").encode("ascii"))
tmp.write(self.source.encode('ascii'))
if (hasattr(self.curmod, "WrapEnd")):
tmp.write(
("\n" + self.curmod.WrapEnd(self)).encode("ascii"))
tmp.close()
self.outputs = self.curmod.Execute(self, sets)
except:
log.debug(" " + traceback.format_exc())
finally:
pass
else:
self.filename = None
self.outputs = self.curmod.Execute(self, sets)
log.debug("OUTPUT: " + str(self.outputs))
else:
log.error("No execute in module, abort")
return
# Reformat adding indents to each line!
# No bad formatting allowed!
n = db.Get().AtPt(view, self.s)
self.level = n.level
self.outHandler.SetIndent(n.level)
if (self.outFormatter):
self.outFormatter.SetIndent(n.level)
output = self.outHandler.FormatOutput(self.outputs)
self.preFormattedOutput = output
self.resultsTxtStart = self.resultsStartPt + self.level + 1
rowadjust = 0
if (self.outFormatter):
output, rowadjust = self.outFormatter.FormatOutput(output)
# If our formatter wrapped us we have to adjust our text point for post processing
# and results text.
if (rowadjust > 0):
row, col = self.view.rowcol(self.resultsTxtStart)
row += rowadjust
self.resultsTxtStart = self.view.text_point(row, col)
## Keep track of this so we know where we are inserting the text.
self.formattedOutput = (" " * self.level + " ") + output + '\n'
if (self.CheckResultsFor('silent')):
# We only echo to the console in silent mode.
print(self.formattedOutput)
self.silent = True
self.OnReplaced()
# Add after other text
elif (self.CheckResultsFor('append')):
self.view.run_command(
"org_internal_replace", {
"start": self.resultsEndPt,
"end": self.resultsEndPt,
"text": self.formattedOutput,
"onDone": evt.Make(self.OnReplaced)
})
# Add before other text
elif (self.CheckResultsFor('prepend')):
self.view.run_command(
"org_internal_replace", {
"start": self.resultsStartPt,
"end": self.resultsStartPt,
"text": self.formattedOutput,
"onDone": evt.Make(self.OnReplaced)
})
# Replace mode
else:
self.view.run_command(
"org_internal_replace", {
"start": self.resultsStartPt,
"end": self.resultsEndPt,
"text": self.formattedOutput,
"onDone": evt.Make(self.OnReplaced)
})
def InsertLink(self):
self.ed = RunEditingCommandOnToday(self.view, "org_append_text",
{'text': self.link})
self.ed.Run(evt.Make(self.OnDone))
def on_update_timestamps_if_needed(self, row=0):
# We have to reload our node as we updated things.
self.node = db.Get().At(self.view, self.node.start_row)
if (row > (self.node.local_end_row + 1)):
self.on_totally_done()
for i in range(self.node.start_row + row, self.node.local_end_row + 1):
pt = self.view.text_point(i, 0)
line = self.view.line(pt)
txt = self.view.substr(line)
m = RE_T.search(txt)
now = datetime.datetime.now()
if (m):
tsl = OrgDate.list_from_str(m.group('time'))
if (tsl):
t = tsl[0]
if (t.repeating):
next = t.start
next2 = t.end
if (t.repeatpre == "+"):
next = t.next_repeat_from(oa.EnsureDateTime(next))
elif (t.repeatpre == "++"):
while (next < now):
next = t.next_repeat_from(
oa.EnsureDateTime(next))
elif (t.repeatpre == ".+"):
next = t.next_repeat_from(now)
s = m.start(1)
e = m.end(1)
rpt = t.repeatpre + str(t.repeatnum) + t.repeatdwmy
wrn = ""
if (t.warning):
wrn = " " + t.warnpre + str(t.warnnum) + t.warndwmy
if (t.has_end()):
if (t.has_time()):
nout = txt[:s] + next.strftime(
"<%Y-%m-%d %a %H:%M-") + t.end.strftime(
"%H:%M ") + rpt + wrn + ">" + txt[e:]
else:
# This really shouldn't happen.
nout = txt[:s] + next.strftime(
"<%Y-%m-%d %a "
) + rpt + wrn + ">" + txt[e:]
else:
if (t.has_time()):
nout = txt[:s] + next.strftime(
"<%Y-%m-%d %a %H:%M "
) + rpt + wrn + ">" + txt[e:]
else:
nout = txt[:s] + next.strftime(
"<%Y-%m-%d %a "
) + rpt + wrn + ">" + txt[e:]
self.view.run_command(
"org_internal_replace", {
"start":
line.begin(),
"end":
line.end(),
"text":
nout,
"onDone":
evt.Make(lambda: self.
on_update_timestamps_if_needed(i + 1))
})
return
self.on_totally_done()
def run(self, edit):
view = self.view
at = view.sel()[0]
if (view.match_selector(at.begin(), 'orgmode.fence.dynamicblock')):
# Okay we have a dynamic block, now we need to know where it ends.
start = at.begin()
end = None
erow = view.endRow()
row = view.curRow()
for rw in range(row, erow + 1):
line = view.substr(view.line(view.text_point(rw, 0)))
if (RE_END.search(line)):
end = rw
break
if (not end):
log.debug("Could not locate #+END: tag")
return
# Okay now we have a start and end to build a region out of.
# time to run a command and try to get the output.
dynamic = ext.find_extension_modules(
'orgdynamic', ["insertdatetime", "clocktable", "columnview"])
line = view.substr(view.line(start))
m = RE_DYN_BLOCK.search(line)
if (not m):
log.error("FAILED TO PARSE DYNAMIC BLOCK: " + line)
return
fnname = m.group('name')
#log.debug("DYN NAME: " + fnname)
params = PList.createPList(line[len(m.group(0)):])
# Now find me that function!
if (fnname not in dynamic):
log.error(
"Function not found in dynamic folder! Cannot execute!")
return
# Run the "writer"
if (hasattr(dynamic[fnname], "Execute")):
self.curmod = dynamic[fnname]
self.params = params
outputs = self.curmod.Execute(view, params)
#log.debug("OUTPUT: " + str(outputs))
# Okay now time to replace the contents of the block
s = view.text_point(row + 1, 0)
e = view.text_point(end, 0)
self.region = sublime.Region(s, e)
# Reformat adding indents to each line!
# No bad formatting allowed!
n = db.Get().AtInView(view)
level = n.level
indent = "\n" + (" " * level) + " "
#outputs = output.split('\n')
output = indent.join(outputs)
print(output)
self.view.run_command(
"org_internal_replace", {
"start": s,
"end": e,
"text": (" " * level + " ") + output + "\n",
"onDone": evt.Make(self.on_replaced)
})
else:
log.error("NOT in A DynamicBlock, nothing to run")
