Opis funkcji dostępnych z poziomu skryptu perlowego.
Aktualizacja: grudzień 2010
(C) Copyright 2005 Jakub Zawadzki <darkjames[at]darkjames.ath.cx>
	      2010 Sławomir Nizio <poczta-sn[at]gazeta.pl>
	      2010 Wiesław Ochmiński <wiechu[at]wiechu.com>

Ekg2
   exit()                                                                  (void)
      - kończy program

   get_ekg2_dir()                                                          (char*)
      - zwraca katalog config_dir


   debug(char* str)                                                        (void)
      - pisze tekst w oknie debugowania; nie wstawia znaku nowej linii na końcu

   echo(char* str)                                                         (void)
      - pisze tekst w oknie

   print(int dest, char* str)                                              (void)
      - pisze w oknie o zadanym numerze


   format_add(char* str, char* value)                                      (void)
      - dodaje format

   format_string(char* str)                                                (char*)
      - zwraca sformatowany ciąg znaków


   fstring2ascii(char* str, void* attr_)                                   (char*)
      - zamienia sformatowany tekst na "formatkę"


   handler_bind(char* query_name, char* handler)                           (void)
      - ustawia handlera dla zdarzenia query_name

   command_bind(char* cmd, char* handler)                                  (void)
      - ustawia handlera dla polecenia cmd

   command_bind_ext(char* cmd, char* params, char* poss, char* handler)    (void)
      - ustawia handlera dla polecenia cmd, wersja rozszerzona
        pozwala podać typ parametrów i opcje, które będą wykorzystane
        między innymi przy dopełnianiu tabulatorem

   timer_bind(int freq, char* handler)                                     (Ekg2::Timer)
      - ustawia zegarek (okresowe zdarzenie) o podanej częstotliwości


   session_add(char* uid)                                                  (Ekg2::Session)
      - dodaje nową sesję do listy

   session_find(char* uid)                                                 (Ekg2::Session)
      - zwraca sesję dla zadanego UID


   script_find(char* name)                                                 (Ekg2::Script)
      - zwraca skrypt o zadanej nazwie (bez rozszerzenia)

   plugin_find(char* name)                                                 (Ekg2::Plugin)
      - zwraca plugin o zadanej nazwie (bez rozszerzenia)

   plugin_register(char* name, int type, void* formatinit)                 (void)
      - rejestruje plugin

   plugin_load(char* name)                                                 (int)
      - ładuje plugin


   window_findid(int id)                                                   (Ekg2::Window)
      - zwraca okno o zadanym numerze

   window_find(char* name)                                                 (Ekg2::Window)
      - zwraca okno o zadanej nazwie

   window_new(char* target, int new_id)                                    (Ekg2::Window)
      - otwiera nowe okno

   window_current()                                                        (Ekg2::Window)
      - zwraca bieżące okno


   variables()                                                             (lista Ekg2::Variable)
      - zwraca listę zmiennych

   plugins()                                                               (lista Ekg2::Plugin)
      - zwrace listę pluginów

   timers()                                                                (lista Ekg2::Timer)
      - zwraca listę zegarków

   commands()                                                              (lista Ekg2::Command)
      - zwraca listę komend

   watches()                                                               (lista Ekg2::Watch)
      - zwraca listę watchy

   sessions()                                                              (lista Ekg2::Session)
      - zwraca listę sesji

   windows()                                                               (lista Ekg2::Window)
      - zwraca listę okien


   command(char* what)                                                     (int)
      - wykonuje polecenie (np. ,,/beep'')

   command_exec(Ekg2::Window window, Ekg2::Session session, char* what)    (int)
      - wykonuje polecenie


   variable_find(char* name)                                               (Ekg2::Variable)
      - zwraca zmienną o podanej nazwie

   variable_add(char* name, char* value)                                   (Ekg2::Variable)
      - dodaje zmienną

   variable_add_ext(char* name, char* value, char* handler)                (Ekg2::Variable)
      - dodaje zmienną i handler do obsługi zmian jej wartości

   variables_free()                                                        (void)
      - usuwa listę zmiennych


   watch_add(int fd, int type, char* handler, void* data)                  (void)
      - dodaje watcha

   watch_remove(int fd, int type)                                          (void)
      - usuwa watcha


   EKG_MSGCLASS_SENT()                                                     (int)
      - zwraca wartość EKG_MSGCLASS_SENT

   EKG_MSGCLASS_SENT_CHAT()                                                (int)
      - zwraca wartość EKG_MSGCLASS_SENT_CHAT

   EKG_NO_THEMEBIT()                                                       (int)
      - zwraca wartość EKG_NO_THEMEBIT

   WATCH_READ_LINE()                                                       (int)
      - zwraca wartość WATCH_READ_LINE

   WATCH_READ()                                                            (int)
      - zwraca wartość WATCH_READ

   WATCH_WRITE()                                                           (int)
      - zwraca wartość WATCH_WRITE

   PLUGIN_UI()                                                             (int)
      - zwraca wartość PLUGIN_UI

   PLUGIN_PROTOCOL()                                                       (int)
      - zwraca wartość PLUGIN_PROTOCOL


Ekg2::Command
   {name}                                                                  (char*)
      - nazwa

   {param}                                                                 (char*)
      - np. "!U ? p", gdy {name} = "add"

   {poss}                                                                  (char*)
      - możliwości (np. "-f --find", gdy {name} = "add")


   execute(Ekg2::Command comm, char* param)                                (int)
      - wykonuje polecenie

   remove(Ekg2::Command comm)                                              (void)
      - usuwa polecenie


Ekg2::Plugin
   {name}                                                                  (char*)
      - nazwa

   {prio}                                                                  (int)
      - priorytet


   unload(Ekg2::Plugin plugin)                                             (int)
      - wyładowuje plugin


Ekg2::Script
   {name}                                                                  (char*)
      - nazwa

   {path}                                                                  (char*)
      - ścieżka


Ekg2::Session
   {connected}                                                             (int)
      - czy połączona

   {uid}                                                                   (char*)
      - nazwa

   {status}                                                                (char*)
      - status (avail, ...)

   {alias}                                                                 (char*)
      - alias


   userlist(Ekg2::Session session)                                         (Ekg2::Userlist)
      - lista użytkowników dla sesji

   set(Ekg2::Session session)                                              (void)
      - zmienia bieżącą sesję

   connected_set(Ekg2::Session session, int val)                           (void)
      - ustawia informację: sesja jest połączona czy nie

   param_add(Ekg2::Session session, char *name)                            (int)
      - dodaje zmienną sesyjną

   param_set(Ekg2::Session session, char* name, char* value)               (void)
      - ustawia parametr sesji

   disconnect(Ekg2::Session session)                                       (int)
      - robi /disconnect

   connect(Ekg2::Session session)                                          (int)
      - robi /connect


Ekg2::Session::param
   {key}                                                                   (char*)

   {value}                                                                 (char*)


   session_help(Ekg2::Session session, char* name)                         (void)
      - pokazuje pomoc zmiennej sesji

   help(Ekg2::Session::Param param, Ekg2::Session session)                 (void)
      - pokazuje pomoc

   set(Ekg2::Session::Param param, Ekg2::Session session, char* value)     (int)
      - ustawia parametr sesji


Ekg2::Timer
   {name}                                                                  (char*)
      - nazwa

   {freq}                                                                  (int)
      - częstotliwość (sekundy)

   {freq_ms}                                                               (int)
      - częstotliwość


   destroy(Ekg2::Timer timer)                                              (void)
      - usuwa zegarek


Ekg2::User
   {nickname}                                                              (char*)
      - nazwa użytkownika

   {uid}                                                                   (char*)
      - uid

   {status}                                                                (char*)
      - status użytkownika


   set_status(Ekg2::User u, char* status)                                  (int: 0 lub 1)
      - zmienia status użytkownikowi


Ekg2::Userlist
   {}                                                                      (list_t)
      - just a pointer


   find(Ekg2::Userlist userlist, char* uid)                                (Ekg2::User)
      - zwraca użytkownika o zadanym ID

   users(Ekg2::Userlist userlist)                                          (lista Ekg2::User)
      - zwraca listę użytkowników

   add(Ekg2::Userlist userlist, char* uid, char* nickname)                (Ekg2::User)
      - dodaje użytkownika do listy

   remove(Ekg2::Userlist userlist, Ekg2::User u)                           (int)
      - usuwa użytkownika z listy


Ekg2::Variable
   {name}                                                                  (char*)
      - nazwa

   {value}                                                                 (char*/int)
      - wartosc


   help(Ekg2::Variable var)                                                (void)
      - wyświetla pomoc dla zmiennej

   remove(Ekg2::Variable var)                                              (void)
      - usuwa

   set(Ekg2::Variable var, char* value)                                    (int)
      - ustawia wartość


Ekg2::Watch
   {fd}                                                                    (int)

   {type}                                                                  (int)

   {removed}                                                               (int)

   {timeout}                                                               (int)

   {plugin}                                                                (Ekg2::Plugin)

   {started}                                                               (int)


Ekg2::Window
   {target}                                                                (char*)
      - nazwa

   {id}                                                                    (int)
      - numer

   {session}                                                               (Ekg2::Session)
      - sesja


   next(Ekg2::Window window)                                               (Ekg2::Window)
      - zwraca następne okno

   prev(Ekg2::Window window)                                               (Ekg2::Window)
      - zwraca poprzednie okno

   userlist(Ekg2::Window window)                                           (Ekg2::Userlist)
      - lista użytkowników dla okna

   switch(Ekg2::Window window)                                             (void)
      - przełącza na zadane okno

   kill(Ekg2::Window window)                                               (void)
      - zabija okno

   print_format(Ekg2::Window window, char* format, ...)                    (void)
      - pisze w zadanym oknie

   print(Ekg2::Window window, char* line)                                  (void)
      - pisze w zadanym oknie


#########

Ekg2::Irc
   servers()                                                               (lista Ekg2::Irc::Server)
      - zwraca liste serwerów

   session2server(Ekg2::Session s)                                         (Ekg2::Irc::Server)
      - zwraca zblessowana sesje ircowa ze ,,zwyklej''


Ekg2::Irc::Channel
   {name}                                                                  (char*)
      - nazwa kanału, bez irc:

   {mode}                                                                  (char*)
      - tryb kanału

   {topic}                                                                 (char*)
      - topic

   {topicby}                                                               (char*)
      - autor topica

   {window}                                                                (Ekg2::Window)
      - okno

   {name_}                                                                 (char*)
      - (może być usunięte w przyszłości) nazwa kanału, z irc:


   part(Ekg2::Irc::Channel chan, char* reason)                             (void)
      - wysyła wiadomość wyjścia z kanału


Ekg2::Irc::Channel::User
   {mode}                                                                  (int)

   {sign}                                                                  (char*)
      - np. @

   {channel}                                                               (Ekg2::Irc::Channel)
      - kanał


Ekg2::Irc::Server
   {nick}                                                                  (char*)
      - nick

   {server}                                                                (char*)
      - nazwa serwera

   {ip}                                                                    (char*)
      - jesli zresolvowano: adres ip, jesli nie: 0.0.0.0


   session(Ekg2::Session s)                                                (Ekg2::Session)
      - sesja

   raw(Ekg2::Session s, char* str)                                         (void)
      - wysyła wiadomość do serwera

   quit(Ekg2::Session s, char* quitreason)                                 (void)
      - wysyła wiadomość QUIT

   newnick(Ekg2::Session s, char* newnick)                                 (void)
      - wysyła wiadomość zmiany nicka na newnick

   setmode(Ekg2::Session s, char* mode)                                    (void)
      - wysyła wiadomość MODE

   oper(Ekg2::Session s, char* nick, char* password)                       (void)
      - identifikuje się jako operator

   die(Ekg2::Session s, char *reason)                                      (void)
      - wysyła wiadomość DIE

   channels(Ekg2::Session s)                                               (lista Ekg2::Irc::Channel)
      - zwraca listę kanałów, na których jesteśmy

   people(Ekg2::Session s)                                                 (lista Ekg2::Irc::User)
      - zwraca listę użytkowników na kanałach, na których jesteśmy


Ekg2::Irc::User
   {nick}                                                                  (char*)

   {realname}                                                              (char*)

   {hostname}                                                              (char*)

   {ident}                                                                 (char*)

   {nick_}                                                                 (char*)


   channels (Ekg2::Irc::User user)                                         (lista Ekg2::Irc::Channel::User)
      - lista kanalow, na których jest użytkownik


------- przykład ------

   # $sess_name - nazwa sesji, np. xmpp:nick@serwer.ktory.ma.uptime.piec.lat.org albo np. irc:fajna_sieć
   # $uid - ID użytkownika, np. xmpp:nick2@reszta.com/Abc

   # znajdź sesję, której na przykład dotyczy zdarzenie obsługiwane przez handler
   # (albo Ekg2::session_current jeśli interesuje nas bieżąca sesja):
   my $ses = Ekg2::session_find($sess_name);

   # weź listę nicków:
   my $ul = Ekg2::Session::userlist($ses);

   # znajdź użytkownika na liście:
   my $user = Ekg2::Userlist::find($ul, $uid);

   # jeśli nie znalazło (undef), przypisz $uid
   my $who = defined $user ? $user->{nickname} : $uid;

   # i wypisz na ekran
   Ekg2::echo("test ::: $who");

------ koniec ------
