Perl updates. Lots of updates to perl documentation :)

git-svn-id: http://svn.irssi.org/repos/irssi/trunk@1081 dbcabf3a-b0e7-0310-adc4-f8d773084564

1 files changed, 625 insertions, 338 deletions

diff --git a/docs/perl.txt b/docs/perl.txt
index 4ebbdaed..1976fee7 100644
--- a/docs/perl.txt
+++ b/docs/perl.txt
@@ -1,89 +1,104 @@
  Running Perl scripts
  --------------------
 
-FIXME: part of this file is out of date..
-UPDATE: 0.7.96 - this is even yet more out of date ;) See scripts in
-samples/ directory, they'll help you get started :)
+First you'll need to have Perl support on. By default irssi compiles
+Perl as a module, so /LOAD perl probably helps. After that you can run
+scripts with /RUN script (you don't need to give the .pl extension). If
+/RUN complains about "unknown command", you don't have Perl module
+loaded, or maybe Perl support wasn't compiled at all.
 
-Place new scripts to ~/.irssi/scripts/, or /usr/lib/irssi/scripts/
-directory and run then with /RUN script. Or you could also run the
-script from another place by specifying the whole path to it. Scripts
-in ~/.irssi/scripts/autorun/ directory are automatically run at
-startup.
+Place new scripts to ~/.irssi/scripts/ or /usr/local/lib/irssi/scripts/
+directory. Scripts in ~/.irssi/scripts/autorun/ directory are
+automatically run at startup.
 
 Using /PERLFLUSH closes and reopens the perl interpreter removing all
-Perl scripts from memory. There's currently no way to unload a single Perl
-script. Also, Irssi doesn't check if you run the same script twice or
-different scripts use signal_add() for the same named function - it will
-probably crash or do some weird things then.
+Perl scripts from memory. There's currently no way to unload a single
+Perl script (/SCRIPT REMOVE will probably work soon). You can however
+run same script multiple times, and irssi will remove the old version
+from memory before running the new version.
 
 
  Irssi's signals
  ---------------
 
 Irssi is pretty much based on sending and handling different signals.
-Like when you receive a message from server, say,
-":nick!user@there.org PRIVMSG you :blahblah". Irssi will first send a
-"server incoming" signal with the raw line as it's first parameter. You
-probably don't want to use this signal. Next thing Irssi does is to
-interpret the header and send a "server event" signal with arguments
-"PRIVMSG you...", server, "nick", "user@there.org". You probably don't
-want to use this either, since next irssi will send an "event privmsg"
-signal with the "you :blahblah" as it's argument. You can at any point
-grab the signal, do whatever you want to do with it and optionally stop
-it from going any further by returning from the function with value 1. 
+Like when you receive a message from server, say
+
+  :nick!user@there.org PRIVMSG you :blahblah
+
+Irssi will first send a signal:
+
+  "server incoming", SERVER_REC, "nick!user@there PRIVMSG ..."
+
+You probably don't want to use this signal. Default handler for this
+signal interprets the header and sends a signal:
+
+  "server event", SERVER_REC, "PRIVMSG ...", "nick", "user@there.org"
+
+You probably don't want to use this either, since this signal's default
+handler parses the event string and sends a signal:
+
+  "event privmsg", SERVER_REC, "you :blahblah", "nick", "user@there.org"
+
+You can at any point grab the signal, do whatever you want to do with
+it and optionally stop it from going any further by calling
+Irssi::signal_stop();
 
 For example:
 
 --------------------------------------------------------
 sub event_privmsg {
-	# $data = "nick/#channel :text"
-	my ($data, $server, $nick, $address) = @_;
-	my ($target, $text) = $data =~ /^(\S*)\s:(.*)/;
+  # $data = "nick/#channel :text"
+  my ($server, $data, $nick, $address) = @_;
+  my ($target, $text) = split(/ :/, $data, 2);
 
-	return 1 if ($text =~ /free.*porn/);
-	return 1 if ($nick =~ /idiot/);
+  Irssi::signal_stop() if ($text =~ /free.*porn/ || $nick =~ /idiot/);
 }
 
 Irssi::signal_add("event privmsg", "event_privmsg")
 --------------------------------------------------------
 
 This will hide all public or private messages that match the regexp
-"free.*porn" or the sender's nick contain the word "idiot".
+"free.*porn" or the sender's nick contain the word "idiot". Yes, you
+could use /IGNORE instead for both of these :)
 
 You can also use signal_add_last() if you wish to let the Irssi's internal
 functions be run before yours.
 
-A list of signals that irssi send can be found from SIGNALS file.
+A list of signals that irssi send can be found from signals.txt file.
 
 
  Message levels
  --------------
 
-Several functions expect message levels. Sometimes numeric and sometimes
-alphabetic. Yes, it's stupid, will fix it :) For now you can use 
-Irssi::level2bits() function to convert the level string to numeric. Here's
-all the levels that irssi supports currently:
+Several functions expect message levels. They're used to roughly
+classify messages. They're used by a lot of things including logging,
+ignoring, highlighting, etc. so you should use as good level as
+possible. It's possible to have several levels in one message, like
+ACTIONS+PUBLIC or ACTIONS+MSGS.
 
-CRAP, MSGS, PUBLIC, NOTICES, SNOTES, CTCPS, ACTIONS, JOINS, PARTS
-QUITS, KICKS, MODES, SMODES, TOPICS, WALLOPS, INVITES, NICKS, PONGS
-DCC, CLIENTNOTICE, CLIENTCRAP, CLIENTERROR, HILIGHT
-(and NOHILIGHT if you don't want the message to be hilighted ever..)
+Here's all the levels that irssi supports currently:
 
-For example:
+  CRAP, MSGS, PUBLIC, NOTICES, SNOTES, CTCPS, ACTIONS, JOINS, PARTS
+  QUITS, KICKS, MODES, TOPICS, WALLOPS, INVITES, NICKS, DCC, DCCMSGS,
+  CLIENTNOTICE, CLIENTCRAP, CLIENTERROR
 
-$server->printtext("#channel", Irssi::level2bits('clientcrap'), 'Hello, world');
+And a few special ones that could be included with the levels above:
 
-Writes text to #channel window with clientcrap level.
+  HILIGHT - message is highlighted
+  NOHILIGHT - don't check highlighting from message
+  NO_ACT - don't trigger channel activity when printing this message
+  NEVER - never ignore or log this message (not a good idea usually)
 
+You can use them with a MSGLEVEL_ prefix, for example:
 
- Functions that you can use in Irssi's Perl scripts
- --------------------------------------------------
+  $server->print("#channel", 'Hello, world', MSGLEVEL_CLIENTCRAP);
+
+Writes text to #channel window with CLIENTCRAP level.
 
-This is just my very first implementation and things will probably change.
 
-Commands marked with (!!) mean that you shouldn't use it unless you
-know what you're doing..
+ Functions that you can use in Irssi's Perl scripts
+ --------------------------------------------------
 
 If there's a "Xxxx::" text before the command, it means that it belongs to
 that package. Like "Server::command" means that you should either call it as
@@ -93,200 +108,359 @@ or more easily:
 
 Commands that don't have the Xxxx prefix are called as Irssi::command();
 
+Information from most objects can be fetched with $object->{data}, for
+example current nick in server could be read with $server->{nick}. List
+of all the information that are in objects are in "Object->{}" sections
+below.
+
+Commands are split in two groups, generic ones that could be used with
+any chat protocol, and IRC specific commands, you'll need to put
+"use Irssi::Irc;" to your scripts. IRC specific commands are listed
+after the generic ones.
+
 
  *** General
 
-Window active_win() - return current window
-Server active_server() - return current server
+Window active_win() - return active window
+Server active_server() - return server in active window
 
-channels() - return list of all channels
+windows() - return list of all windows
 servers() - return list of all servers
+reconnects() - return list of all server reconnections
+channels() - return list of all channels
+queries() - return list of all queries
 commands() - return list of all commands
-dccs() - return list of all dcc connections
 logs() - return list of all log files
+ignores() - returns list of all ignores
 
-print(str, [level])
-  Print `str' to some window (status/current probably), default level is
-  "Irssi notice".
+Server::channels() - return list of channels in server
+Server::queries() - return list of queries in server
 
-print_window(str, [level])
-  Print `str' to current window, default level is "Irssi notice".
+print(str[, level])
+Server::print(channel, str[, level])
+Window::print(str[, level])
+Windowitem::print(str[, level])
+  Print `str'. Default level is MSGLEVEL_CLIENTNOTICE.
 
-command(cmd, [Server server, [Channel channel]])
+command(cmd)
+Server::command(cmd)
+Window::command(cmd)
+Windowitem::command(cmd)
   Send a command `cmd' (in current channel). This will work just as if you
   had typed `cmd' in command line, so you'll need to use /COMMANDS or the
   text will be sent to the channel.
 
-Server::command(cmd, [Channel channel])
   Just like above, except different calling method.
 
-Channel::command(cmd)
-  Just like above, except different calling method.
 
-Server::printtext(channel, level, str)
-  Print `str'.
+ *** Themes
 
-setup_get(option)
-  Get value of `option' from setup and return it.
+You can have user configurable texts in scripts that work just like
+irssi's internal texts that can be changed in themes.
 
+First you'll have to register the formats:
 
- *** Message levels
+Irssi::theme_register([
+  'format_name', '{hilight my perl format!}',
+  'format2', 'testing.. nick = $0, channel = $1'
+]);
 
-level2bits(level)
-  Level string -> number
+Printing happens with one of the functions:
 
-bits2level(bits)
-  Level number -> string
+printformat(level, format, ...)
+Window::printformat(level, format, ...)
+Server::printformat(target, level, format, ...)
+Windowitem::printformat(level, format, ...)
 
-combine_level(level, str)
-  Combine level number to level string ("+level -level").
-  Return new level number.
+For example:
+
+  $channel->printformat(MSGLEVEL_CRAP, 'format2',
+		        'nick', $channel->{name});
+
+
+ *** Settings
 
+settings_get_str(key)
+settings_get_int(key)
+settings_get_bool(key)
+  Return value for setting.
 
- *** Signals / timeouts
+settings_add_str(section, key, def)
+settings_add_int(section, key, def)
+settings_add_bool(section, key, def)
+  Create new setting.
+
+settings_remove(key)
+  Remove a setting.
+
+
+ *** Signals
 
 signal_emit(signal, ...)
-  Send signal `signal'
+  Send signal `signal'. You can give 6 parameters at maximum.
 
 signal_add(signal, func)
-  Bind `signal' to function `func'
+  Bind `signal' to function `func'.
+
+signal_add_first(signal, func)
+  Bind `signal' to function `func'. Call `func' as soon as possible.
 
 signal_add_last(signal, func)
   Bind `signal' to function `func'. Call `func' as late as possible.
 
 signal_remove(signal, func)
-  Unbind `signal' from function `func'
+  Unbind `signal' from function `func'.
 
-tag timeout_add(msecs, func, data)
+signal_stop()
+  Stop the signal that's currently being emitted.
+
+signal_stop_by_name(signal)
+  Stop the signal with name `signal' that's currently being emitted.
+
+
+  *** timeouts / IO listener
+
+timeout_add(msecs, func, data)
   Call `func' every `msecs' milliseconds (1000 = 1 second) with
   parameter `data'. Returns tag which can be used to stop the timeout.
 
 timeout_remove(tag)
   Remove timeout with tag.
 
+input_add(source, condition, func, data)
+  Call `func' with parameter `data' when specified IO happens.
+  `source' is the file handle that is being listened. `condition' can
+  be INPUT_READ, INPUT_WRITE or both. Returns tag which can be used to
+  remove the listener.
+
+input_remove(tag)
+  Remove listener with tag.
+
+
+ *** Message levels
+
+level2bits(level)
+  Level string -> number
+
+bits2level(bits)
+  Level number -> string
+
+combine_level(level, str)
+  Combine level number to level string ("+level -level").
+  Return new level number.
+
 
  *** Commands
 
-Command::values()
-  Get some information about command. This function returns a reference to
-  hash table. Hash table has keys:
-	"cmd" - Command
-	"category" - Category
+Command->{}:
+  cmd - Command name
+  category - Category
 
-command_bind(cmd, category, func)
+command_bind(cmd, func[, category])
   Bind command `cmd' to call function `func'. `category' is the
   category where the command is displayed in /HELP.
 
 command_unbind(cmd, func)
   Unbind command `cmd' from function 'func.
 
-Server::irc_send_cmd_split(cmd, arg, max_nicks)
-  Split the `cmd' into several commands so `arg' argument has only
-  `max_nicks' number of nicks.
 
-  Example: $server->irc_send_cmd_split("KICK #channel nick1,nick2,nick3 :byebye", 2, 2);
-  Irssi will send commands "KICK #channel nick1,nick2 :byebye" and
-  "KICK #channel nick3 :byebye" to server.
+ *** Windows
+
+Window::items()
+  Return a list of items in window.
+
+Window
+window_create(automatic)
+Windowitem::window_create(automatic)
+  Create a new window.
+
+Window::destroy()
+  Destroy the window.
+
+Irssi::Window
+Windowitem::window()
+  Returns parent window for window item.
+
+Window
+window_find_name(name)
+  Find window with name.
+
+Window
+window_find_refnum(refnum)
+  Find window with reference number.
+
+Window
+window_find_level(level)
+Server::window_find_level(level)
+  Find window with level.
+
+Window
+window_find_closest(name, level)
+Server::window_find_closest(name, level)
+  Find window that matches best to given arguments. `name' can be either
+  window name or name of one of the window items.
+
+Window
+window_find_item(name)
+Server::window_find_item(name)
+  Find window which contains window item with specified name/server.
+
+Windowitem
+window_item_find(name)
+Server::window_item_find(name)
+Window::item_find(server, name)
+  Find window item that matches best to given arguments.
+
+window_refnum_prev(refnum, wrap)
+window_refnum_next(refnum, wrap)
+  Return refnum for window that's previous/next in windows list.
+
+windows_refnum_last()
+  Return refnum for last window.
+
+Window::item_add(item, automatic)
+Window::item_remove(item)
+Window::item_destroy(item)
+  Add/remove/destroy window item
+
+Window::set_active()
+  Set window active.
+
+Window::change_server(server)
+Window::set_refnum(refnum)
+Window::set_name(name)
+Window::set_level(level)
+  Change server/refnum/name/level in window.
+
+Windowitem::set_active()
+  Change window item active in parent window.
+
+Window::item_prev()
+Window::item_next()
+  Change to previous/next window item.
+
+Windowitem::change_server(server)
+  Change server in window item.
+
+Windowitem::is_active()
+  Returns 1 if window item is the active item in parent window.
+
+Window::get_active_name()
+  Return active item's name, or if none is active, window's name
 
 
  *** Server Connects
 
-This is a record where we keep connection information. All Servers and
-Reconnects records have pointer to one of these.
+Connect->{}
+  type - "SERVER CONNECT" text
+  chat_type - String ID of chat protocol, for example "IRC"
 
-Connect::values()
-  Get some information about connect. This function returns a reference to
-  hash table. Hash table has keys:
-	"address" - Address where we connected (irc.blah.org)
-	"port" - Port where we connected
-	"password" - Password we used in connection.
+  address - Address where we connected (irc.blah.org)
+  port - Port where we connected
+  chatnet - Chat network
 
-	"ircnet" - IRC network
-	"wanted_nick" - Nick which we would prefer to use
-	"alternate_nick" - Alternate nick which we would prefer to use
-	"username" - User name
-	"realname" - Real name
+  password - Password we used in connection.
+  wanted_nick - Nick which we would prefer to use
+  username - User name
+  realname - Real name
 
-Connect server_create_conn(address, [port=6667, [password='', [nick='', [channels='']]]])
+Connect
+server_create_conn(address[, port=6667[, password=''[, nick=''[, channels='']]]])
   Create new server connection.
 
+
  *** Server functions
 
-Server::values()
-  Get some information about server. This function returns a reference to
-  hash table. Hash table has keys:
-	"address" - Address where we connected (irc.blah.org)
-	"port" - Port where we connected
-	"password" - Password we used in connection.
-
-	"ircnet" - IRC network
-	"wanted_nick" - Nick which we would prefer to use
-	"alternate_nick" - Alternate nick which we would prefer to use
-	"username" - User name
-	"realname" - Real name
-
-	"tag" - Unique server tag.
-	"real_address" - Who the server thinks it is (irc1.blah.org)
-	"nick" - Current nick
-	"usermode" - Current user mode
-	"usermode_away" - Are we marked as away? 1|0
-	"away_reason" - Away reason
-	"connected" - Is connection finished? 1|0
-	"connection_lost" - Did we lose the connection (1) or was
-	                    the connection meant to be disconnected (0)
-  Example:
-	$server_info = Irssi::active_server->values();
-	Irssi::print("Current server = ".$server_info->{'address'});
+Server->{}
+  type - "SERVER" text
+  chat_type - String ID of chat protocol, for example "IRC"
+
+  (..contains all the same data as Connect above..)
+
+  connect_time - Time when connect() to server finished
+  real_connect_time - Time when server sent "connected" message
+
+  tag - Unique server tag
+  nick - Current nick
+
+  connected - Is connection finished? 1|0
+  connection_lost - Did we lose the connection (1) or was
+                    the connection just /DISCONNECTed (0)
 
-Server Connect::connect()
+  rawlog - Rawlog object for the server
+
+  version - Server version
+  last_invite - Last channel we were invited to
+  server_operator - Are we server operator (IRC op) 1|0
+  usermode_away - Are we marked as away? 1|0
+  away_reason - Away reason message
+  banned - Were we banned from this server? 1|0
+
+Server
+Connect::connect()
   Connect to server.
 
 Server::disconnect()
   Disconnect from server.
 
-Server server_find_tag(tag)
+Server
+server_find_tag(tag)
   Find server with tag
 
-Server server_find_ircnet(ircnet)
-  Find first server that is in `ircnet'
+Server
+server_find_chatnet(chatnet)
+  Find first server that is in `chatnet'
 
-Channel channel_find(channel)
-  Find `channel' from any server
+Server::isnickflag(flag)
+  Returns 1 if flag is a nick mode flag (@, + or % in IRC)
 
-Channel Server::channel_find_level(level)
-  Find channel with level `level' preferably from specified server, but
-  fallbacks to any channel the matching level.
+Server::ischannel(data)
+  Returns 1 if start of `data' seems to mean channel.
 
-Server::send_raw(cmd)
-  Send raw message to server, it will be flood protected so you
-  don't need to worry about it.
+Server::get_nick_flags()
+  Returns nick flag characters in order: op, voice, halfop ("@+%" in IRC).
+
+Server::send_message(target, msg)
+  Sends a message to nick/channel.
 
-Server::ctcp_send_reply(data)
-  Send CTCP reply. This will be "CTCP flood protected" so if there's too
-  many CTCP requests in buffer, this reply might not get sent.
+
+ *** Server reconnections
+
+Reconnect->{}
+  type - "RECONNECT" text
+  chat_type - String ID of chat protocol, for example "IRC"
+
+  (..contains all the same data as Connect above..)
+
+  tag - Unique numeric tag
+  next_connect - Unix time stamp when the next connection occurs
 
 
  *** Server redirections
 
-WARNING: It's easy to mess up the Irssi's internal server expectations with
-these commands!
+WARNING: It's easy to mess up the Irssi's internal server expectations
+with these commands!
 
-This is a powerful feature of Irssi that I can't seen in other IRC clients.
-You can EASILY grab the server's reply for a command you send to server
-without any horrible kludges.
+This is a powerful feature of Irssi that I haven't seen in other IRC
+clients. You can EASILY grab the server's reply for a command you send
+to server without any horrible kludges.
 
 Server::redirect_init(command, last, ...)
-  Initialize redirection for specified command. This needs to be done only
-  once. Irssi already initializes commands "WHOIS", "WHO", "LIST" and "ISON".
+  Initialize redirection for specified command. This needs to be done
+  only once. Irssi already initializes commands WHOIS, WHO, LIST,
+  USERHOST and ISON.
+
   `command' is the whole name of the signal, like "command whois".
   `last' specifies how many of the items in `...' is considered as the
   "last event" from the command.
 
-  Example: $server->redirection_init('command who',
-        2, # 2 first events will finish the command
-	'event 401', # unknown nick (finished)
-	'event 315', # end of who (finished)
-	'event 352'); # who line (wait..)
+  Example:
+
+  $server->redirection_init('command who',
+        2,             # 2 first events will finish the command
+        'event 401',   # unknown nick (finished)
+        'event 315',   # end of who (finished)
+        'event 352');  # who line (wait..)
 
 Server::redirect_event(arg, last, ...)
   Add redirection. `arg' is a space separated list of arguments that should
@@ -301,98 +475,301 @@ Server::redirect_event(arg, last, ...)
   `event' is the event we're waiting from server.
   `signal' is the signal we will send after receiving the event. It should
            always start with 'redir ' so that Irssi's perl handler knows to
-	   send correct arguments to signal handler.
+           send correct arguments to signal handler.
   `argpos' is the argument position in event's data or -1 if it
            should be ignored.
 
   Example:
-	$server->send_raw('WHOIS :cras');
-	$server->redirect_event('cras', 2,
-			  "event 318", "redir end_of_whois", -1,
-			  "event 402", "redir no_such_server", -1,
-			  "event 401", "redir no_such_nick", 1,
-			  "event 311", "redir whois", 1,
-			  "event 301", "redir whois_away", 1,
-			  "event 312", "redir whois_server", 1,
-			  "event 313", "redir whois_oper", 1,
-			  "event 317", "redir whois_idle", 1,
-			  "event 319", "redir whois_channels", 1);
-  In the 402-case we tried "/WHOIS nick nick" but nick didn't exist..
-
-group Server::redirect_single_event(arg, last, group, event, signal, argpos)
+  $server->send_raw('WHOIS :cras');
+  $server->redirect_event('cras', 2,
+        "event 318", "redir end_of_whois", 1,
+        "event 402", "redir no_such_server", 1,
+        "event 401", "redir no_such_nick", 1,
+        "event 311", "redir whois", 1,
+        "event 301", "redir whois_away", 1,
+        "event 312", "redir whois_server", 1,
+        "event 313", "redir whois_oper", 1,
+        "event 317", "redir whois_idle", 1,
+        "event 319", "redir whois_channels", 1);
+
+  In the 402-case we tried "/WHOIS nick nick" but nick didn't exist. If
+  you need to handle "/WHOIS server nick" situation, you should put both
+  to arg with "server nick".
+
+Server::redirect_single_event(arg, last, group, event, signal, argpos)
   Same as redirect_event() except you can set it up in pieces.
   If `group' is 0, it will create new group and return it's id.
 
 
- *** IRC masks
+ *** Window items
+
+Windowitem->{}
+  type - Type of the window item, for example "CHANNEL" or "QUERY"
+  chat_type - String ID of chat protocol, for example "IRC"
+
+  server - Active server for item
+  name - Name of the item
+
+  createtime - Time the window item was created
+  new_data - 0=no new data, 1=text, 2=msg, 3=highlighted text
+  last_color - Color of the last highlighted text
+
+
+ *** Channels
+
+Channel->{}
+  type - "CHANNEL" text
+  chat_type - String ID of chat protocol, for example "IRC"
+
+  (..contains all the same data as Windowitem above..)
+
+  topic - Chanenl topic
+
+  no_modes - Channel is modeless
+  mode - Channel mode
+  limit - Max. users in channel (+l mode)
+  key - Channel key (password)
+
+  chanop - You are channel operator
+  names_got - /NAMES list has been received
+  wholist - /WHO list has been received
+  synced - Channel is fully synchronized
+
+  joined - JOIN event for this channel has been received
+  left - You just left the channel (for "channel destroyed" event)
+  kicked - You was just kicked out of the channel (for
+           "channel destroyed" event)
+
+Server::channels_join(channels, automatic)
+  Join to channels in server. `channels' may also contain keys for
+  channels just like with /JOIN command. `automatic' specifies if this
+  channel was joined "automatically" or if it was joined because join
+  was requested by user. If channel join is "automatic", irssi doesn't
+  jump to the window where the channel was joined.
+
+Channel
+Server::channel_create(name, automatic)
+  Create new channel.
+
+Channel
+channel_create(chat_type, name, automatic)
+  Create new channel with specified chat type.
+  FIXME: should this be removed? is this useful for anything?
+
+Channel::destroy()
+  Destroy channel.
+
+Channel
+channel_find(channel)
+  Find channel from any server.
+
+Channel
+Server::channel_find(channel)
+  Find channel from specified server.
+
+
+ *** Nick list
+
+Nick->{}
+  type - "NICK" text
+  chat_type - String ID of chat protocol, for example "IRC"
+
+  nick - Plain nick
+  host - Host address
+  realname - Real name
+  hops - Hop count to the server the nick is using
+
+  gone, serverop - User status, 1 or 0
+  op, voice, halfop - Channel status, 1 or 0
+
+  last_check - timestamp when last checked gone/ircop status.
+  send_massjoin - Waiting to be sent in a "massjoin" signal, 1 or 0
+
+Nick
+Channel::nick_insert(nick, op, voice, send_massjoin)
+  Add nick to nicklist.
+
+Channel::nick_remove(nick)
+  Remove nick from nicklist.
+
+Nick
+Channel::nick_find(mask)
+  Find nick from nicklist.
+
+Channel::nicks(channel)
+  Return a list of all nicks in channel.
+
+Server::nicks_get_same(nick)
+  Return all nick objects in all channels in server. List is in format:
+  Channel, Nick, Channel, ...
+
+
+ *** Queries
+
+Query->{}
+  type - "QUERY" text
+  chat_type - String ID of chat protocol, for example "IRC"
+
+  (..contains all the same data as Windowitem above..)
 
-irc_mask_match(mask, nick, user, host)
+  address - Host address of the queries nick
+  server_tag - Server tag used for this nick (doesn't get erased if
+               server gets disconnected)
+  unwanted - 1 if the other side closed or some error occured (DCC chats)
+
+Query
+query_create(chat_type, server_tag, nick, automatic)
+  Create a new query.
+
+Query::destroy()
+  Destroy the query.
+
+Query::query_change_server(server)
+  Change the active server of the query.
+
+Query
+query_find(nick)
+  Find query from any server.
+
+Query
+Server::query_find(nick)
+  Find query from specified server.
+
+
+ *** Masks
+
+You should use the Server version of the function if possible, since
+with different chat protocols the mask matching could be different.
+
+mask_match(mask, nick, user, host)
+Server::mask_match(mask, nick, user, host)
   Return 1 if `mask' matches nick!user@host.
 
-irc_mask_match_address(mask, nick, address)
+mask_match_address(mask, nick, address)
+Server::mask_match_address(mask, nick, address)
   Return 1 if `mask' matches nick!address.
 
-irc_masks_match(masks, nick, address)
+masks_match(masks, nick, address)
+Server::masks_match(masks, nick, address)
   Return 1 if any mask in the `masks' (string separated with spaces)
   matches nick!address.
 
-irc_get_mask(nick, host, flags)
-  Create IRC mask from nick!host.
-  flags = you need to combine these:
-  (FIXME: export the IRC_xxx defines to perl (or something))
-	IRC_MASK_NICK   0x01
-	IRC_MASK_USER   0x02
-	IRC_MASK_HOST   0x04
-	IRC_MASK_DOMAIN 0x08
 
+ *** Rawlog
+
+Rawlog
+rawlog_create()
+  Create a new rawlog.
 
- *** Channels
+Rawlog::destroy()
+  Destroy the rawlog.
 
-Channel::values()
-  Get some information about channel. This function returns a reference to
-  hash table. Hash table has keys:
-	"server" - Server of the channel
-	"name" - Channel name
-	"type" - Channel type ("channel", "query", "dcc chat", "empty")
-	"topic" - Channel topic
-	"key" - Channel key (password)
-	"limit" - Max. users in channel (+l mode)
-	"level" - Channel's level number.
-	"new_data" - 0=no new data, 1=text, 2=msg, 3=msg for you
-	"synced" - Channel is synchronized
-	"wholist" - Channel has received /WHO list
-	"names_got" - Channel has received /NAMES list
-	"chanop" - You are channel operator
-	"left" - You just left the channel (for "channel destroyed" event)
-	"kicked" - You was just kicked out of the channel (for
-	           "channel destroyed" event)
-
-Channel Server::channel_create(type, automatic)
-  Create new channel with name `channel'. `automatic' means that channel is
-  created "automatically", Irssi won't change the active window to it.
+rawlog_set_size(lines)
+  Set the default rawlog size for new rawlogs.
 
-Channel::destroy()
-  Destroy channel.
+Rawlog::open(filename)
+  Start logging new messages in rawlog to specified file.
+
+Rawlog::close()
+  Stop logging to file.
+
+Rawlog::save(filename)
+  Save the current rawlog history to specified file.
+
+Rawlog::input(str)
+  Send `str' to raw log as input text.
+
+Rawlog::output(str)
+  Send `str' to raw log as output text.
 
-Channel::change_name(name)
-  Change channel's name
+Rawlog::redirect(str)
+  Send `str' to raw log as redirection text.
 
-Channel::get_mode()
-  Return channel's mode
 
-Channel Server::channel_find(channel)
-  Find `channel' in server.
+ *** Logging
+
+Log->{}
+  fname - Log file name
+  opened - Log file is open
+  level - Log only these levels
+  last - Timestamp when last message was written
+  autoopen - Automatically open log at startup
+  failed - Opening log failed last time
+  temp - Log isn't saved to config file
+  items - List of log items
+
+Logitem->{}
+  type - 0=target, 1=window refnum
+  name - Name
+  servertag - Server tag
+
+Log
+log_create_rec(fname, level)
+  Create log file.
+
+Log::update()
+  Add log to list of logs / save changes to config file.
+
+Log
+log_find(fname)
+  Find log with file name.
+
+Log::close()
+  Destroy log file.
+
+Log::start_logging()
+  Open log file and start logging.
 
-Channel Server::channel_find_closest(channel, level)
-  Find `channel' or if not found, some other channel that has
-  level `level' (number).
+Log::stop_logging()
+  Close log file.
 
-Channel channel_find_level(level)
-  Find channel with level `level'.
+Log::item_add(type, name, server)
+  Add log item to log.
+
+Log::item_destroy(item)
+  Remove log item from log.
+
+Logitem
+Log::item_find(type, item, server)
+  Find item from log.
+
+
+ *** Ignores
+
+Ignore->{}
+  mask - Ignore mask
+  servertag - Ignore only in server
+  channels - Ignore only in channels (list of names)
+  pattern - Ignore text pattern
+
+  level - Ignore level
+  except_level - Ignore exception levels
+
+  regexp - Regexp pattern matching
+  fullword - Pattern matches only full words
+
+ignore_add_rec(ignore)
+  Add ignore record.
+
+ignore_update_rec(ignore)
+  Update ignore record in configuration
+
+ignore_check(nick, host, channel, text, level)
+Server::ignore_check(nick, host, channel, text, level)
+  Return 1 if ignoring matched.
 
 
  *** Channel modes
 
+irc_get_mask(nick, host, flags)
+  Create IRC mask from nick!host.
+  flags = you need to combine these:
+  (FIXME: export the IRC_xxx defines to perl (or something))
+	IRC_MASK_NICK   0x01
+	IRC_MASK_USER   0x02
+	IRC_MASK_HOST   0x04
+	IRC_MASK_DOMAIN 0x08
+
 Ban::values()
   Get some information about ban. This function returns a reference to
   hash table. Hash table has keys:
@@ -429,32 +806,6 @@ Channel::modes_set(data, mode)
   separated with spaces.
 
 
- *** Nick list
-
-Nick::values()
-  Get some information about nick. This function returns a reference to
-  hash table. Hash table has keys:
-	"nick" - Plain nick
-	"host" - Host (blah@there.org)
-	"name" - Real name
-	"hops" - Hop count to the server nick is using
-	"op", "voice", "gone", "ircop" - 1 or 0
-	"last_check" - timestamp when last checked gone/ircop status.
-	"send_massjoin" - Waiting to be sent in a "massjoin" signal - 1 or 0
-
-Nick Channel::nicklist_insert(nick, op, voice, send_massjoin)
-  Add nick to nicklist. (!!)
-
-Channel::nicklist_remove(nick)
-  Remove nick from nicklist. (!!)
-
-Nick Channel::nicklist_find(mask)
-  Find nick from nicklist.
-
-Channel::nicklist_getnicks(channel)
-  Return a list of all nicks (Nick packages) in channel.
-
-
  *** DCC
 
 Dcc::values()
@@ -500,25 +851,6 @@ Dcc item_get_dcc(item)
   If window item `item' is a query of a =nick, return DCC chat record
   of nick.
 
- *** Reconnects
-
-Reconnect::values()
-  Get some information about reconnect. This function returns a reference to
-  hash table. Hash table has keys:
-	"tag" - Unique numeric tag
-	"next_connect" - Unix time stamp when the next connection occurs
-
-	"address" - Address where we connected (irc.blah.org)
-	"port" - Port where we connected
-	"password" - Password we used in connection.
-
-	"ircnet" - IRC network
-	"wanted_nick" - Nick which we would prefer to use
-	"alternate_nick" - Alternate nick which we would prefer to use
-	"username" - User name
-	"realname" - Real name
-
-
  *** Netsplits
 
 Netsplit::values()
@@ -552,19 +884,43 @@ Server::notifylist_ison_server(nick)
   Check if `nick' is on IRC server.
 
 
- *** Rawlog
+ *** Plugins
+
+Plugin::values()
+  Get some information about plugin. This function returns a reference to
+  hash table. Hash table has keys:
+	"name" - Plugin name
+	"description" - Plugin description
 
-Server::rawlog_input(str)
-  Send `str' to raw log as input text. (!!)
+plugin_load(name, args)
+  Load plugin.
 
-Server::rawlog_output(str)
-  Send `str' to raw log as output text. (!!)
+plugin_get_description(name)
+  Get plugin description string.
 
-Server::rawlog_redirect(str)
-  Send `str' to raw log as redirection text. (!!)
+Plugin plugin_find(name)
+  Find plugin.
 
 
- *** Ignores
+ *** IRC
+
+dccs() - return list of all dcc connections
+
+Server::send_raw(cmd)
+  Send raw message to server, it will be flood protected so you
+  don't need to worry about it.
+
+Server::irc_send_cmd_split(cmd, arg, max_nicks)
+  Split the `cmd' into several commands so `arg' argument has only
+  `max_nicks' number of nicks.
+
+  Example: $server->irc_send_cmd_split("KICK #channel nick1,nick2,nick3 :byebye", 2, 2);
+  Irssi will send commands "KICK #channel nick1,nick2 :byebye" and
+  "KICK #channel nick3 :byebye" to server.
+
+Server::ctcp_send_reply(data)
+  Send CTCP reply. This will be "CTCP flood protected" so if there's too
+  many CTCP requests in buffer, this reply might not get sent.
 
 Autoignore::values()
   Get some information about autoignore. This function returns a reference to
@@ -573,77 +929,8 @@ Autoignore::values()
 	"timeleft" - Seconds left to ignore
 	"level" - Ignoring level number
 
-ignore_add(mask, level)
-  Ignore `mask' with level string
-
-ignore_remove(mask, level)
-  Unignore level string from `mask'
-
-Server::ignore_check(nick, host, type)
-  Return 1 if nick!host is ignored with level number `type'.
-
 Server::autoignore_add(type, nick)
   Autoignore `nick' in server with level number `type'.
 
 Server::autoignore_remove(mask, level)
   Remove autoignoring `nick' from server. `level' is a string.
-
-
- *** Logging
-
-Log::values()
-  Get some information about log. This function returns a reference to
-  hash table. Hash table has keys:
-	"fname" - Log file name
-	"autoopen_log" - Automatically open log at startup
-	"last" - Timestamp when last write occured.
-	"level" - Global logging level.
-	/*FIXME: add list of Logitems;*/
-
-Logitem::values()
-  Get some information about logitem. This function returns a reference to
-  hash table. Hash table has keys:
-	"name" - Log item name.
-	"level" - Logging level number.
-
-Log log_create(fname, data)
-  Create log file. `data' = logging level ("-all #channel +public")
-
-Log log_create_with_level(fname, level)
-  Create log file with level number.
-
-Log log_file_find(fname)
-  Find log file.
-
-Log::destroy()
-  Destroy log file
-
-Log::open()
-  Start logging
-
-Log::close()
-  Stop logging
-
-Log::append_item(name, level)
-  Append log item with level number `level' to log file. (!!)
-
-Log::remove_item(log, name)
-  Remove log item. (!!)
-
-
- *** Plugins
-
-Plugin::values()
-  Get some information about plugin. This function returns a reference to
-  hash table. Hash table has keys:
-	"name" - Plugin name
-	"description" - Plugin description
-
-plugin_load(name, args)
-  Load plugin.
-
-plugin_get_description(name)
-  Get plugin description string.
-
-Plugin plugin_find(name)
-  Find plugin.