Python weechat.buffer_set函数代码示例

def translate_process_cb(data, command, rc, stdout, stderr):
    """Callback reading HTML data from website."""
    global translate
    if stdout != '':
        translate['stdout'] += stdout
    if int(rc) >= 0:
        translated = translate['stdout'].split('"')[1]
        translate['input_before'][0] = weechat.buffer_get_string(weechat.current_buffer(), 'input')
        translate['input_before'][1] = weechat.buffer_get_integer(weechat.current_buffer(), 'input_pos')
        if translate['options']['word']:
            # translate last word of input
            str_input = translate['input_before'][0]
            if str_input:
                pos = str_input.rfind(' ')
                if pos < 0:
                    str_input = translated
                else:
                    str_input = '%s %s' % (str_input[0:pos], translated)
            else:
                str_input = translated
            translate['input_after'][0] = str_input
        else:
            if translate['options']['before_marker']:
                translated = '%s%s' % (translate['options']['before_marker'], translated)
            translate['input_after'][0] = translated
        # set input with translation
        translate['input_after'][1] = len(translate['input_after'][0])
        weechat.buffer_set(weechat.current_buffer(), 'input', translate['input_after'][0])
        weechat.buffer_set(weechat.current_buffer(), 'input_pos', '%d' % translate['input_after'][1])
        translate['hook_process'] = ''
    elif int(rc) == WEECHAT_HOOK_PROCESS_ERROR:
        translate['hook_process'] = ''
    return weechat.WEECHAT_RC_OK

def unhide_buffer_cb(data, signal, signal_data):
    """Unhide a buffer on new activity.

    This callback unhides the buffer in which a new message has been received.
    If configuration option ``unhide_low`` is enabled,
    buffers with only low messages (like JOIN, PART, etc.) will be unhidden as well.
    """
    server = signal.split(",")[0]
    message = weechat.info_get_hashtable(
        "irc_message_parse",
        {"message": signal_data})
    channel = message["channel"]
    hotlist = hotlist_dict()
    buffer = weechat.info_get("irc_buffer", "{},{}".format(server, channel))

    if not buffer in hotlist.keys():
        # just some background noise
        return WEECHAT_RC_OK

    if (weechat.config_get_plugin("unhide_low") == "on"
            and hotlist[buffer]["count_low"] > 0
            or hotlist[buffer]["count_message"] > 0
            or hotlist[buffer]["count_private"] > 0
            or hotlist[buffer]["count_highlight"] > 0):
        weechat.buffer_set(buffer, "hidden", "0")

    return WEECHAT_RC_OK

def scroll_cb(data_ptr, remaining_calls):
    display_fin.pop(0)
    cadena = ''
    for character in display_fin:
        cadena += character
    weechat.buffer_set(weechat.current_buffer(), 'title', cadena)
    return weechat.WEECHAT_RC_OK

def at_completion(data, buffer, command):
    if not config['enable']:
        return weechat.WEECHAT_RC_OK
    
    input = weechat.buffer_get_string(buffer, 'input')
    if input[0] != '/':
        buffer_name = weechat.buffer_get_string(buffer,'name')
        plugin_name = weechat.buffer_get_string(buffer,'plugin')
        # don't nick complete in core
        if plugin_name == 'core': return weechat.WEECHAT_RC_OK
        server_name = buffer_name.split('.')[0]
        if (server_name not in config['servers'] 
           or not check_buffers(buffer_name) ):
           return weechat.WEECHAT_RC_OK
        pos = weechat.buffer_get_integer(buffer, 'input_pos')
        if pos > 0 and (pos == len(input) or input[pos] == ' '):
            n = input.rfind(' ', 0, pos)
            e = input.find(' ',n)
            at = 0
            word = input[n+1:pos]
            if e != n :
              word = word[:e]
            if word[0] == '@':
                word = word[1:]
                at = 1
            nicklist = weechat.infolist_get('nicklist', buffer, '')
            if nicklist:
                nick = walk_nicklist(nicklist,word)
                if nick != "":
                    complete = '%[email protected]%s %s' %(input[:pos-len(word)-at],nick,input[pos:])
                    weechat.buffer_set(buffer, 'input', complete)
                    weechat.buffer_set(buffer, 'input_pos', str(pos - len(word) + len(nick)+2))
                    return weechat.WEECHAT_RC_OK_EAT
    return weechat.WEECHAT_RC_OK

def reorder_buffers():
    """Reorders the buffers once the whitelist has changed
    """

    count = 2
    chan = ""

    ilist = weechat.infolist_get("buffer", "", "")

    for chan in whitelist:
        if -1 == chan.find(".#"): #network name is not set, matching by short_name
            weechat.infolist_reset_item_cursor(ilist)

            while weechat.infolist_next(ilist):
                if weechat.infolist_string(ilist, "short_name") == chan:
                    chan = weechat.infolist_string(ilist, "name")
                    break

        buff = weechat.buffer_search("irc", chan)

        if buff:
            weechat.buffer_set(buff, "number", str(count))
            count += 1

    weechat.infolist_free(ilist)

    return weechat.WEECHAT_RC_OK

def unhide_buffer_cb(data, signal, signal_data):
    """Unhide a buffer on new activity.

    This callback unhides a buffer in which a new message has been received.
    If configuration option ``unhide_low`` is enabled,
    buffers with only low priority messages (like JOIN, PART, etc.) will be unhidden as well.

    :param data: Pointer
    :param signal: Signal sent by Weechat
    :param signal_data: Data sent with signal
    :returns: Callback return value expected by Weechat.
    """
    hotlist = hotlist_dict()
    line_data = weechat.hdata_pointer(weechat.hdata_get('line'), signal_data, 'data')
    buffer = weechat.hdata_pointer(weechat.hdata_get('line_data'), line_data, 'buffer')

    if not buffer in hotlist.keys():
        # just some background noise
        return WEECHAT_RC_OK

    if (weechat.config_get_plugin("unhide_low") == "on"
            and hotlist[buffer]["count_low"] > 0
            or hotlist[buffer]["count_message"] > 0
            or hotlist[buffer]["count_private"] > 0
            or hotlist[buffer]["count_highlight"] > 0):
        remove_keep_alive(buffer)
        weechat.buffer_set(buffer, "hidden", "0")

    return WEECHAT_RC_OK

def word_magic(data, buffer, command):
    # get the input string
    uinput = w.buffer_get_string(buffer, "input")

    # if the buffer is blacklisted, do nothing
    if w.buffer_get_string(buffer, "short_name") in w.config_get_plugin(
            "blacklist_buffers").split(","):
        return w.WEECHAT_RC_OK

    if command == "/input return":
        # in case the line's empty, do nothing
        if uinput == "":
            return w.WEECHAT_RC_OK
        # bypass this using a backslash as the first character
        elif uinput.startswith("\\"):
            uinput = uinput.replace("\\", "", 1)
        # we don't want to capitalize basic URLs
        elif uinput[:4] == "http": # I'M TOO LAZY FOR REGEX MATCHING
            return w.WEECHAT_RC_OK
        # if we point to a user, don't capitalise this
        elif isnick(buffer, uinput.split()[0][:-1]):
            return w.WEECHAT_RC_OK
        # if everything else is fine, replace the first char with its capital
        else:
            uinput = uinput.replace(uinput[0], uinput[0].upper(), 1)
        # set the new string into the input
        w.buffer_set(buffer, "input", uinput)
    return w.WEECHAT_RC_OK

def unread_buffer_cb(data, buffer, args):

    arguments = args.lower().split(' ')
    if not len(arguments) == 2:
        return weechat.WEECHAT_RC_OK

    if arguments[0] == 'low':
        priority = "0"
    elif arguments[0] == 'message':
        priority = "1"
    elif arguments[0] == 'private':
        priority = "2"
    elif arguments[0] == 'highlight':
        priority = "3"
    elif arguments[0] == 'remove':
        priority = "-1"
    else:
        return weechat.WEECHAT_RC_OK
    # search for either buffer_name or buffer_number
    ptr_buffer = buffer_infolist(arguments[1])

    weechat.buffer_set(ptr_buffer, "hotlist", "-1")
    weechat.buffer_set(ptr_buffer, "hotlist", priority)

    return weechat.WEECHAT_RC_OK

def switch_current_buffer():
    """Save current buffer and ensure that it's visible, then if the
    buffer is elegible to be hidden, we add it to the list of the buffers
    to be hidden after a delay
    """
    global CURRENT_BUFFER
    global CURRENT_BUFFER_TIMER_HOOK

    previous_buffer = CURRENT_BUFFER
    CURRENT_BUFFER = weechat.current_buffer()

    if previous_buffer == CURRENT_BUFFER:
        return

    if weechat.buffer_get_integer(CURRENT_BUFFER, "hidden") == 1:
        weechat.buffer_set(CURRENT_BUFFER, "hidden", "0")

    if weechat.config_get_plugin("keep_open") != "off":
        if CURRENT_BUFFER_TIMER_HOOK is not None:
            weechat.unhook(CURRENT_BUFFER_TIMER_HOOK)
            CURRENT_BUFFER_TIMER_HOOK = None
            maybe_hide_buffer(previous_buffer)
        else:
            keep_alive_buffer(previous_buffer)

        CURRENT_BUFFER_TIMER_HOOK = weechat.hook_timer(MINIMUM_BUFFER_LIFE, 0, 1,
            "on_current_buffer_is_still_active_timeout", "")
    else:
        maybe_hide_buffer(previous_buffer)

def command_run_input(data, buffer, command):
    """ Function called when a command "/input xxxx" is run """
    if command == "/input return":  # As in enter was pressed.

        # Get input contents
        input_s = w.buffer_get_string(buffer, "input")

        # Skip modification of settings
        if input_s.startswith("/set "):
            return w.WEECHAT_RC_OK

        # Iterate transformation pairs
        for replace_item in w.config_get_plugin("replacement_pairs").split(","):
            if replace_item:
                orig, replaced = replace_item.split("=")
                input_s = input_s.replace(orig, replaced)
        # Iterate words
        for replace_item in w.config_get_plugin("replacement_words").split(","):
            if replace_item:
                orig, replaced = replace_item.split("=")
                # Search for whitespace+word+whitespace and replace the word
                input_s = re.sub("(\s+|^)%s(\s+|$)" % orig, "\\1%s\\2" % replaced, input_s)

        # Spit it out
        w.buffer_set(buffer, "input", input_s)
    return w.WEECHAT_RC_OK

 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 all_cmd_cb(data, buffer, args):
	''' Command /all '''
	translate_input = args
	if not translate_input:
	   translate_input = weechat.buffer_get_string(buffer, "input")

	channel = weechat.buffer_get_string(buffer, 'localvar_channel')
	server = weechat.buffer_get_string(buffer, 'localvar_server')

	joined_nick=""
	infolist = weechat.infolist_get("irc_nick", "", server+","+channel)
	if infolist:
		while weechat.infolist_next(infolist):
			name = weechat.infolist_string(infolist, "name")
			weechat.prnt("", "buffer: %s" % name)
			joined_nick += name+" "

		weechat.infolist_free(infolist)

	translate_input=joined_nick +": "+ translate_input
	
	#outstring = translate_input.encode('UTF-8')
	outstring = translate_input
	weechat.buffer_set(buffer, 'input', outstring)
	weechat.buffer_set(buffer, 'input_pos', '%d' % len(outstring))
	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 input_delete_cb(data, signal, signal_data):
    buffer = signal
    delete_localvar_replace_mode(buffer)
    weechat.buffer_set(buffer, 'localvar_del_spell_correction_suggest_item', '')
    weechat.buffer_set(buffer, 'localvar_del_spell_correction_suggest_input_line', '')
    weechat.bar_item_update('spell_correction')
    return weechat.WEECHAT_RC_OK

def command_run_input(data, buffer, command):
    """ Function called when a command "/input xxxx" is run """
    if command == "/input return":  # As in enter was pressed.

        # Get input contents
        input_s = w.buffer_get_string(buffer, 'input')

        # Skip modification of settings
        if input_s.startswith('/'):
            return w.WEECHAT_RC_OK

        yubistring = w.config_get_plugin('yubistring')

        if yubistring != '':

            # if it's longer than 6 characters, chop it down.
            if len(yubistring) > 6:
                yubistring = yubistring[:6]

            if input_s.startswith(yubistring) and len(input_s) == 44:
                input_s = ''

        # Spit it out
        w.buffer_set(buffer, 'input', input_s)
    return w.WEECHAT_RC_OK