Python weechat.buffer_new函数代码示例

def hilightCheckBuffer( signal, pointer ):
    global bufferpointer
    if pointer == bufferpointer:
        weechat.prnt("", "Alright, who closed the buffer?!?!")
        weechat.buffer_new( weechat.config_get_plugin('buffer_out'), "", "" )
        bufferpointer = weechat.buffer_search( "python", weechat.config_get_plugin('buffer_out'))

    return weechat.WEECHAT_RC_OK

def renderConversations(unused, command, return_code, out, err):
    global conversation_map
    global conv

    if return_code == weechat.WEECHAT_HOOK_PROCESS_ERROR:
        weechat.prnt("", "Error with command '%s'" % command)
        return weechat.WEECHAT_RC_OK
    if return_code > 0:
        weechat.prnt("", "return_code = %d" % return_code)
    if out != '':
        conv += out
        if return_code == weechat.WEECHAT_HOOK_PROCESS_RUNNING:
            weechat.prnt('', 'getting more data')
            return weechat.WEECHAT_RC_OK
    if err != "":
        weechat.prnt("", "stderr: %s" % err)
        return weechat.WEECHAT_RC_OK

    try:
        conversations = reversed(cPickle.loads(conv))
    except EOFError:
        weechat.prnt('', 'wtrecv returned garbage')
        return weechat.WEECHAT_RC_OK

    for conversation in conversations:
        if not conversation.conv_id in conversation_map:
            conversation_map[conversation.conv_id] = conversation
            msgs = conversation.messages
        else:
            old = conversation_map[conversation.conv_id]
            conversation_map[conversation.conv_id] = conversation
            msgs = old.new_messages(conversation)
        for msg in msgs:
            if not conversation.number in number_map and msg['from'] != 'Me:':
                number_map[conversation.number] = msg['from']
        for msg in msgs:
            if conversation.number in number_map:
                buf = weechat.buffer_search('python', number_map[conversation.number][:-1])
                if not buf:
                    buf = weechat.buffer_new(number_map[conversation.number][:-1],
                                             "textOut", "", "buffer_close_cb", "")
            else:
                buf = weechat.buffer_search('python', 'Me')
                if not buf:
                    buf = weechat.buffer_new('Me', "textOut", "", "buffer_close_cb", "")
            if weechat.config_get_plugin('encrypt_sms') == 'True':
                msg['text'] = decrypt(msg['text'], buf)
            nick = msg['from'][:-1].strip()
            tags = 'notify_private,nick_' + msg['from'][:-1].strip()
            tags += ',log1,prefix_nick_' + weechat.info_get('irc_nick_color_name', nick)
            nick = msg['from'][:-1].strip()
            weechat.prnt_date_tags(buf, 0, tags, '\x03' + weechat.info_get('irc_nick_color', nick)
                                   + nick + '\t' + msg['text'])
    conv = ''
    callGV()
    return weechat.WEECHAT_RC_OK

def gvOut(data, buf, input_data):
    if input_data[:4] == 'text' and buf == weechat.buffer_search('python', 'weeText'):
        buffer = weechat.buffer_new("+1"+input_data[5:], "textOut", "", "buffer_close_cb", "")
    if input_data[:5] == 'multi' and buf == weechat.buffer_search('python', 'weeText'):
        num_list = input_data[6:].split(',')
        nums = ''
        for num in num_list:
            nums += '+' + num[-4:]
        nums = nums[1:]
        buffer = weechat.buffer_new('m:' + nums, "multiText", input_data[6:], "buffer_close_cb", "")
    return weechat.WEECHAT_RC_OK

def weecat_command_cb(data, buffer, args):
    global weecat_buffers, cmds_by_buffer, listen_hooks

    try:
        this_file = open(args)
    except IOError as e:
        weechat.prnt("", weechat.prefix("error") + "weecat: " + e.strerror)
        return weechat.WEECHAT_RC_ERROR

    filename = this_file.name

    if not args in listen_hooks:
        new_buffer = weechat.buffer_new(
                "wc: " + filename,
                "weecat_input_cb", "",
                "weecat_close_cb", ""
                )

        weechat.buffer_set(new_buffer, "title",
                "weecat: " + filename)

        weechat.hook_signal_send("logger_backlog",
                weechat.WEECHAT_HOOK_SIGNAL_POINTER, new_buffer)

        listen_hooks[filename] = weechat.hook_fd(this_file.fileno(), 1, 0, 0, "weecat_update_cb", new_buffer)

        weechat.buffer_set(new_buffer, "display", "1") # switch to it

        weecat_buffers.add(new_buffer)
        files_by_buffer[new_buffer] = this_file

    return weechat.WEECHAT_RC_OK

def rooms_create_buffer(bitlbee_server):
    global rooms_buffer, rooms_curline

    if not rooms_buffer:
        rooms_buffer = weechat.buffer_new("hipchat_rooms", "rooms_input_cb",
                                          "", "rooms_close_cb", "")
        rooms_set_buffer_title()
        # Sets notify to 0 as this buffer does not need to be in hotlist.
        weechat.buffer_set(rooms_buffer, "notify", "0")
        weechat.buffer_set(rooms_buffer, "nicklist", "0")
        weechat.buffer_set(rooms_buffer, "type", "free")
        weechat.buffer_set(rooms_buffer, "key_bind_ctrl-L", "/hipchat rooms **refresh")
        weechat.buffer_set(rooms_buffer, "key_bind_meta2-A", "/hipchat rooms **up")
        weechat.buffer_set(rooms_buffer, "key_bind_meta2-B", "/hipchat rooms **down")
        weechat.buffer_set(rooms_buffer, "key_bind_meta2-1~", "/hipchat rooms **scroll_top")
        weechat.buffer_set(rooms_buffer, "key_bind_meta2-4~", "/hipchat rooms **scroll_bottom")
        weechat.buffer_set(rooms_buffer, "key_bind_meta-ctrl-J", "/hipchat rooms **enter")
        weechat.buffer_set(rooms_buffer, "key_bind_meta-ctrl-M", "/hipchat rooms **enter")
        weechat.buffer_set(rooms_buffer, "key_bind_meta->", "/hipchat rooms **sort_next")
        weechat.buffer_set(rooms_buffer, "key_bind_meta-<", "/hipchat rooms **sort_previous")
        weechat.buffer_set(rooms_buffer, "key_bind_meta-/", "/hipchat rooms **sort_invert")
        weechat.buffer_set(rooms_buffer, "localvar_set_bitlbee_server", bitlbee_server)
        rooms_curline = 0
    if weechat.config_get_plugin("autofocus") == "on":
        if not weechat.window_search_with_buffer(rooms_buffer):
            weechat.command("", "/buffer " + weechat.buffer_get_string(rooms_buffer, "name"))

    def playlistinfo(self, sortkey='pos'):
        """Shows playlist information sorted by key
        """
        new_buf = wc.buffer_search("", "mpc: playlist")
        if len(new_buf) == 0:
            new_buf = wc.buffer_new('mpc: playlist', "", "", "", "")

        pl = self._mpdc.playlistinfo()
        try:
            # Numerical sort
            spl = sorted(pl,
                         cmp=lambda x,y: cmp(int(x), int(y)),
                         key=itemgetter(sortkey))
        except ValueError:
            # Alpha sort
            lcmp = lambda x,y: cmp(x.lower(), y.lower())
            spl = sorted(pl,
                         cmp=lambda x,y: cmp(x.lower(), y.lower()),
                         key=itemgetter(sortkey))

        t = Template(wc.config_get_plugin("playinfo"))
        for line in spl:
            wc.prnt(new_buf, t.safe_substitute(line))

        return pl

def lb_create_buffer():
  global lb_buffer, lb_curline

  if not lb_buffer:
    lb_buffer = weechat.buffer_new("listbuffer", "lb_input_cb", \
                "", "lb_close_cb", "")
    weechat.buffer_set(lb_buffer, "title", lb_line_format({
      'channel': 'Channel name',
      'users': 'Users',
      'modes': 'Modes',
      'topic': 'Topic',
      'nomodes': None,
    }))
    # Sets notify to 0 as this buffer does not need to be in hotlist.
    weechat.buffer_set(lb_buffer, "notify", "0")
    weechat.buffer_set(lb_buffer, "nicklist", "0")
    weechat.buffer_set(lb_buffer, "type", "free")
    weechat.buffer_set(lb_buffer, "key_bind_ctrl-L", "/listbuffer **refresh")
    weechat.buffer_set(lb_buffer, "key_bind_meta2-A", "/listbuffer **up")
    weechat.buffer_set(lb_buffer, "key_bind_meta2-B", "/listbuffer **down")
    weechat.buffer_set(lb_buffer, "key_bind_meta2-1~", "/listbuffer **scroll_top")
    weechat.buffer_set(lb_buffer, "key_bind_meta2-4~", "/listbuffer **scroll_bottom")
    weechat.buffer_set(lb_buffer, "key_bind_meta-ctrl-J", "/listbuffer **enter")
    weechat.buffer_set(lb_buffer, "key_bind_meta-ctrl-M", "/listbuffer **enter")
    weechat.buffer_set(lb_buffer, "key_bind_meta->", "/listbuffer **sort_next")
    weechat.buffer_set(lb_buffer, "key_bind_meta-<", "/listbuffer **sort_previous")
    weechat.buffer_set(lb_buffer, "key_bind_meta-/", "/listbuffer **sort_invert")
    lb_curline = 0
  if weechat.config_get_plugin("autofocus") == "on":
    if not weechat.window_search_with_buffer(lb_buffer):
      weechat.command("", "/buffer " + weechat.buffer_get_string(lb_buffer,"name"))

 def create_buffer(self):
     channel_buffer = w.buffer_search("", "%s.%s" % (self.server.domain, self.name))
     if channel_buffer:
         self.channel_buffer = channel_buffer
     else:
         self.channel_buffer = w.buffer_new("%s.%s" % (self.server.domain, self.name), "buffer_input_cb", self.name, "", "")
         w.buffer_set(self.channel_buffer, "short_name", 'loading..')

def minesweeper_init():
    """Init minesweeper: create buffer, adjust zoom, new game."""
    global minesweeper
    if minesweeper['buffer']:
        return
    minesweeper['buffer'] = weechat.buffer_search('python', 'minesweeper')
    if not minesweeper['buffer']:
        minesweeper['buffer'] = weechat.buffer_new('minesweeper', 'minesweeper_input_buffer', '', 'minesweeper_close_buffer', '')
        if minesweeper['buffer']:
            weechat.buffer_set(minesweeper['buffer'], 'type', 'free')
            weechat.buffer_set(minesweeper['buffer'], 'title',
                               'Minesweeper! | alt-space or mouse-b1: explore, alt-f or mouse-b2: flag, alt-n: new game, '
                               'alt-+/-: adjust board zoom | '
                               'Command line: (n)ew, +/-: change size, (q)uit')
            weechat.buffer_set(minesweeper['buffer'], 'key_bind_meta2-A', '/minesweeper up')
            weechat.buffer_set(minesweeper['buffer'], 'key_bind_meta2-B', '/minesweeper down')
            weechat.buffer_set(minesweeper['buffer'], 'key_bind_meta2-D', '/minesweeper left')
            weechat.buffer_set(minesweeper['buffer'], 'key_bind_meta2-C', '/minesweeper right')
            weechat.buffer_set(minesweeper['buffer'], 'key_bind_meta-f',  '/minesweeper flag')
            weechat.buffer_set(minesweeper['buffer'], 'key_bind_meta- ',  '/minesweeper explore')
            weechat.buffer_set(minesweeper['buffer'], 'key_bind_meta-n',  '/minesweeper new')
            weechat.buffer_set(minesweeper['buffer'], 'key_bind_meta-+',  '/minesweeper zoom')
            weechat.buffer_set(minesweeper['buffer'], 'key_bind_meta--',  '/minesweeper dezoom')
            weechat.buffer_set(minesweeper['buffer'], 'key_bind_meta-c',  '/minesweeper cheat')
    if minesweeper['buffer']:
        minesweeper_adjust_zoom()
        minesweeper_new_game()

def samegame_init():
    """Init samegame: create buffer, adjust zoom, new game."""
    global samegame, samegame_settings
    if samegame["buffer"]:
        return
    samegame["buffer"] = weechat.buffer_search("python", "samegame")
    if not samegame["buffer"]:
        samegame["buffer"] = weechat.buffer_new("samegame", "samegame_input_buffer", "", "samegame_close_buffer", "")
        if samegame["buffer"]:
            weechat.buffer_set(samegame["buffer"], "type", "free")
            weechat.buffer_set(
                samegame["buffer"],
                "title",
                "Samegame | mouse: play, alt-n: new game, alt-+/-: adjust board zoom, alt-u: undo | "
                "Command line: (n)ew, +/-: change size, (q)uit, 3-6: number of colors",
            )
            weechat.buffer_set(samegame["buffer"], "key_bind_meta-n", "/samegame new")
            weechat.buffer_set(samegame["buffer"], "key_bind_meta-+", "/samegame zoom")
            weechat.buffer_set(samegame["buffer"], "key_bind_meta--", "/samegame dezoom")
            weechat.buffer_set(samegame["buffer"], "key_bind_meta-u", "/samegame undo")
    try:
        samegame["numcolors"] = int(samegame_settings["numcolors"])
    except:
        pass
    if samegame["numcolors"] < 3:
        samegame["numcolors"] = 3
    if samegame["numcolors"] > 6:
        samegame["numcolors"] = 6
    if samegame["buffer"]:
        samegame_adjust_zoom()
        samegame_new_game()

def help_cb(data, buffer, args):
    global help_buf
    if help_buf is None:
        help_buf = weechat.buffer_new("vimode", '', '', "help_closed_cb", '')
    buf_num = weechat.buffer_get_integer(help_buf, "number")
    weechat.command('', "/buffer %s" % buf_num)
    weechat.prnt(help_buf, help_text)
    return weechat.WEECHAT_RC_OK

def create_slack_debug_buffer():
    global slack_debug, debug_string
    if slack_debug != None:
        w.buffer_set(slack_debug, "display", "1")
    else:
        debug_string = None
        slack_debug = w.buffer_new("slack-debug", "", "", "closed_slack_debug_buffer_cb", "")
        w.buffer_set(slack_debug, "notify", "0")

 def __init__(self, server, login = None, fd = None) :
     self.server = server
     self.login = login
     self.fd = fd
     self.buffer = weechat.buffer_new('Netsoul.temp', 'weeNS_buffer_input_cb', '', 'weeNS_buffer_close_cb', '')
     weechat.buffer_set(self.buffer, "display", "auto")
     self.updateBuffer(login)
     self.server.chats.append(self)

def setup_viola_weechat_buffers():
    """Initialize the viola control panel and debug buffers."""
    global VIOLA_DEBUG_BUFFER
    global VIOLA_CONTROL_BUFFER

    if not VIOLA_CONTROL_BUFFER:
        VIOLA_CONTROL_BUFFER = weechat.buffer_new(otrlib.colorize("Viola Control Panel", "yellow"),
                                                                  "", "",
                                                                  "debug_buffer_close_cb", "")

        weechat.buffer_set(VIOLA_CONTROL_BUFFER, 'title', 'Viola Control Messages')

        weechat.buffer_set(VIOLA_CONTROL_BUFFER, 'localvar_set_no_log', '1')

    if not VIOLA_DEBUG_BUFFER:
        VIOLA_DEBUG_BUFFER = weechat.buffer_new("Viola Debug", "", "",
                                              "debug_buffer_close_cb", "")
        weechat.buffer_set(VIOLA_DEBUG_BUFFER, 'title', 'Viola Debug')
        weechat.buffer_set(VIOLA_DEBUG_BUFFER, 'localvar_set_no_log', '1')

def setup_flute_weechat_buffers():
    """Initialize the flute control panel and debug buffers."""
    global FLUTE_DEBUG_BUFFER
    global FLUTE_CONTROL_BUFFER

    if not FLUTE_CONTROL_BUFFER:
        FLUTE_CONTROL_BUFFER = weechat.buffer_new(otrlib.colorize("Flute Control Panel", "yellow"),
                                                                  "", "",
                                                                  "debug_buffer_close_cb", "")

        weechat.buffer_set(FLUTE_CONTROL_BUFFER, 'title', 'Flute Control Messages')

        weechat.buffer_set(FLUTE_CONTROL_BUFFER, 'localvar_set_no_log', '1')

    if not FLUTE_DEBUG_BUFFER:
        FLUTE_DEBUG_BUFFER = weechat.buffer_new("Flute Debug", "", "",
                                              "debug_buffer_close_cb", "")
        weechat.buffer_set(FLUTE_DEBUG_BUFFER, 'title', 'Flute Debug')
        weechat.buffer_set(FLUTE_DEBUG_BUFFER, 'localvar_set_no_log', '1')