Opis funkcji dostpnych z poziomu skryptu perlowego.
Aktualizacja: grudzie 2010
(C) Copyright 2005 Jakub Zawadzki <darkjames[at]darkjames.ath.cx>
	      2010 Sawomir Nizio <poczta-sn[at]gazeta.pl>
	      2010 Wiesaw Ochmiski <wiechu[at]wiechu.com>

Ekg2
   exit()                                                                  (void)
      - koczy program

   get_ekg2_dir()                                                          (char*)
      - zwraca katalog config_dir


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

   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 cig znakw


   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 parametrw i opcje, ktre bd wykorzystane
        midzy innymi przy dopenianiu tabulatorem

   timer_bind(int freq, char* handler)                                     (Ekg2::Timer)
      - ustawia zegarek (okresowe zdarzenie) o podanej czstotliwoci


   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 biece okno


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

   plugins()                                                               (lista Ekg2::Plugin)
      - zwrace list pluginw

   timers()                                                                (lista Ekg2::Timer)
      - zwraca list zegarkw

   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 obsugi zmian jej wartoci

   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*)
      - moliwoci (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)
      - wyadowuje plugin


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

   {path}                                                                  (char*)
      - cieka


Ekg2::Session
   {connected}                                                             (int)
      - czy poczona

   {uid}                                                                   (char*)
      - nazwa

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

   {alias}                                                                 (char*)
      - alias


   userlist(Ekg2::Session session)                                         (Ekg2::Userlist)
      - lista uytkownikw dla sesji

   set(Ekg2::Session session)                                              (void)
      - zmienia biec sesj

   connected_set(Ekg2::Session session, int val)                           (void)
      - ustawia informacj: sesja jest poczona 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)
      - czstotliwo (sekundy)

   {freq_ms}                                                               (int)
      - czstotliwo


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


Ekg2::User
   {nickname}                                                              (char*)
      - nazwa uytkownika

   {uid}                                                                   (char*)
      - uid

   {status}                                                                (char*)
      - status uytkownika


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


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


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

   users(Ekg2::Userlist userlist)                                          (lista Ekg2::User)
      - zwraca list uytkownikw

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

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


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

   {value}                                                                 (char*/int)
      - wartosc


   help(Ekg2::Variable var)                                                (void)
      - wywietla 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 nastpne okno

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

   userlist(Ekg2::Window window)                                           (Ekg2::Userlist)
      - lista uytkownikw dla okna

   switch(Ekg2::Window window)                                             (void)
      - przecza 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 serwerw

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


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

   {mode}                                                                  (char*)
      - tryb kanau

   {topic}                                                                 (char*)
      - topic

   {topicby}                                                               (char*)
      - autor topica

   {window}                                                                (Ekg2::Window)
      - okno

   {name_}                                                                 (char*)
      - (moe by usunite w przyszoci) nazwa kanau, z irc:


   part(Ekg2::Irc::Channel chan, char* reason)                             (void)
      - wysya wiadomo wyjcia z kanau


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)
      - wysya wiadomo do serwera

   quit(Ekg2::Session s, char* quitreason)                                 (void)
      - wysya wiadomo QUIT

   newnick(Ekg2::Session s, char* newnick)                                 (void)
      - wysya wiadomo zmiany nicka na newnick

   setmode(Ekg2::Session s, char* mode)                                    (void)
      - wysya wiadomo MODE

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

   die(Ekg2::Session s, char *reason)                                      (void)
      - wysya wiadomo DIE

   channels(Ekg2::Session s)                                               (lista Ekg2::Irc::Channel)
      - zwraca list kanaw, na ktrych jestemy

   people(Ekg2::Session s)                                                 (lista Ekg2::Irc::User)
      - zwraca list uytkownikw na kanaach, na ktrych jestemy


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 ktrych jest uytkownik


------- przykad ------

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

   # znajd sesj, ktrej na przykad dotyczy zdarzenie obsugiwane przez handler
   # (albo Ekg2::session_current jeli interesuje nas bieca sesja):
   my $ses = Ekg2::session_find($sess_name);

   # we list nickw:
   my $ul = Ekg2::Session::userlist($ses);

   # znajd uytkownika na licie:
   my $user = Ekg2::Userlist::find($ul, $uid);

   # jeli nie znalazo (undef), przypisz $uid
   my $who = defined $user ? $user->{nickname} : $uid;

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

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