static void
init_cursors(void) {
static char zchar[1];
Pixmap pix;
XColor black, dummy;
create_cursor(CurNormal, XC_left_ptr);
create_cursor(CurNECorner, XC_top_right_corner);
create_cursor(CurNWCorner, XC_top_left_corner);
create_cursor(CurSECorner, XC_bottom_right_corner);
create_cursor(CurSWCorner, XC_bottom_left_corner);
create_cursor(CurMove, XC_fleur);
create_cursor(CurDHArrow, XC_sb_h_double_arrow);
create_cursor(CurInput, XC_xterm);
create_cursor(CurSizing, XC_sizing);
create_cursor(CurIcon, XC_icon);
XAllocNamedColor(display, scr.colormap,
"black", &black, &dummy);
pix = XCreateBitmapFromData(
display, scr.root.w,
zchar, 1, 1);
cursor[CurNone] = XCreatePixmapCursor(display,
pix, pix,
&black, &black,
0, 0);
XFreePixmap(display, pix);
}
/***********************************************************************
* set_window_cursor
*/
void set_window_cursor( struct x11drv_win_data *data, HCURSOR handle )
{
Cursor cursor, prev;
wine_tsx11_lock();
if (!handle) cursor = get_empty_cursor();
else if (!cursor_context || XFindContext( gdi_display, (XID)handle, cursor_context, (char **)&cursor ))
{
/* try to create it */
wine_tsx11_unlock();
if (!(cursor = create_cursor( handle ))) return;
wine_tsx11_lock();
if (!cursor_context) cursor_context = XUniqueContext();
if (!XFindContext( gdi_display, (XID)handle, cursor_context, (char **)&prev ))
{
/* someone else was here first */
XFreeCursor( gdi_display, cursor );
cursor = prev;
}
else
{
XSaveContext( gdi_display, (XID)handle, cursor_context, (char *)cursor );
TRACE( "cursor %p created %lx\n", handle, cursor );
}
}
XDefineCursor( gdi_display, data->whole_window, cursor );
/* make the change take effect immediately */
XFlush( gdi_display );
data->cursor = handle;
wine_tsx11_unlock();
}
static void
scroll_button_press(ScrollTool *tool, GdkEventButton *event,
DDisplay *ddisp)
{
Point clickedpoint;
tool->use_hand = (event->state & GDK_SHIFT_MASK) != 0;
if (tool->use_hand) {
if (!closed_hand_cursor)
closed_hand_cursor = create_cursor(ddisp->canvas->window,
hand_closed_data_bits,
hand_closed_data_width,
hand_closed_data_height,
hand_closed_mask_bits,
hand_closed_data_width/2,
hand_closed_data_height/2);
ddisplay_set_all_cursor(closed_hand_cursor);
} else
ddisplay_set_all_cursor(scroll_cursor);
ddisplay_untransform_coords(ddisp,
(int)event->x, (int)event->y,
&clickedpoint.x, &clickedpoint.y);
tool->scrolling = TRUE;
tool->last_pos = clickedpoint;
}
/*
** Execute an SQL statement.
** Return a Cursor object if the statement is a query, otherwise
** return the number of tuples affected by the statement.
*/
static int conn_execute (lua_State *L) {
conn_data *conn = getconnection (L);
const char *statement = luaL_checkstring (L, 2);
unsigned long st_len = strlen(statement);
if (mysql_real_query(conn->my_conn, statement, st_len))
/* error executing query */
return luasql_failmessage(L, "Error executing query. MySQL: ", mysql_error(conn->my_conn));
else
{
MYSQL_RES *res = mysql_store_result(conn->my_conn);
unsigned int num_cols = mysql_field_count(conn->my_conn);
if (res) { /* tuples returned */
return create_cursor (L, 1, res, num_cols);
}
else { /* mysql_use_result() returned nothing; should it have? */
if(num_cols == 0) { /* no tuples returned */
/* query does not return data (it was not a SELECT) */
lua_pushnumber(L, mysql_affected_rows(conn->my_conn));
return 1;
}
else /* mysql_use_result() should have returned data */
return luasql_failmessage(L, "Error retrieving result. MySQL: ", mysql_error(conn->my_conn));
}
}
}
/*
** Execute an SQL statement.
** Return a Cursor object if the statement is a query, otherwise
** return the number of tuples affected by the statement.
*/
static int conn_execute (lua_State *L) {
env_data *env;
conn_data *conn = getconnection (L);
const char *statement = luaL_checkstring (L, 2);
sword status;
ub4 prefetch = 0;
ub4 iters;
ub4 mode;
ub2 type;
OCIStmt *stmthp;
/* get environment */
lua_rawgeti (L, LUA_REGISTRYINDEX, conn->env);
if (!lua_isuserdata (L, -1))
luaL_error(L,LUASQL_PREFIX"invalid environment in connection!");
env = (env_data *)lua_touserdata (L, -1);
/* statement handle */
ASSERT (L, OCIHandleAlloc ((dvoid *)env->envhp, (dvoid **)&stmthp,
OCI_HTYPE_STMT, (size_t)0, (dvoid **)0), conn->errhp);
ASSERT (L, OCIAttrSet ((dvoid *)stmthp, (ub4)OCI_HTYPE_STMT,
(dvoid *)&prefetch, (ub4)0, (ub4)OCI_ATTR_PREFETCH_ROWS,
conn->errhp), conn->errhp);
ASSERT (L, OCIStmtPrepare (stmthp, conn->errhp, (text *)statement,
(ub4) strlen(statement), (ub4) OCI_NTV_SYNTAX, (ub4) OCI_DEFAULT),
conn->errhp);
/* statement type */
ASSERT (L, OCIAttrGet ((dvoid *)stmthp, (ub4) OCI_HTYPE_STMT,
(dvoid *)&type, (ub4 *)0, (ub4)OCI_ATTR_STMT_TYPE, conn->errhp),
conn->errhp);
if (type == OCI_STMT_SELECT)
iters = 0;
else
iters = 1;
if (conn->auto_commit)
mode = OCI_COMMIT_ON_SUCCESS;
else
mode = OCI_DEFAULT;
/* execute statement */
status = OCIStmtExecute (conn->svchp, stmthp, conn->errhp, iters,
(ub4)0, (CONST OCISnapshot *)NULL, (OCISnapshot *)NULL, mode);
if (status && (status != OCI_NO_DATA)) {
OCIHandleFree ((dvoid *)stmthp, OCI_HTYPE_STMT);
return checkerr (L, status, conn->errhp);
}
if (type == OCI_STMT_SELECT) {
/* create cursor */
return create_cursor (L, 1, conn, stmthp, statement);
} else {
/* return number of rows */
int rows_affected;
ASSERT (L, OCIAttrGet ((dvoid *)stmthp, (ub4)OCI_HTYPE_STMT,
(dvoid *)&rows_affected, (ub4 *)0,
(ub4)OCI_ATTR_ROW_COUNT, conn->errhp), conn->errhp);
OCIHandleFree ((dvoid *)stmthp, OCI_HTYPE_STMT);
lua_pushnumber (L, rows_affected);
return 1;
}
}
static SDL_Cursor* get_cursor(cursor::CURSOR_TYPE type)
{
if(cache[type] == NULL) {
static const std::string prefix = "cursors-bw/";
const surface surf(image::get_image(prefix + color_images[type]));
cache[type] = create_cursor(surf);
}
return cache[type];
}
static void
scroll_motion(ScrollTool *tool, GdkEventMotion *event,
DDisplay *ddisp)
{
Point to;
Point delta;
/* set the cursor appropriately, and change use_hand if needed */
if (!tool->scrolling) {
/* try to minimise the number of cursor type changes */
if ((event->state & GDK_SHIFT_MASK) != 0) {
if (!tool->use_hand) {
tool->use_hand = TRUE;
if (!open_hand_cursor)
open_hand_cursor = create_cursor(ddisp->canvas->window,
hand_open_data_bits,
hand_open_data_width,
hand_open_data_height,
hand_open_mask_bits,
hand_open_data_width/2,
hand_open_data_height/2);
ddisplay_set_all_cursor(open_hand_cursor);
}
} else
if (tool->use_hand) {
tool->use_hand = FALSE;
ddisplay_set_all_cursor(scroll_cursor);
}
return;
}
ddisplay_untransform_coords(ddisp, event->x, event->y, &to.x, &to.y);
if (tool->use_hand) {
delta = tool->last_pos;
point_sub(&delta, &to);
tool->last_pos = to;
point_add(&tool->last_pos, &delta);
/* we use this so you can scroll past the edge of the image */
point_add(&delta, &ddisp->origo);
ddisplay_set_origo(ddisp, delta.x, delta.y);
ddisplay_update_scrollbars(ddisp);
ddisplay_add_update_all(ddisp);
} else {
delta = to;
point_sub(&delta, &tool->last_pos);
point_scale(&delta, 0.5);
ddisplay_scroll(ddisp, &delta);
tool->last_pos = to;
}
ddisplay_flush(ddisp);
}
/*
** Executes a SQL statement.
** Returns
** cursor object: if there are results or
** row count: number of rows affected by statement if no results
*/
static int conn_execute (lua_State *L) {
conn_data *conn = (conn_data *) getconnection (L);
const char *statement = luaL_checkstring(L, 2);
SQLHDBC hdbc = conn->hdbc;
SQLHSTMT hstmt;
SQLSMALLINT numcols;
SQLRETURN ret;
ret = SQLAllocHandle(hSTMT, hdbc, &hstmt);
if (error(ret))
return fail(L, hDBC, hdbc);
ret = SQLPrepare(hstmt, (char *) statement, SQL_NTS);
if (error(ret)) {
ret = fail(L, hSTMT, hstmt);
SQLFreeHandle(hSTMT, hstmt);
return ret;
}
/* execute the statement */
ret = SQLExecute (hstmt);
if (error(ret)) {
ret = fail(L, hSTMT, hstmt);
SQLFreeHandle(hSTMT, hstmt);
return ret;
}
/* determine the number of results */
ret = SQLNumResultCols (hstmt, &numcols);
if (error(ret)) {
ret = fail(L, hSTMT, hstmt);
SQLFreeHandle(hSTMT, hstmt);
return ret;
}
if (numcols > 0)
/* if there is a results table (e.g., SELECT) */
return create_cursor (L, 1, conn, hstmt, numcols);
else {
/* if action has no results (e.g., UPDATE) */
SQLINTEGER numrows;
ret = SQLRowCount(hstmt, &numrows);
if (error(ret)) {
ret = fail(L, hSTMT, hstmt);
SQLFreeHandle(hSTMT, hstmt);
return ret;
}
lua_pushnumber(L, numrows);
SQLFreeHandle(hSTMT, hstmt);
return 1;
}
}
/*
** Execute an SQL statement.
** Return a Cursor object if the statement is a query, otherwise
** return the number of tuples affected by the statement.
*/
static int conn_execute(lua_State *L)
{
conn_data *conn = getconnection(L);
const char *statement = luaL_checkstring(L, 2);
int res;
sqlite3_stmt *vm;
const char *errmsg;
int numcols;
const char *tail;
res = sqlite3_prepare(conn->sql_conn, statement, -1, &vm, &tail);
if (res != SQLITE_OK)
{
errmsg = sqlite3_errmsg(conn->sql_conn);
lua_pushnil(L);
lua_pushliteral(L, LUASQL_PREFIX);
lua_pushstring(L, errmsg);
lua_concat(L, 2);
return 2;
}
/* process first result to retrive query information and type */
res = sqlite3_step(vm);
numcols = sqlite3_column_count(vm);
/* real query? if empty, must have numcols!=0 */
if ((res == SQLITE_ROW) || ((res == SQLITE_DONE) && numcols))
{
sqlite3_reset(vm);
return create_cursor(L, 1, conn, vm, numcols);
}
if (res == SQLITE_DONE) /* and numcols==0, INSERT,UPDATE,DELETE statement */
{
sqlite3_finalize(vm);
/* return number of columns changed */
lua_pushnumber(L, sqlite3_changes(conn->sql_conn));
return 1;
}
/* error */
errmsg = sqlite3_errmsg(sqlite3_db_handle(vm));
sqlite3_finalize(vm);
lua_pushnil(L);
lua_pushliteral(L, LUASQL_PREFIX);
lua_pushstring(L, errmsg);
lua_concat(L, 2);
return 2;
}
/*
** Execute an SQL statement.
** Return a Cursor object if the statement is a query, otherwise
** return the number of tuples affected by the statement.
*/
static int conn_execute(lua_State *L)
{
conn_data *conn = getconnection(L);
const char *statement = luaL_checkstring(L, 2);
int res;
sqlite_vm *vm;
char *errmsg;
int numcols;
const char **col_info;
res = sqlite_compile(conn->sql_conn, statement, NULL, &vm, &errmsg);
if (res != SQLITE_OK)
{
lua_pushnil(L);
lua_pushliteral(L, LUASQL_PREFIX);
lua_pushstring(L, errmsg);
sqlite_freemem(errmsg);
lua_concat(L, 2);
return 2;
}
/* process first result to retrive query information and type */
res = sqlite_step(vm, &numcols, NULL, &col_info);
/* real query? if empty, must have numcols!=0 */
if ((res == SQLITE_ROW) || ((res == SQLITE_DONE) && numcols))
{
sqlite_reset(vm, NULL);
return create_cursor(L, 1, conn, vm, numcols, col_info);
}
if (res == SQLITE_DONE) /* and numcols==0, INSERT,UPDATE,DELETE statement */
{
sqlite_finalize(vm, NULL);
/* return number of columns changed */
lua_pushnumber(L, sqlite_changes(conn->sql_conn));
return 1;
}
/* error */
sqlite_finalize(vm, &errmsg);
lua_pushnil(L);
lua_pushliteral(L, LUASQL_PREFIX);
lua_pushstring(L, errmsg);
sqlite_freemem(errmsg);
lua_concat(L, 2);
return 2;
}
bool_t create_lessui(lessui_t *ui) {
bool_t ok = TRUE;
if( ui ) {
ok &= create_cursor(&ui->cursor);
ok &= create_cursormanager(&ui->cmg);
ok &= create_cursorrep(&ui->cr);
ok &= create_display(&ui->display);
if( ok ) {
/* toggle_display(&ui->display, DISPLAY_WRAP); */
/* toggle_display(&ui->display, DISPLAY_ATTRIBUTES); */
}
return ok;
}
return FALSE;
}
Bool
apc_pointer_set_user( Handle self, Handle icon, Point hot_spot)
{
DEFXX;
if ( XX-> user_pointer != None) {
XFreeCursor( DISP, XX-> user_pointer);
XX-> user_pointer = None;
}
if ( XX-> user_p_source != None) {
XFreePixmap( DISP, XX-> user_p_source);
XX-> user_p_source = None;
}
if ( XX-> user_p_mask != None) {
XFreePixmap( DISP, XX-> user_p_mask);
XX-> user_p_mask = None;
}
#ifdef HAVE_X11_XCURSOR_XCURSOR_H
if ( XX-> user_xcursor != NULL) {
XcursorImageDestroy(XX-> user_xcursor);
XX-> user_xcursor = NULL;
}
#endif
if ( icon != nilHandle) {
Bool ok = create_cursor(self, icon, hot_spot);
if ( !ok ) return false;
if ( XX-> pointer_id == crUser && self != application) {
if ( guts. pointer_invisible_count < 0) {
if ( !XX-> flags. pointer_obscured) {
XDefineCursor( DISP, XX-> udrawable, prima_null_pointer());
XX-> flags. pointer_obscured = 1;
}
} else {
XDefineCursor( DISP, XX-> udrawable, XX-> user_pointer);
XX-> flags. pointer_obscured = 0;
}
XCHECKPOINT;
}
}
XFlush( DISP);
if ( guts. grab_widget)
apc_widget_set_capture( guts. grab_widget, true, guts. grab_confine);
return true;
}
int seqed_reg(Tcl_Interp *interp,
char *seqed_win,
int seq_num,
tkSeqed *se)
{
int id;
SeqedResult *seqed_result;
char *colour;
seq_cursor_notify cn;
int line_width;
if (NULL == (seqed_result = (SeqedResult *)xmalloc(sizeof(SeqedResult))))
return -1;
seqed_result->op_func = seqed_callback;
seqed_result->seq_id = GetSeqId(seq_num);
strcpy(seqed_result->seqed_win, seqed_win);
seqed_result->interp = interp;
id = get_reg_id();
seqed_result->index = id;
line_width = get_default_int(interp, spin_defs,
w("SEQ.CURSOR.LINE_WIDTH"));
colour = get_raster_colour();
se->rid = id;
se->seq_id = GetSeqId(seq_num);
strcpy(se->cursorCol, colour);
se->cursor = create_cursor(seq_num, 1, NULL, line_width, 1, HORIZONTAL);
se->cursor_visible = 0;
se->prev_pos = se->cursor->abspos;
se->cursor->abspos = se->cursorPos;
seq_register(seq_num, seqed_callback, (void *)seqed_result, SEQ_SEQED,
id);
cn.job = SEQ_CURSOR_NOTIFY;
cn.cursor = se->cursor;
cn.cursor->job = CURSOR_MOVE;
seq_notify(seq_num, (seq_reg_data *)&cn);
return id;
}
static int conn_execute(lua_State* L)
{
Connection* conn = check_conn(L);
luaL_argcheck(L, conn && !conn->closed, 1, "invalid Connection object");
size_t length = 0;
const char* stmt = luaL_checklstring(L, 2, &length);
const char* fetch_opt = lua_tostring(L, 3);
int fetch_all = 1;
if (fetch_opt)
{
if (strcmp(fetch_opt, "store") == 0)
fetch_all = 1;
else if (strcmp(fetch_opt, "use") == 0)
fetch_all = 0;
}
MYSQL* my_conn = &conn->my_conn;
int err = mysql_real_query(my_conn, stmt, (unsigned long)length);
if (err != 0)
{
return luaL_error(L, "%d: %s\n", err, mysql_error(my_conn));
}
MYSQL_RES* res = NULL;
if (fetch_all)
res = mysql_store_result(my_conn);
else
res = mysql_use_result(my_conn);
unsigned int numcols = mysql_field_count(my_conn);
if (res)
{
return create_cursor(L, 1, res, numcols, fetch_all);
}
else
{
if (numcols == 0) // query does not return data (not SELECT)
{
lua_pushinteger(L, (lua_Integer)mysql_affected_rows(my_conn));
return 1;
}
}
return 0;
}
/*
** Execute an SQL statement.
** Return a Cursor object if the statement is a query, otherwise
** return the number of tuples affected by the statement.
*/
static int conn_execute (lua_State *L) {
conn_data *conn = getconnection (L);
const char *statement = luaL_checkstring (L, 2);
PGresult *res = PQexec(conn->pg_conn, statement);
if (res && PQresultStatus(res)==PGRES_COMMAND_OK) {
/* no tuples returned */
lua_pushnumber(L, atof(PQcmdTuples(res)));
PQclear (res);
return 1;
}
else if (res && PQresultStatus(res)==PGRES_TUPLES_OK)
/* tuples returned */
return create_cursor (L, 1, res);
else {
/* error */
PQclear (res);
return luasql_failmsg(L, "error executing statement. PostgreSQL: ", PQerrorMessage(conn->pg_conn));
}
}
static void
scroll_button_release(ScrollTool *tool, GdkEventButton *event,
DDisplay *ddisp)
{
tool->use_hand = (event->state & GDK_SHIFT_MASK) != 0;
if (tool->use_hand) {
if (!open_hand_cursor)
open_hand_cursor = create_cursor(ddisp->canvas->window,
hand_open_data_bits,
hand_open_data_width,
hand_open_data_height,
hand_open_mask_bits,
hand_open_data_width/2,
hand_open_data_height/2);
ddisplay_set_all_cursor(open_hand_cursor);
} else
ddisplay_set_all_cursor(scroll_cursor);
tool->scrolling = FALSE;
}
GdkCursor *
get_cursor(DiaCursorType ctype)
{
if (ctype >= G_N_ELEMENTS (cursors)) {
return NULL;
}
if (cursors[ctype].cursor == NULL) {
GdkCursor *new_cursor = NULL;
if (cursors[ctype].gdk_cursor_number != DIA_CURSOR) {
new_cursor = gdk_cursor_new(cursors[ctype].gdk_cursor_number);
} else {
DDisplay *active_display = ddisplay_active ();
if (active_display != NULL)
new_cursor = create_cursor(gtk_widget_get_window(active_display->canvas),
cursors[ctype].data,
cursors[ctype].hot_x,
cursors[ctype].hot_y);
}
cursors[ctype].cursor = new_cursor;
}
return cursors[ctype].cursor;
}
CursorProvider_Win32::CursorProvider_Win32(const CursorDescription &cursor_description)
: handle(0)
{
handle = create_cursor(cursor_description);
}
void test_cursor() {
// Create a table named "Table".
auto db = grnxx::open_db("");
auto table = db->create_table("Table");
// Insert rows.
constexpr size_t NUM_ROWS = 1 << 16;
for (size_t i = 0; i < NUM_ROWS; ++i) {
table->insert_row();
}
// Test a cursor with the default options.
auto cursor = table->create_cursor();
grnxx::Array<grnxx::Record> records;
assert(cursor->read(0, &records) == 0);
assert(records.is_empty());
assert(cursor->read(NUM_ROWS / 2, &records) == (NUM_ROWS / 2));
assert(records.size() == (NUM_ROWS / 2));
assert(cursor->read_all(&records) == (NUM_ROWS / 2));
assert(records.size() == NUM_ROWS);
for (size_t i = 0; i < NUM_ROWS; ++i) {
grnxx::Int exptected_row_id(i);
assert(records[i].row_id.match(exptected_row_id));
assert(records[i].score.raw() == 0.0);
}
records.clear();
// Test a cursor that scans a table in reverse order.
grnxx::CursorOptions cursor_options;
cursor_options.order_type = GRNXX_REVERSE_ORDER;
cursor = table->create_cursor(cursor_options);
assert(cursor->read_all(&records) == NUM_ROWS);
assert(records.size() == NUM_ROWS);
for (size_t i = 0; i < NUM_ROWS; ++i) {
grnxx::Int exptected_row_id(NUM_ROWS - i - 1);
assert(records[i].row_id.match(exptected_row_id));
assert(records[i].score.raw() == 0.0);
}
records.clear();
// Remove 98.4375% rows.
std::mt19937 rng;
std::vector<grnxx::Int> row_ids;
for (size_t i = 0; i < NUM_ROWS; ++i) {
grnxx::Int row_id(i);
if ((rng() % 64) != 0) {
table->remove_row(row_id);
} else {
row_ids.push_back(row_id);
}
}
// Test a cursor with the default options.
cursor = table->create_cursor();
assert(cursor->read_all(&records) == row_ids.size());
for (size_t i = 0; i < row_ids.size(); ++i) {
assert(records[i].row_id.match(row_ids[i]));
}
records.clear();
// Test a cursor that scans a table in reverse order.
cursor = table->create_cursor(cursor_options);
assert(cursor->read_all(&records) == row_ids.size());
for (size_t i = 0; i < row_ids.size(); ++i) {
assert(records[i].row_id.match(row_ids[row_ids.size() - i - 1]));
}
records.clear();
}
/**
* Initialise atari gui.
*/
static void gui_init(int argc, char** argv)
{
char buf[PATH_MAX];
OBJECT * cursors;
atari_find_resource(buf, "netsurf.rsc", "./res/netsurf.rsc");
LOG("Using RSC file: %s ", (char *)&buf);
if (rsrc_load(buf)==0) {
char msg[1024];
snprintf(msg, 1024, "Unable to open GEM Resource file (%s)!", buf);
die(msg);
}
wind_get_grect(0, WF_WORKXYWH, &desk_area);
create_cursor(0, POINT_HAND, NULL, &gem_cursors.hand );
create_cursor(0, TEXT_CRSR, NULL, &gem_cursors.ibeam );
create_cursor(0, THIN_CROSS, NULL, &gem_cursors.cross);
create_cursor(0, BUSY_BEE, NULL, &gem_cursors.wait);
create_cursor(0, ARROW, NULL, &gem_cursors.arrow);
create_cursor(0, OUTLN_CROSS, NULL, &gem_cursors.sizeall);
create_cursor(0, OUTLN_CROSS, NULL, &gem_cursors.sizenesw);
create_cursor(0, OUTLN_CROSS, NULL, &gem_cursors.sizenwse);
cursors = gemtk_obj_get_tree(CURSOR);
create_cursor(MFORM_EX_FLAG_USERFORM, CURSOR_APPSTART,
cursors, &gem_cursors.appstarting);
gem_set_cursor( &gem_cursors.appstarting );
create_cursor(MFORM_EX_FLAG_USERFORM, CURSOR_SIZEWE,
cursors, &gem_cursors.sizewe);
create_cursor(MFORM_EX_FLAG_USERFORM, CURSOR_SIZENS,
cursors, &gem_cursors.sizens);
create_cursor(MFORM_EX_FLAG_USERFORM, CURSOR_NODROP,
cursors, &gem_cursors.nodrop);
create_cursor(MFORM_EX_FLAG_USERFORM, CURSOR_DENY,
cursors, &gem_cursors.deny);
create_cursor(MFORM_EX_FLAG_USERFORM, CURSOR_MENU,
cursors, &gem_cursors.menu);
create_cursor(MFORM_EX_FLAG_USERFORM, CURSOR_HELP,
cursors, &gem_cursors.help);
LOG("Enabling core select menu");
nsoption_set_bool(core_select_menu, true);
LOG("Loading url.db from: %s", nsoption_charp(url_file));
if( strlen(nsoption_charp(url_file)) ) {
urldb_load(nsoption_charp(url_file));
}
LOG("Loading cookies from: %s", nsoption_charp(cookie_file));
if( strlen(nsoption_charp(cookie_file)) ) {
urldb_load_cookies(nsoption_charp(cookie_file));
}
if (process_cmdline(argc,argv) != true)
die("unable to process command line.\n");
LOG("Initializing NKC...");
nkc_init();
LOG("Initializing plotters...");
plot_init(nsoption_charp(atari_font_driver));
aes_event_in.emi_m1leave = MO_LEAVE;
aes_event_in.emi_m1.g_w = 1;
aes_event_in.emi_m1.g_h = 1;
//next_poll = clock() + (CLOCKS_PER_SEC>>3);
deskmenu_init();
menu_register( -1, theapp);
if (sys_type() & (SYS_MAGIC|SYS_NAES|SYS_XAAES)) {
menu_register( _AESapid, (char*)" NetSurf ");
}
gemtk_wm_init();
/* Initialize the specific treeview windows: */
atari_global_history_init();
atari_hotlist_init();
atari_cookie_manager_init();
/* Initialize the toolbar framework: */
toolbar_init();
}
int main(int argc, char *argv[]) {
setlocale(LC_TIME, "ru_RU.UTF-8");
char *username;
char *image_path = NULL;
int ret;
struct pam_conv conv = {conv_callback, NULL};
int curs_choice = CURS_NONE;
int o;
int optind = 0;
struct option longopts[] = {
{"version", no_argument, NULL, 'v'},
{"nofork", no_argument, NULL, 'n'},
{"beep", no_argument, NULL, 'b'},
{"dpms", no_argument, NULL, 'd'},
{"color", required_argument, NULL, 'c'},
{"pointer", required_argument, NULL , 'p'},
{"debug", no_argument, NULL, 0},
{"help", no_argument, NULL, 'h'},
{"no-unlock-indicator", no_argument, NULL, 'u'},
{"image", required_argument, NULL, 'i'},
{"tiling", no_argument, NULL, 't'},
{"auth-fail-command", required_argument, NULL, 'f'},
{"auth-done-command", required_argument, NULL, 'o'},
{NULL, no_argument, NULL, 0}
};
if ((username = getenv("USER")) == NULL)
errx(1, "USER environment variable not set, please set it.\n");
while ((o = getopt_long(argc, argv, "hvnbdc:p:ui:f:o:t", longopts, &optind)) != -1) {
switch (o) {
case 'v':
errx(EXIT_SUCCESS, "version " VERSION " © 2010-2012 Michael Stapelberg");
case 'n':
dont_fork = true;
break;
case 'b':
beep = true;
break;
case 'd':
dpms = true;
break;
case 'c': {
char *arg = optarg;
/* Skip # if present */
if (arg[0] == '#')
arg++;
if (strlen(arg) != 6 || sscanf(arg, "%06[0-9a-fA-F]", color) != 1)
errx(1, "color is invalid, it must be given in 3-byte hexadecimal format: rrggbb\n");
break;
}
case 'u':
unlock_indicator = false;
break;
case 'i':
image_path = strdup(optarg);
break;
case 't':
tile = true;
break;
case 'p':
if (!strcmp(optarg, "win")) {
curs_choice = CURS_WIN;
} else if (!strcmp(optarg, "default")) {
curs_choice = CURS_DEFAULT;
} else {
errx(1, "i3lock: Invalid pointer type given. Expected one of \"win\" or \"default\".\n");
}
break;
case 'f':
shell_auth_fail_command = strdup(optarg);
break;
case 'o':
shell_auth_done_command = strdup(optarg);
break;
case 'h':
show_time = false;
break;
case 0:
if (strcmp(longopts[optind].name, "debug") == 0)
debug_mode = true;
break;
default:
errx(1, "Syntax: i3lock [-v] [-n] [-b] [-d] [-c color] [-u] [-p win|default] [-h]"
" [-i image.png] [-t] [-f command] [-o command]"
);
}
}
/* We need (relatively) random numbers for highlighting a random part of
* the unlock indicator upon keypresses. */
srand(time(NULL));
/* Initialize PAM */
ret = pam_start("i3lock", username, &conv, &pam_handle);
if (ret != PAM_SUCCESS)
errx(EXIT_FAILURE, "PAM: %s", pam_strerror(pam_handle, ret));
/* Using mlock() as non-super-user seems only possible in Linux. Users of other
* operating systems should use encrypted swap/no swap (or remove the ifdef and
* run i3lock as super-user). */
#if defined(__linux__)
/* Lock the area where we store the password in memory, we don’t want it to
* be swapped to disk. Since Linux 2.6.9, this does not require any
* privileges, just enough bytes in the RLIMIT_MEMLOCK limit. */
if (mlock(password, sizeof(password)) != 0)
err(EXIT_FAILURE, "Could not lock page in memory, check RLIMIT_MEMLOCK");
#endif
/* Initialize connection to X11 */
if ((display = XOpenDisplay(NULL)) == NULL)
errx(EXIT_FAILURE, "Could not connect to X11, maybe you need to set DISPLAY?");
XSetEventQueueOwner(display, XCBOwnsEventQueue);
conn = XGetXCBConnection(display);
/* Double checking that connection is good and operatable with xcb */
if (xcb_connection_has_error(conn))
errx(EXIT_FAILURE, "Could not connect to X11, maybe you need to set DISPLAY?");
/* When we cannot initially load the keymap, we better exit */
if (!load_keymap())
errx(EXIT_FAILURE, "Could not load keymap");
xinerama_init();
xinerama_query_screens();
/* if DPMS is enabled, check if the X server really supports it */
if (dpms) {
xcb_dpms_capable_cookie_t dpmsc = xcb_dpms_capable(conn);
xcb_dpms_capable_reply_t *dpmsr;
if ((dpmsr = xcb_dpms_capable_reply(conn, dpmsc, NULL))) {
if (!dpmsr->capable) {
if (debug_mode)
fprintf(stderr, "Disabling DPMS, X server not DPMS capable\n");
dpms = false;
}
free(dpmsr);
}
}
screen = xcb_setup_roots_iterator(xcb_get_setup(conn)).data;
last_resolution[0] = screen->width_in_pixels;
last_resolution[1] = screen->height_in_pixels;
xcb_change_window_attributes(conn, screen->root, XCB_CW_EVENT_MASK,
(uint32_t[]){ XCB_EVENT_MASK_STRUCTURE_NOTIFY });
if (image_path) {
/* Create a pixmap to render on, fill it with the background color */
img = cairo_image_surface_create_from_png(image_path);
/* In case loading failed, we just pretend no -i was specified. */
if (cairo_surface_status(img) != CAIRO_STATUS_SUCCESS) {
fprintf(stderr, "Could not load image \"%s\": cairo surface status %d\n",
image_path, cairo_surface_status(img));
img = NULL;
}
}
/* Pixmap on which the image is rendered to (if any) */
xcb_pixmap_t bg_pixmap = draw_image(last_resolution);
/* open the fullscreen window, already with the correct pixmap in place */
win = open_fullscreen_window(conn, screen, color, bg_pixmap);
xcb_free_pixmap(conn, bg_pixmap);
cursor = create_cursor(conn, screen, win, curs_choice);
grab_pointer_and_keyboard(conn, screen, cursor);
if (dpms)
dpms_turn_off_screen(conn);
/* Initialize the libev event loop. */
main_loop = EV_DEFAULT;
if (main_loop == NULL)
errx(EXIT_FAILURE, "Could not initialize libev. Bad LIBEV_FLAGS?\n");
struct ev_io *xcb_watcher = calloc(sizeof(struct ev_io), 1);
struct ev_check *xcb_check = calloc(sizeof(struct ev_check), 1);
struct ev_prepare *xcb_prepare = calloc(sizeof(struct ev_prepare), 1);
ev_io_init(xcb_watcher, xcb_got_event, xcb_get_file_descriptor(conn), EV_READ);
ev_io_start(main_loop, xcb_watcher);
ev_check_init(xcb_check, xcb_check_cb);
ev_check_start(main_loop, xcb_check);
ev_prepare_init(xcb_prepare, xcb_prepare_cb);
ev_prepare_start(main_loop, xcb_prepare);
/* Invoke the event callback once to catch all the events which were
* received up until now. ev will only pick up new events (when the X11
* file descriptor becomes readable). */
ev_invoke(main_loop, xcb_check, 0);
if(show_time)
start_time_redraw_tick();
ev_loop(main_loop, 0);
}
static void gui_init(int argc, char** argv)
{
char buf[PATH_MAX];
OBJECT * cursors;
atari_find_resource(buf, "netsurf.rsc", "./res/netsurf.rsc");
LOG(("%s ", (char*)&buf));
if (rsrc_load(buf)==0) {
die("Uable to open GEM Resource file!");
}
wind_get_grect(0, WF_WORKXYWH, &desk_area);
create_cursor(0, POINT_HAND, NULL, &gem_cursors.hand );
create_cursor(0, TEXT_CRSR, NULL, &gem_cursors.ibeam );
create_cursor(0, THIN_CROSS, NULL, &gem_cursors.cross);
create_cursor(0, BUSY_BEE, NULL, &gem_cursors.wait);
create_cursor(0, ARROW, NULL, &gem_cursors.arrow);
create_cursor(0, OUTLN_CROSS, NULL, &gem_cursors.sizeall);
create_cursor(0, OUTLN_CROSS, NULL, &gem_cursors.sizenesw);
create_cursor(0, OUTLN_CROSS, NULL, &gem_cursors.sizenwse);
cursors = gemtk_obj_get_tree(CURSOR);
create_cursor(MFORM_EX_FLAG_USERFORM, CURSOR_APPSTART,
cursors, &gem_cursors.appstarting);
gem_set_cursor( &gem_cursors.appstarting );
create_cursor(MFORM_EX_FLAG_USERFORM, CURSOR_SIZEWE,
cursors, &gem_cursors.sizewe);
create_cursor(MFORM_EX_FLAG_USERFORM, CURSOR_SIZENS,
cursors, &gem_cursors.sizens);
create_cursor(MFORM_EX_FLAG_USERFORM, CURSOR_NODROP,
cursors, &gem_cursors.nodrop);
create_cursor(MFORM_EX_FLAG_USERFORM, CURSOR_DENY,
cursors, &gem_cursors.deny);
create_cursor(MFORM_EX_FLAG_USERFORM, CURSOR_MENU,
cursors, &gem_cursors.menu);
create_cursor(MFORM_EX_FLAG_USERFORM, CURSOR_HELP,
cursors, &gem_cursors.help);
LOG(("Enabling core select menu"));
nsoption_set_bool(core_select_menu, true);
LOG(("Loading url.db from: %s", nsoption_charp(url_file) ));
if( strlen(nsoption_charp(url_file)) ) {
urldb_load(nsoption_charp(url_file));
}
LOG(("Loading cookies from: %s", nsoption_charp(cookie_file) ));
if( strlen(nsoption_charp(cookie_file)) ) {
urldb_load_cookies(nsoption_charp(cookie_file));
}
if (process_cmdline(argc,argv) != true)
die("unable to process command line.\n");
LOG(("Initializing NKC..."));
nkc_init();
LOG(("Initializing plotters..."));
plot_init(nsoption_charp(atari_font_driver));
tree_set_icon_dir(nsoption_charp(tree_icons_path));
aes_event_in.emi_m1leave = MO_LEAVE;
aes_event_in.emi_m1.g_w = 1;
aes_event_in.emi_m1.g_h = 1;
//next_poll = clock() + (CLOCKS_PER_SEC>>3);
}
void test_scored_subexpression() {
// Create a database with the default options.
auto db = grnxx::open_db("");
// Create a table with the default options.
auto table = db->create_table("Table");
constexpr size_t NUM_ROWS = 1 << 16;
// Generate random values.
grnxx::Array<grnxx::Float> float_values;
grnxx::Array<grnxx::Int> ref_values;
float_values.resize(NUM_ROWS);
ref_values.resize(NUM_ROWS);
for (size_t i = 0; i < NUM_ROWS; ++i) {
float_values[i] = grnxx::Float(1.0 * rng() / rng.max());
// ref_values[i] = mersenne_twister() % NUM_ROWS;
ref_values[i] = grnxx::Int(0);
}
// Create columns for Float and Int values.
auto float_column = table->create_column("Float", GRNXX_FLOAT);
grnxx::ColumnOptions options;
options.reference_table_name = "Table";
auto ref_column = table->create_column("Ref", GRNXX_INT, options);
// Store generated values into columns.
for (size_t i = 0; i < NUM_ROWS; ++i) {
grnxx::Int row_id = table->insert_row();
assert(row_id.match(grnxx::Int(i)));
float_column->set(row_id, float_values[i]);
}
for (size_t i = 0; i < NUM_ROWS; ++i) {
ref_column->set(grnxx::Int(i), ref_values[i]);
}
// Generate a list of records.
grnxx::Array<grnxx::Record> records;
auto cursor = table->create_cursor();
assert(cursor->read_all(&records) == table->num_rows());
// Set scores (Float).
auto builder = grnxx::ExpressionBuilder::create(table);
builder->push_column("Float");
auto expression = builder->release();
expression->adjust(&records);
// Test an expression (Ref.(_score > 0.5)).
builder->push_column("Ref");
builder->begin_subexpression();
builder->push_score();
builder->push_constant(grnxx::Float(0.5));
builder->push_operator(GRNXX_GREATER);
builder->end_subexpression();
expression = builder->release();
expression->filter(&records);
size_t count = 0;
for (size_t i = 0; i < NUM_ROWS; ++i) {
if (float_values[i].raw() > 0.5) {
assert(records[count].row_id.match(grnxx::Int(i)));
++count;
}
}
assert(records.size() == count);
}
int main(int argc, char *argv[]) {
struct passwd *pw;
char *username;
char *image_path = NULL;
int ret;
struct pam_conv conv = {conv_callback, NULL};
int curs_choice = CURS_NONE;
int o;
int optind = 0;
struct option longopts[] = {
{"version", no_argument, NULL, 'v'},
{"nofork", no_argument, NULL, 'n'},
{"beep", no_argument, NULL, 'b'},
{"dpms", no_argument, NULL, 'd'},
{"color", required_argument, NULL, 'c'},
{"pointer", required_argument, NULL, 'p'},
{"debug", no_argument, NULL, 0},
{"help", no_argument, NULL, 'h'},
{"no-unlock-indicator", no_argument, NULL, 'u'},
{"image", required_argument, NULL, 'i'},
{"tiling", no_argument, NULL, 't'},
{"ignore-empty-password", no_argument, NULL, 'e'},
{"inactivity-timeout", required_argument, NULL, 'I'},
{"show-failed-attempts", no_argument, NULL, 'f'},
{NULL, no_argument, NULL, 0}
};
if ((pw = getpwuid(getuid())) == NULL)
err(EXIT_FAILURE, "getpwuid() failed");
if ((username = pw->pw_name) == NULL)
errx(EXIT_FAILURE, "pw->pw_name is NULL.\n");
char *optstring = "hvnbdc:p:ui:teI:f";
while ((o = getopt_long(argc, argv, optstring, longopts, &optind)) != -1) {
switch (o) {
case 'v':
errx(EXIT_SUCCESS, "version " VERSION " © 2010 Michael Stapelberg");
case 'n':
dont_fork = true;
break;
case 'b':
beep = true;
break;
case 'd':
fprintf(stderr, "DPMS support has been removed from i3lock. Please see the manpage i3lock(1).\n");
break;
case 'I': {
int time = 0;
if (sscanf(optarg, "%d", &time) != 1 || time < 0)
errx(EXIT_FAILURE, "invalid timeout, it must be a positive integer\n");
inactivity_timeout = time;
break;
}
case 'c': {
char *arg = optarg;
/* Skip # if present */
if (arg[0] == '#')
arg++;
if (strlen(arg) != 6 || sscanf(arg, "%06[0-9a-fA-F]", color) != 1)
errx(EXIT_FAILURE, "color is invalid, it must be given in 3-byte hexadecimal format: rrggbb\n");
break;
}
case 'u':
unlock_indicator = false;
break;
case 'i':
image_path = strdup(optarg);
break;
case 't':
tile = true;
break;
case 'p':
if (!strcmp(optarg, "win")) {
curs_choice = CURS_WIN;
} else if (!strcmp(optarg, "default")) {
curs_choice = CURS_DEFAULT;
} else {
errx(EXIT_FAILURE, "i3lock: Invalid pointer type given. Expected one of \"win\" or \"default\".\n");
}
break;
case 'e':
ignore_empty_password = true;
break;
case 0:
if (strcmp(longopts[optind].name, "debug") == 0)
debug_mode = true;
break;
case 'f':
show_failed_attempts = true;
break;
default:
errx(EXIT_FAILURE, "Syntax: i3lock [-v] [-n] [-b] [-d] [-c color] [-u] [-p win|default]"
" [-i image.png] [-t] [-e] [-I timeout] [-f]");
}
}
/* We need (relatively) random numbers for highlighting a random part of
* the unlock indicator upon keypresses. */
srand(time(NULL));
/* Initialize PAM */
ret = pam_start("i3lock", username, &conv, &pam_handle);
if (ret != PAM_SUCCESS)
errx(EXIT_FAILURE, "PAM: %s", pam_strerror(pam_handle, ret));
/* Using mlock() as non-super-user seems only possible in Linux. Users of other
* operating systems should use encrypted swap/no swap (or remove the ifdef and
* run i3lock as super-user). */
#if defined(__linux__)
/* Lock the area where we store the password in memory, we don’t want it to
* be swapped to disk. Since Linux 2.6.9, this does not require any
* privileges, just enough bytes in the RLIMIT_MEMLOCK limit. */
if (mlock(password, sizeof(password)) != 0)
err(EXIT_FAILURE, "Could not lock page in memory, check RLIMIT_MEMLOCK");
#endif
/* Double checking that connection is good and operatable with xcb */
int screennr;
if ((conn = xcb_connect(NULL, &screennr)) == NULL ||
xcb_connection_has_error(conn))
errx(EXIT_FAILURE, "Could not connect to X11, maybe you need to set DISPLAY?");
if (xkb_x11_setup_xkb_extension(conn,
XKB_X11_MIN_MAJOR_XKB_VERSION,
XKB_X11_MIN_MINOR_XKB_VERSION,
0,
NULL,
NULL,
&xkb_base_event,
&xkb_base_error) != 1)
errx(EXIT_FAILURE, "Could not setup XKB extension.");
static const xcb_xkb_map_part_t required_map_parts =
(XCB_XKB_MAP_PART_KEY_TYPES |
XCB_XKB_MAP_PART_KEY_SYMS |
XCB_XKB_MAP_PART_MODIFIER_MAP |
XCB_XKB_MAP_PART_EXPLICIT_COMPONENTS |
XCB_XKB_MAP_PART_KEY_ACTIONS |
XCB_XKB_MAP_PART_VIRTUAL_MODS |
XCB_XKB_MAP_PART_VIRTUAL_MOD_MAP);
static const xcb_xkb_event_type_t required_events =
(XCB_XKB_EVENT_TYPE_NEW_KEYBOARD_NOTIFY |
XCB_XKB_EVENT_TYPE_MAP_NOTIFY |
XCB_XKB_EVENT_TYPE_STATE_NOTIFY);
xcb_xkb_select_events(
conn,
xkb_x11_get_core_keyboard_device_id(conn),
required_events,
0,
required_events,
required_map_parts,
required_map_parts,
0);
/* When we cannot initially load the keymap, we better exit */
if (!load_keymap())
errx(EXIT_FAILURE, "Could not load keymap");
const char *locale = getenv("LC_ALL");
if (!locale)
locale = getenv("LC_CTYPE");
if (!locale)
locale = getenv("LANG");
if (!locale) {
if (debug_mode)
fprintf(stderr, "Can't detect your locale, fallback to C\n");
locale = "C";
}
load_compose_table(locale);
xinerama_init();
xinerama_query_screens();
screen = xcb_setup_roots_iterator(xcb_get_setup(conn)).data;
last_resolution[0] = screen->width_in_pixels;
last_resolution[1] = screen->height_in_pixels;
xcb_change_window_attributes(conn, screen->root, XCB_CW_EVENT_MASK,
(uint32_t[]) {
XCB_EVENT_MASK_STRUCTURE_NOTIFY
});
if (image_path) {
/* Create a pixmap to render on, fill it with the background color */
img = cairo_image_surface_create_from_png(image_path);
/* In case loading failed, we just pretend no -i was specified. */
if (cairo_surface_status(img) != CAIRO_STATUS_SUCCESS) {
fprintf(stderr, "Could not load image \"%s\": %s\n",
image_path, cairo_status_to_string(cairo_surface_status(img)));
img = NULL;
}
}
/* Pixmap on which the image is rendered to (if any) */
xcb_pixmap_t bg_pixmap = draw_image(last_resolution);
/* open the fullscreen window, already with the correct pixmap in place */
win = open_fullscreen_window(conn, screen, color, bg_pixmap);
xcb_free_pixmap(conn, bg_pixmap);
pid_t pid = fork();
/* The pid == -1 case is intentionally ignored here:
* While the child process is useful for preventing other windows from
* popping up while i3lock blocks, it is not critical. */
if (pid == 0) {
/* Child */
close(xcb_get_file_descriptor(conn));
raise_loop(win);
exit(EXIT_SUCCESS);
}
cursor = create_cursor(conn, screen, win, curs_choice);
grab_pointer_and_keyboard(conn, screen, cursor);
/* Load the keymap again to sync the current modifier state. Since we first
* loaded the keymap, there might have been changes, but starting from now,
* we should get all key presses/releases due to having grabbed the
* keyboard. */
(void)load_keymap();
/* Initialize the libev event loop. */
main_loop = EV_DEFAULT;
if (main_loop == NULL)
errx(EXIT_FAILURE, "Could not initialize libev. Bad LIBEV_FLAGS?\n");
struct ev_io *xcb_watcher = calloc(sizeof(struct ev_io), 1);
struct ev_check *xcb_check = calloc(sizeof(struct ev_check), 1);
struct ev_prepare *xcb_prepare = calloc(sizeof(struct ev_prepare), 1);
ev_io_init(xcb_watcher, xcb_got_event, xcb_get_file_descriptor(conn), EV_READ);
ev_io_start(main_loop, xcb_watcher);
ev_check_init(xcb_check, xcb_check_cb);
ev_check_start(main_loop, xcb_check);
ev_prepare_init(xcb_prepare, xcb_prepare_cb);
ev_prepare_start(main_loop, xcb_prepare);
/* Invoke the event callback once to catch all the events which were
* received up until now. ev will only pick up new events (when the X11
* file descriptor becomes readable). */
ev_invoke(main_loop, xcb_check, 0);
ev_loop(main_loop, 0);
}
int seqed_reg(Tcl_Interp *interp,
char *seqed_win,
int seq_num,
tkSeqed *se,
int pos,
int container_id,
char *c_win,
int element_id)
{
int id;
SeqedResult *seqed_result;
char *colour;
seq_cursor_notify cn;
int line_width;
element *e;
plot_data *result;
if (NULL == (seqed_result = (SeqedResult *)xmalloc(sizeof(SeqedResult))))
return -1;
if (NULL == (result = (plot_data *)xmalloc(sizeof(plot_data))))
return -1;
seqed_result->op_func = seqed_callback;
seqed_result->seq_id = GetSeqId(seq_num);
strcpy(seqed_result->seqed_win, seqed_win);
seqed_result->interp = interp;
id = get_reg_id();
seqed_result->index = id;
line_width = get_default_int(interp, spin_defs,
w("SEQ.CURSOR.LINE_WIDTH"));
se->rid = id;
se->seq_id = GetSeqId(seq_num);
colour = get_cursor_colour(se->rid);
strcpy(se->cursorCol, colour);
se->cursor = create_cursor(seq_num, 1, NULL, line_width, 1, HORIZONTAL, pos);
se->cursor_visible = 0;
se->prev_pos = se->cursor->abspos;
se->cursor->abspos = se->cursorPos;
if (NULL == (e = (get_element(element_id)))) {
e = create_element(interp, container_id, element_id, seqed_win, HORIZONTAL, -1);
}
seqed_result->e = e;
result->result_id = id;
result->amp_ruler = 0;
result->len_ruler = 0;
result->n_configure = 0;
result->sf_m = 1.0;
result->sf_c = 0.0;
result->scale = 0;
result->hidden = 0;
result->colour = NULL;
result->cursor = NULL;
set_seq_element_funcs(e);
add_seq_id_to_element(e, GetSeqId(seq_num), HORIZONTAL);
add_result_to_element(e, result, DBL_MAX, DBL_MAX, -DBL_MAX, -DBL_MAX, HORIZONTAL, SEQ_EDITOR);
add_element_to_container(interp, container_id, c_win, e,
INT_MAX, INT_MIN, INT_MAX, INT_MIN);
seq_register(seq_num, seqed_callback, (void *)seqed_result, SEQ_SEQED,
id);
seq_element_reg(interp, e);
cn.job = SEQ_CURSOR_NOTIFY;
cn.cursor = se->cursor;
cn.cursor->job = CURSOR_MOVE;
cn.show_all = 0;
seq_notify(seq_num, (seq_reg_data *)&cn);
return id;
}
