diff --git a/prototypes/tile/6.mu b/prototypes/tile/6.mu
deleted file mode 100644
index be95dead..00000000
--- a/prototypes/tile/6.mu
+++ /dev/null
@@ -1,184 +0,0 @@
-# rendering trees of arbitrary depth, with each node having a single child
-#
-# To run (on Linux and x86):
-# $ git clone https://github.com/akkartik/mu
-# $ cd mu
-# $ ./translate_mu prototypes/tile/6.mu
-# $ ./a.elf
-#
-# Every time you press a key, a deeper tree is rendered. Press ctrl-c to exit.
-# It seems useful as a visual idiom to represent nodes with a single child as
-# slightly larger than the child.
-# Once we get to multiple children we'll start tiling more regularly.
-
-# We also have tests now:
-# $ ./a.elf test
-fn main args-on-stack: (addr array addr array byte) -> exit-status/ebx: int {
- var args/eax: (addr array addr array byte) <- copy args-on-stack
- var tmp/ecx: int <- length args
- $main-body: {
- # if (len(args) > 1 && args[1] == "test") run-tests()
- compare tmp, 1
- {
- break-if-<=
- # if (args[1] == "test") run-tests()
- var tmp2/ecx: (addr addr array byte) <- index args, 1
- var tmp3/eax: boolean <- string-equal? *tmp2, "test"
- compare tmp3, 0
- {
- break-if-=
- run-tests
- exit-status <- copy 0 # TODO: get at Num-test-failures somehow
- }
- break $main-body
- }
- # otherwise operate interactively
- exit-status <- interactive
- }
-}
-
-# - interactive loop
-
-type cell {
- val: int # single chars only for now
- parent: (handle cell)
- first-child: (handle cell)
- next-sibling: (handle cell)
- prev-sibling: (handle cell)
-}
-
-fn interactive -> exit-status/ebx: int {
- var root-handle: (handle cell)
- var root/esi: (addr handle cell) <- address root-handle
- allocate root
- var cursor/edi: (addr handle cell) <- copy root
- enable-keyboard-immediate-mode
- var root-addr/eax: (addr cell) <- lookup *root
- render root-addr
-$main:loop: {
- # process key
- {
- var c/eax: grapheme <- read-key-from-real-keyboard
- compare c, 4 # ctrl-d
- break-if-= $main:loop
- process c, root, cursor
- }
- # render tree
- root-addr <- lookup root-handle
- render root-addr
- loop
- }
- clear-screen 0
- enable-keyboard-type-mode
- exit-status <- copy 0
-}
-
-#######################################################
-# Tree mutations
-#######################################################
-
-fn process c: grapheme, root: (addr handle cell), cursor: (addr handle cell) {
- # increase depth by 1
- var c1/ecx: (addr handle cell) <- copy cursor
- var c2/eax: (addr cell) <- lookup *c1
- var c3/edx: (addr cell) <- copy c2
- {
- print-string 0, "iter\n"
- var tmp/ebx: (addr handle cell) <- get c3, first-child
- var tmp2/eax: (addr cell) <- lookup *tmp
- compare tmp2, 0
- break-if-=
- c1 <- copy tmp
- c3 <- copy tmp2
- loop
- }
- create-child c3
-}
-
-fn create-child node: (addr cell) {
- var n/ecx: (addr cell) <- copy node
- var first-child/esi: (addr handle cell) <- get n, first-child
- allocate first-child
-}
-
-#######################################################
-# Tree drawing
-#######################################################
-
-fn render root: (addr cell) {
- clear-screen 0
- var depth/eax: int <- tree-depth root
- var viewport-width/ecx: int <- copy 0x64 # col2
- viewport-width <- subtract 5 # col1
- var column-width/eax: int <- try-divide viewport-width, depth
- render-tree root, column-width, 5, 5, 0x20, 0x64
-}
-
-fn render-tree c: (addr cell), column-width: int, row-min: int, col-min: int, row-max: int, col-max: int {
- var root-max/ecx: int <- copy col-min
- root-max <- add column-width
- draw-box row-min, col-min, row-max, root-max
- var c2/eax: (addr cell) <- copy c
- var child/eax: (addr handle cell) <- get c2, first-child
- var child-addr/eax: (addr cell) <- lookup *child
- {
- compare child-addr, 0
- break-if-=
- increment row-min
- decrement row-max
- render-tree child-addr, column-width, row-min, root-max, row-max, col-max
- }
-}
-
-fn tree-depth node-on-stack: (addr cell) -> result/eax: int {
- var tmp-result/edi: int <- copy 0
- var node/eax: (addr cell) <- copy node-on-stack
- var child/ecx: (addr handle cell) <- get node, first-child
- var child-addr/eax: (addr cell) <- lookup *child
- {
- compare child-addr, 0
- break-if-=
- {
- var tmp/eax: int <- tree-depth child-addr
- compare tmp, tmp-result
- break-if-<=
- tmp-result <- copy tmp
- }
- child <- get child-addr, next-sibling
- child-addr <- lookup *child
- loop
- }
- result <- copy tmp-result
- result <- increment
-}
-
-fn draw-box row1: int, col1: int, row2: int, col2: int {
- draw-horizontal-line row1, col1, col2
- draw-vertical-line row1, row2, col1
- draw-horizontal-line row2, col1, col2
- draw-vertical-line row1, row2, col2
-}
-
-fn draw-horizontal-line row: int, col1: int, col2: int {
- var col/eax: int <- copy col1
- move-cursor 0, row, col
- {
- compare col, col2
- break-if->=
- print-string 0, "-"
- col <- increment
- loop
- }
-}
-
-fn draw-vertical-line row1: int, row2: int, col: int {
- var row/eax: int <- copy row1
- {
- compare row, row2
- break-if->=
- move-cursor 0, row, col
- print-string 0, "|"
- row <"""
This page describes functions that plugins may implement to be called from Profanity on certain events. All functions are optional.
Examples:
::
def prof_on_start():
prof.cons_show("Profanity has started...")
def prof_pre_room_message_display(room, nick, message):
prof.cons_show("Manipulating chat room message before display...")
new_message = message + " (added by plugin)"
return new_message
def prof_on_contact_presence(barejid, resource, presence, status, priority):
notify_message = barejid + " is " + presence
prof.notify(notify_message, 5, "Presence")
"""
def prof_init(version, status, account_name, fulljid):
"""Called when a plugin is loaded, either when profanity is started, or when the ``/plugins load`` or ``/plugins install`` commands are called
:param version: the version of Profanity
:param status: the package status of Profanity, ``"development"`` or ``"release"``
:param account_name: account name of the currently logged in account, or ``None`` if not logged in
:param fulljid: the users full Jabber ID (barejid and resource) if logged in, ``None`` otherwise
:type version: str or unicode
:type status: str or unicode
:type account_name: str, unicode or None
:type fulljid: str, unicode or None
"""
pass
def prof_on_start():
"""Called when Profanity is started
"""
pass
def prof_on_shutdown():
"""Called when the user quits Profanity
"""
pass
def prof_on_unload():
"""Called when a plugin is unloaded with the ``/plugins unload`` command
"""
pass
def prof_on_connect(account_name, fulljid):
"""Called when the user connects with an account
:param account_name: account name of the account used for logging in
:param fulljid: the full Jabber ID (barejid and resource) of the account
:type account_name: str or unicode
:type fulljid: str or unicode
"""
pass
def prof_on_disconnect(account_name, fulljid):
"""Called when the user disconnects an account
:param account_name: account name of the account being disconnected
:param fulljid: the full Jabber ID (barejid and resource) of the account
:type account_name: str or unicode
:type fulljid: str or unicode
"""
pass
def prof_pre_chat_message_display(barejid, resource, message):
"""Called before a chat message is displayed
:param barejid: Jabber ID of the message sender
:param resource: resource of the message sender
:param message: the received message
:type barejid: str or unicode
:type resource: str or unicode
:type message: str or unicode
:return: the new message to display, or ``None`` to preserve the original message
:rtype: str or unicode
"""
pass
def prof_post_chat_message_display(barejid, resource, message):
"""Called after a chat message is displayed
:param barejid: Jabber ID of the message sender
:param resource: resource of the message sender
:param message: the received message
:type barejid: str or unicode
:type resource: str or unicode
:type message: str or unicode
"""
pass
def prof_pre_chat_message_send(barejid, message):
"""Called before a chat message is sent
:param barejid: Jabber ID of the message recipient
:param message: the message to be sent
:type barejid: str or unicode
:type message: str or unicode
:return: the modified or original message to send, or ``None`` to cancel sending of the message
:rtype: str or unicode
"""
pass
def prof_post_chat_message_send(barejid, message):
"""Called after a chat message has been sent
:param barejid: Jabber ID of the message recipient
:param message: the sent message
:type barejid: str or unicode
:type message: str or unicode
"""
pass
def prof_pre_room_message_display(barejid, nick, message):
"""Called before a chat room message is displayed
:param barejid: Jabber ID of the room
:param nick: nickname of message sender
:param message: the received message
:type barejid: str or unicode
:type nick: str or unicode
:type message: str or unicode
:return: the new message to display, or ``None`` to preserve the original message
:rtype: str or unicode
"""
pass
def prof_post_room_message_display(barejid, nick, message):
"""Called after a chat room message is displayed
:param barejid: Jabber ID of the room
:param nick: nickname of the message sender
:param message: the received message
:type barejid: str or unicode
:type nick: str or unicode
:type message: str or unicode
"""
pass
def prof_pre_room_message_send(barejid, message):
"""Called before a chat room message is sent
:param barejid: Jabber ID of the room
:param message: the message to be sent
:type barejid: str or unicode
:type message: str or unicode
:return: the modified or original message to send, or ``None`` to cancel sending of the message
:rtype: str or unicode
"""
pass
def prof_post_room_message_send(barejid, message):
"""Called after a chat room message has been sent
:param barejid: Jabber ID of the room
:param message: the sent message
:type barejid: str or unicode
:type message: str or unicode
"""
pass
def prof_on_room_history_message(barejid, nick, message, timestamp):
"""Called when the server sends a chat room history message
:param barejid: Jabber ID of the room
:param nick: nickname of the message sender
:param message: the message to be sent
:param timestamp: time the message was originally sent to the room, in ISO8601 format
:type barejid: str or unicode
:type nick: str or unicode
:type message: str or unicode
:type timestamp: str or unicode
"""
pass
def prof_pre_priv_message_display(barejid, nick, message):
"""Called before a private chat room message is displayed
:param barejid: Jabber ID of the room
:param nick: nickname of message sender
:param message: the received message
:type barejid: str or unicode
:type nick: str or unicode
:type message: str or unicode
:return: the new message to display, or ``None`` to preserve the original message
:rtype: str or unicode
"""
pass
def prof_post_priv_message_display(barejid, nick, message):
"""Called after a private chat room message is displayed
:param barejid: Jabber ID of the room
:param nick: nickname of the message sender
:param message: the received message
:type barejid: str or unicode
:type nick: str or unicode
:type message: str or unicode
"""
pass
def prof_pre_priv_message_send(barejid, nick, message):
"""Called before a private chat room message is sent
:param barejid: Jabber ID of the room
:param nick: nickname of message recipient
:param message: the message to be sent
:type barejid: str or unicode
:type nick: str or unicode
:type message: str or unicode
:return: the modified or original message to send, or ``None`` to cancel sending of the message
:rtype: str or unicode
"""
pass
def prof_post_priv_message_send(barejid, nick, message):
"""Called after a private chat room message has been sent
:param barejid: Jabber ID of the room
:param nick: nickname of the message recipient
:param message: the sent message
:type barejid: str or unicode
:type nick: str or unicode
:type message: str or unicode
"""
pass
def prof_on_message_stanza_send(stanza):
"""Called before an XMPP message stanza is sent
:param stanza: The stanza to send
:type stanza: str or unicode
:return: The new stanza to send, or ``None`` to preserve the original stanza
:rtype: str or unicode
"""
pass
def prof_on_message_stanza_receive(stanza):
"""Called when an XMPP message stanza is received
:param stanza: The stanza received
:type stanza: str or unicode
:return: ``True`` if Profanity should continue to process the message stanza, ``False`` otherwise
:rtype: boolean
"""
pass
def prof_on_presence_stanza_send(stanza):
"""Called before an XMPP presence stanza is sent
:param stanza: The stanza to send
:type stanza: str or unicode
:return: The new stanza to send, or ``None`` to preserve the original stanza
:rtype: str or unicode
"""
pass
def prof_on_presence_stanza_receive(stanza):
"""Called when an XMPP presence stanza is received
:param stanza: The stanza received
:type stanza: str or unicode
:return: ``True`` if Profanity should continue to process the presence stanza, ``False`` otherwise
:rtype: boolean
"""
pass
def prof_on_iq_stanza_send(stanza):
"""Called before an XMPP iq stanza is sent
:param stanza: The stanza to send
:type stanza: str or unicode
:return: The new stanza to send, or ``None`` to preserve the original stanza
:rtype: str or unicode
"""
pass
def prof_on_iq_stanza_receive(stanza):
"""Called when an XMPP iq stanza is received
:param stanza: The stanza received
:type stanza: str or unicode
:return: ``True`` if Profanity should continue to process the iq stanza, ``False`` otherwise
:rtype: boolean
"""
pass
def prof_on_contact_offline(barejid, resource, status):
"""Called when a contact goes offline
:param barejid: Jabber ID of the contact
:param resource: the resource being disconnected
:param status: the status message received with the offline presence, or ``None``
:type barejid: str or unicode
:type resource: str or unicode
:type status: str or unicode
"""
pass
def prof_on_contact_presence(barejid, resource, presence, status, priority):
"""Called when a presence notification is received from a contact
:param barejid: Jabber ID of the contact
:param resource: the resource being disconnected
:param presence: presence of the contact, one of ``"chat"``, ``"online"``, ``"away"``, ``"xa"`` or ``"dnd"``
:param status: the status message received with the presence, or ``None``
:param priority: the priority associated with the resource
:type barejid: str or unicode
:type resource: str or unicode
:type presence: str or unicode
:type status: str or unicode
:type priority: int
"""
pass
def prof_on_chat_win_focus(barejid):
"""Called when a chat window is focussed
:param barejid: Jabber ID of the chat window recipient
:type barejid: str or unicode
"""
pass
def prof_on_room_win_focus(barejid):
"""Called when a chat room window is focussed
:param barejid: Jabber ID of the room
:type barejid: str or unicode
"""
pass
|