SPL Module Documentation: Index


load "array";

builtin array_reindex(array);
builtin array_switch(array, key1, key2);

function array_sort_by_keys(array, order_function);
function array_sort_by_values(array, order_function);
function array_join(array, seperator);


load "bits";

builtin bits_and(@values);
builtin bits_or(@values);
builtin bits_xor(@values);
builtin bits_not(value);
builtin bits_shl(value, bits);
builtin bits_shr(value, bits);


load "builtins";

builtin write(text, encoding);
builtin read(prompt, encoding);
builtin chr(number);
builtin ord(text);
builtin hex(text);
builtin oct(text);
builtin bin(text);
builtin fmt(text, @args);
builtin rand(max);
builtin srand(seed);
builtin declared_builtin(function_name);

builting substring(string,offset,length);

builtin setlocale(category, locale);
builtin bindtextdomain(domain, directory);
builtin textdomain(domain);
builtin gettext(message);
builtin dgettext(domain, message);
builtin _(message, domain, @args);
builtin acos(x);
builtin asin);
builtin atan(x);
builtin atan2(x, y);
builtin cos(x);
builtin sin(x);
builtin tan(x);
builtin sqrt(x);
builtin round(x);
builtin ceil(x);
builtin floor(x);


load "cgi";

builtin cgi_userfile_save(paramname, filename);
builtin cgi_write(text);

namespace cgi
{
     var param;
     var cookie;
     var config;
     var content_type = "text/html";
     var silent_debug = 0;
     var sid;
     var sid_vm;
     var sid_task;
     var sid_passed;
     var url;
     var agent;
     var peerip;
     var post_type;
     var post_data;
}


load "crypt";

builtin crypt(key, salt);


load "curl";

builtin curl(url, %options);


load "encode_int";

function encode_int(text);


load "encode_js";

function encode_js(text);


load "encode_regex";

function encode_regex(text);


load "encode_url";

function encode_url(text);


load "encode_xml";

builtin encode_xml(text);


load "environ";

namespace environ { }


load "epfb";

builtin epfb_pixelset(x,y,col);
builtin epfb_linedraw(startx,starty,stopx,stopy,col);
builtin epfb_blockfill(x,y,width,height,col);
builtin epfb_drawtext(x,y,text,col);
builtin epfb_cursor_setup(width,height,col1,col2,blink1,blink2,blinkrate);
builtin epfb_cursor_pixel(x,y,value);
builtin epfb_cursor_enable(enable);
builtin epfb_cursor_moveto(x,y);
builtin epfb_cursor_position(x,y);


load "file";

builtin file_read(filename, encoding);
builtin file_write(filename, content, encoding);
builtin file_append(filename, content, encoding);
builtin file_delete(filename);
builtin file_list(dirname);
builtin file_type(dirname,filename);
builtin file_access(filename, mode);

object FileEx
{
     var type;
     var filename;
     var errmsg;
     var description;
}


load "format_ini";

function format_ini_parse(inidata);
function format_ini_dump(initree);


load "format_xml";

builtin format_xml_parse(xmldata);
builtin format_xml_dump(xmltree);

object FormatXmlEx
{
     var description;
}


load "gyro";

builtin gyro_open(devicename);
builtin gyro_prefetch_state(fd,channels);
builtin gyro_state(fd,channels);
builtin gyro_close(fd);


load "kde";


load "multimouse";

builtin multimouse_update();

namespace multimouse { }


load "prime";

namespace prime { }


load "qt";

manual SPL_Qt;

builtin qt_debug(mode);
builtin qt_kde();
builtin qt_ui(ui_file);
builtin qt_child(parent, name, class, recursive);
builtin qt_cast(object, type);
builtin qt_destroy(object);
builtin qt_delete(object);
builtin qt_autodelete(object);
builtin qt_as(type, value);
builtin qt_connect(sender, signal, receiver, slot);
builtin qt_disconnect(sender, signal, receiver, slot);
builtin qt_event_callback(object, callback, @eventtypes);
builtin qt_signal_callback(object, signalspec, callback);
builtin qt_virtual_callback(object, method, callback);
builtin qt_info();

function qt_kdeinit(progname, desc, version);

namespace qt { }

object QtEx
{
     var description;
}


load "sdl";

builtin sdl_init(width, height);
builtin sdl_quit();
builtin sdl_title(title, icon);
builtin sdl_delay(ms);
builtin sdl_flip();
builtin sdl_update(x, y, w, h);
builtin sdl_image_load(filename);
builtin sdl_image_create(w, h);
builtin sdl_blit(dstimg, srcimg, x, y);
builtin sdl_blitrect(dstimg, srcimg, dest_x, dest_y, src_x, src_y, w, h);
builtin sdl_copy(srcimg, x, y, w, h);
builtin sdl_fill(dstimg, x, y, w, h, r, g, b, a);
builtin sdl_fill_pattern(dstimg, x, y, w, h, patternimg);
builtin sdl_keystat(keyname);
builtin sdl_sprite_create();
builtin sdl_sprite_redraw();
builtin sdl_sprite_update();

object SdlEx
{
     var description;
}


load "socket";

builtin socket_create(host,port);
builtin socket_server(port);
builtin socket_accept(server);
builtin socket_write(socket,data);
builtin socket_poll(socket,timeout);
builtin socket_read(socket,length);
builtin socket_close();

object SocketEx { }


load "sql";

builtin encode_sql(text);
builtin sql_connect(driver_name, driver_data);
builtin sql(database_handler, query);

object SqlEx
{
     var description;
}


load "sql_mysql";

builtin encode_mysql(text);


load "sql_postgres";


load "sql_sqlite";


load "sql_utils";

function sql_value(db, query);
function sql_tuple(db, query);
function sql_keyval(db, query);
function sql_array(db, query);


load "system";

builtin system(command, encoding);


load "task";

builtin task_create(name, code, ctx);
builtin task_pause(name);
builtin task_continue(name);
builtin task_system(name);
builtin task_public(name);
builtin task_getname();
builtin task_check(name);
builtin task_sleep(seconds);

function task_kill(name);
function task_late_kill(name);
function task_switch(name);
function task_co_call(name);
function task_co_return(retval);
function task_co_setdefault(name, def);
function task_eval(code, ctx);


load "termio";

builtin termio_setpos(x, y);
builtin termio_clear();

builting termio_sleep();


load "time";

builtin time();
builtin time_local(time);
builtin time_gm(time);
builtin time_diff(time1, time0);
builtin time_fmt(format, tm);
builtin time_mk(tm);
builtin time_mkgm(tm);


load "uuidgen";

builtin uuidgen();


load "w2t";

var w2t_core_scripts = <>;

object W2t
{
     static scripts = [ w2t_core_scripts ];
     static styles = [ ];
     static w2t_ns = "http://www.spl-scripting.org/xml/w2t";
     static xmlns;

     var startup;
     var mime_type = "text/xml";
     var callbacks;
     var callbacks_oncleanup;
     var callbacks_rev = 0;
     var request;
     var response;

     method register_callback(id, handler, oncleanup);
     method response_add(xmltext);
     method dom_appendchild(id, xmltext);
     method dom_remove(id);
     method dom_replaceinner(id, xmltext);
     method dom_setattr(id, name, value);
     method execute(script);
     method getscripts();
     method getstyles();
     method getxmlnsdecls();
     method getid();
     method run();
     method init();
}


load "webdebug";

function webdebug() ;


load "wscons";

builtin wscons_open(devicefile);
builtin wscons_read();
builtin wscons_read();


load "wsf";

function wsf_get_domupdate_status(@methods) ;

object WsfComponent
{
     static id_counter = 0;

     var id;
     var sid;
     var dirty = 0;
     var children;
     var main_task;

     method add_action(url);
     method add_href(url);
     method add_javascript(url);
     method get_html_children();
     method get_html_cached();
     method get_html();
     method main();
     method child_set(name, obj);
     method child_remove(name);
     method destroy();
     method init();
}

object WsfDocument
{
     static domupdate = wsf_get_domupdate_status();
     static showiframe = 0;

     var root;
     var title = "";
     var html_head = "";
     var body_attr = "";
     var callbacks;

     method callback_add(type, func);
     method callback_del(type, func);
     method callback_call(type, %options);
     method main();
}


load "wsf_action";

object WsfAction WsfComponent
{
     var action_list;
     var template_function;
     var template_options;
     var data;

     method action_reset();
     method action(name, callback);
     method main();
     method get_html();
     method init(_template_function, %_template_options);
}


load "wsf_debug";

object WsfDebug WsfComponent
{
     method main() ;
     method get_html() ;
}


load "wsf_dialog";

object WsfDialog WsfComponent
{
     var xmltree;
     var values;
     var edit_mode = 0;
     var edit_current = "";
     var edit_show_xml = 0;
     var show_edit_button = 0;

     method set_edit_mode(newmode);
     method get_html();
     method save();
     method main();
     method reset_values();
     method import_xml(xmldata);
     method init(xmldata);
}


load "wsf_display";

object WsfDisplay WsfComponent
{
     var tag = "div";
     var attributes;
     var html_text;

     method get_html();
     method set_html(t);
     method init(t);
}


load "wsf_edit";

object WsfEdit WsfComponent
{
     var edit_data;
     var edit_fields;
     var edit_actions;
     var just_updated;

     method edit_reset();
     method edit_input(field, %opt);
     method edit_textarea(field, %opt);
     method edit_select(field, list, %opt);
     method edit_load();
     method edit_save();
     method main();
     method get_html();
     method init();
}


load "wsf_edit_sql";

object WsfEditSql WsfEdit
{
     var sql_id;
     var sql_db;
     var sql_table;
     var sql_key;
     var get_html_core;

     method edit_load();
     method edit_save();
     method get_html();
     method init(_sql_id, _sql_db, _sql_table, _sql_key, _get_html_core);
}


load "wsf_graph";

object WsfGraph WsfComponent
{
     var get_list;
     var ibase;
     var raster;
     var iframe_header;
     var iframe_footer;
     var iframe_attributes;
     var scroll_x, scroll_y;

     method iframe_main();
     method get_html();
     method main();
     method destroy();
     method init(_get_list, _ibase);
}

interface WsfGraphNode
{
     method get_xywh();
     method set_xy(x, y);
     method get_links();
     method set_link(trg);
     method get_color();
     method get_html();
}


load "wsf_menu";

object WsfMenu WsfComponent
{
     var nojsmenu = 0;
     var size_x = 200;
     var size_y = 25;

     method main();
     method get_html();
     method init(menu_data, %options);
}


load "wsf_switch";

object WsfSwitch WsfComponent
{
     var cases;

     method main() ;
     method switch_code(code);
     method switch_href(i) ;
     method switch_reset() ;
}


load "xml";

builtin xml_parse(xml_text,load_dtd,substitute_entities);
builtin xml_dump(xmldoc);
builtin xml_xslt_text(xmldoc, stylesheet, %params);
builtin xml_xslt_xml(xmldoc, stylesheet, %params);

object XmlEx
{
     var description;
}


Generated by SPLDOC. http://www.clifford.at/spl/