// scc [parameters] [host] [login] [password]
int main( int argc, char *argv[] )
{
int i;
int *a;
pstart();
a=dmalloc(sizeof(int));
/*
поддержка языков
*/
setlocale(LC_ALL,"");
bindtextdomain("sodaliscc","gettext");
textdomain("sodaliscc");
session=sod_init();
sod_assign_event(session,SOD_EV_DISCON,event_disconnect);
sod_assign_event(session,SOD_EV_ERROR,event_error);
sod_connect(session,"localhost",1986,"kane","passw");
while ( session->status!=SOD_AUTHORIZED );
sod_logout(session);
scanf("%d",&i);
sod_halt(session);
pstop();
return EXIT_SUCCESS;
}
kucode_t gfx_img_draw_adv( const gfx_image_t *img, gfx_imgmode_t mode,
int x, int y, int _x, int _y, int _w, int _h )
{
SDL_Rect rs, rd;
pstart();
ku_avoid(img == NULL);
rs.x = _x;
rs.y = _y;
rs.w = _w;
rs.h = _h;
if ( rs.w == 0 ) rs.w = img->w;
if ( rs.h == 0 ) rs.h = img->h;
if ( mode == GFX_IMG_PIECE )
{
rd.x = x;
rd.y = y;
} else
{
rd.x = x+rs.x;
rd.y = y+rs.y;
}
if ( SDL_BlitSurface((SDL_Surface*)img, &rs, gfx_screen, &rd) != 0 )
{
plogfn_i("IMAGE", gettext("Failed to draw an image: %s\n"), SDL_GetError());
KU_ERRQ(KE_EXTERNAL);
}
gfx_needs_update = 1;
preturn KE_NONE;
}
void
fg_proc_entry(struct process *pp)
{
jmp_buf_t osetexit;
int ohaderr;
Char oGettingInput;
size_t omark;
getexit(osetexit);
pintr_disabled++;
oGettingInput = GettingInput;
GettingInput = 0;
ohaderr = haderr; /* we need to ignore setting of haderr due to
* process getting stopped by a signal */
omark = cleanup_push_mark();
if (setexit() == 0) { /* come back here after pjwait */
pendjob();
(void) alarm(0); /* No autologout */
alrmcatch_disabled = 1;
if (!pstart(pp, 1)) {
pp->p_procid = 0;
stderror(ERR_BADJOB, pp->p_command, strerror(errno));
}
pjwait(pp);
}
setalarm(1); /* Autologout back on */
cleanup_pop_mark(omark);
resexit(osetexit);
haderr = ohaderr;
GettingInput = oGettingInput;
disabled_cleanup(&pintr_disabled);
}
kucode_t vspace_addv( vspace_t *space, const char *name, const char *val_types,
... )
{
var_t *var;
va_list ap;
pstart();
va_start(ap, val_types);
var = var_define_v(name, val_types, ap);
va_end(ap);
if ( var == NULL ) {
KU_ERRQ_PASS();
}
if ( space->vars == NULL ) {
space->vars = ku_abtree_create(var_compf, 0);
if ( space->vars == NULL ) {
KU_ERRQ_PASS();
}
if ( ku_abtree_ins(space->vars, var) != KE_NONE ) {
var_undef(var);
ku_abtree_free(space->vars, NULL);
space->vars = NULL;
KU_ERRQ_PASS();
}
} else if ( ku_abtree_ins(space->vars, var) != KE_NONE ) {
var_undef(var);
KU_ERRQ_PASS();
}
preturn KE_NONE;
}
int sod_halt( sod_session *session )
{
pstart();
if ( session->ecode!=SE_NONE )
{
#ifdef USE_GETTEXT
printf(gettext(vstr("WARNING: unmanaged error:\n\tfunction: %s\n\terror: %s\n\tcode: %d\n", \
session->errorfunc,session->errortext,session->ecode)));
#else
printf(vstr("WARNING: unmanaged error:\n\tfunction: %s\n\terror: %s\n\tcode: %d\n", \
session->errorfunc,session->errortext,session->ecode));
#endif
}
if ( session->status==SOD_CONNECTED )
{
sod_disconnect(session);
}
dfree(session);
pstop();
return SOD_OK;
}
// освобождение от загруженных данных
kucode_t button_uload( gui_obj_t *obj )
{
gui_button_t *const widget = (gui_button_t*)obj->widget;
pstart();
ku_avoid( obj->status == GUI_NOTLOADED );
KU_WITHOUT_ERROR_START();
ku_avoid( widget->back_nor_name == NULL );
if ( res_release(widget->back_nor_name) != KE_NONE )
plogfn(gettext("Object %u failed to release a background \"%s\": %d\n"), \
obj->id, widget->back_nor_name, KU_GET_ERROR());
if ( widget->back_mon && (res_release(widget->back_mon_name) != KE_NONE) )
plogfn(gettext("Object %u failed to release a mouse-on background \"%s\": %d\n"), \
obj->id, widget->back_mon_name, KU_GET_ERROR());
if ( widget->back_mdn && (res_release(widget->back_mdn_name) != KE_NONE) )
plogfn(gettext("Object %u failed to release a mouse-down background \"%s\": %d\n"), \
obj->id, widget->back_mdn_name, KU_GET_ERROR());
if ( widget->font && (res_release(widget->font_name) != KE_NONE) )
plogfn(gettext("Object %u failed to release a font \"%s\": %d\n"), \
obj->id, widget->font_name, KU_GET_ERROR());
if ( widget->fontface )
gfx_img_free(widget->fontface);
KU_WITHOUT_ERROR_STOP();
KU_ERRQ_BLOCKED();
}
kucode_t button_destroy( gui_obj_t *obj )
{
gui_button_t *const widget = (gui_button_t*)obj->widget;
pstart();
KU_WITHOUT_ERROR_START();
if ( obj->status > GUI_NOTLOADED )
button_uload(obj);
if ( widget->back_nor_name )
dfree(widget->back_nor_name);
if ( widget->back_mon_name )
dfree(widget->back_mon_name);
if ( widget->back_mdn_name )
dfree(widget->back_mdn_name);
if ( widget->font_name )
dfree(widget->font_name);
if ( widget->caption )
dfree(widget->caption);
KU_WITHOUT_ERROR_STOP();
KU_ERRQ_BLOCKED();
}
kucode_t vspace_adds( vspace_t *space, const char *name )
{
vspace_t *new_space;
pstart();
new_space = vspace_define(name);
if ( new_space == NULL ) {
KU_ERRQ_PASS();
}
if ( space->spaces == NULL ) {
space->spaces = ku_abtree_create(vspace_compf, 0);
if ( space->spaces == NULL ) {
KU_ERRQ_PASS();
}
if ( ku_abtree_ins(space->spaces, new_space) != KE_NONE ) {
vspace_undef(new_space);
ku_abtree_free(space->spaces, NULL);
space->spaces = NULL;
KU_ERRQ_PASS();
}
} else if ( ku_abtree_ins(space->spaces, new_space) != KE_NONE ) {
vspace_undef(new_space);
KU_ERRQ_PASS();
}
preturn KE_NONE;
}
static vspace_t *vspace_get_leaf( vspace_t *space, const char *path,
char **leaf )
{
char *p;
const char *cur = path;
static char buf[VSPACE_MAX_NODE_LEN];
vspace_t search_space;
pstart();
cur = path;
search_space.name = buf;
for ( ;; ) {
p = buf;
while ( (*cur != '/') && (*cur) ) {
*(p++) = *(cur++);
if ( p - buf >= VSPACE_MAX_NODE_LEN )
KU_ERRQNT_V(KE_FULL, NULL);
}
*p = 0;
if ( *cur == 0 )
break;
cur++;
space = ku_abtree_search(space->spaces, &search_space);
if ( space->spaces == NULL )
KU_ERRQNT_V(KE_NOTFOUND, NULL);
}
*leaf = buf;
preturn space;
}
kucode_t vspace_addv_l( vspace_t *space, const char *name, vlist_t *vlist )
{
var_t *var;
pstart();
var = var_define_l(name, vlist);
if ( var == NULL ) {
KU_ERRQ_PASS();
}
if ( space->vars == NULL ) {
space->vars = ku_abtree_create(var_compf, 0);
if ( space->vars == NULL ) {
KU_ERRQ_PASS();
}
if ( ku_abtree_ins(space->vars, var) != KE_NONE ) {
var_undef(var);
ku_abtree_free(space->vars, NULL);
space->vars = NULL;
KU_ERRQ_PASS();
}
} else if ( ku_abtree_ins(space->vars, var) != KE_NONE ) {
var_undef(var);
KU_ERRQ_PASS();
}
preturn KE_NONE;
}
kucode_t NAME(abtree_empty)( ABTREE *tree )
{
NODE *a=tree->ptr, *b;
pstart();
while ( a!=NULL )
{
b=a->left;
if ( b==NULL )
{
b=a->right;
if ( b==NULL )
{
b=a->parent;
if ( b!=NULL )
{
if ( b->left==a )
b->left=NULL; else b->right=NULL;
}
dfree(a);
}
}
a=b;
}
tree->ptr=NULL;
pstop();
return KE_NONE;
}
/*
* Termchar routine for command mode.
* Watch for possible switching to -nl mode.
* Otherwise flush into next level of buffering when
* small buffer fills or at a newline.
*/
int
termchar(int c)
{
if (pfast == 0 && phadnl)
pstart();
if (c == '\n')
phadnl = 1;
else if (linp >= &linb[63])
flush1();
#ifdef MB
if (mb_cur_max > 1 && c & ~(wchar_t)0177) {
char mb[MB_LEN_MAX];
int i, n;
n = wctomb(mb, c&TRIM);
for (i = 0; i < n; i++)
*linp++ = mb[i];
} else
#endif /* MB */
*linp++ = c;
if (linp >= &linb[63]) {
fgoto();
flush1();
}
return c;
}
void event_disconnect( sod_session *session, sod_event_t event, ... )
{
pstart();
printf("you are disconnected!\n");
exit(0);
pstop();
}
void event_error( sod_session *session, sod_event_t event, ... )
{
pstart();
printf("ERROR!!!\n");
printf("%s: %s (%d)\n",session->errorfunc,session->errortext,session->ecode);
session->ecode=SE_NONE;
pstop();
}
kucode_t gfx_add_image_resources( int resource_type, const char *resfile )
{
uint i = 0;
char img_id[CFG_BUFFER],
img_file[CFG_BUFFER];
kucode_t code;
cfg_session_t *cfg;
pstart();
if ( res_assign(resource_type, RESTYPE_ZFL, gfx_img_control) != KE_NONE )
{
plogfn(gettext("Failed to assign an image resource type: %d.\n"), KU_GET_ERROR());
preturn KU_GET_ERROR();
}
if ( (cfg = cfg_open(resfile, CFG_STRICT|CFG_STEP)) == NULL )
{
if ( KU_GET_ERROR() == KE_IO )
plogfn(gettext("Failed to open a file: %s.\n"), strerror(errno)); else
plogfn(gettext("Failed to open a file: %d.\n"), KU_GET_ERROR());
preturn KU_GET_ERROR();
}
if ( cfg_query(cfg, "image=ss/r", img_id, img_file) != KE_NONE )
{
plogfn(gettext("Failed to add a query for the resource file: %d.\n"), KU_GET_ERROR());
cfg_close(cfg);
preturn KU_GET_ERROR();
}
while ( (code = cfg_process(cfg)) == KE_SIGNAL )
{
if ( res_add(img_file, img_id, resource_type, NULL, 0) != KE_NONE )
{
plogfn(gettext("Failed to add an image resource (line %d): %d.\n"), \
cfg->cfg_line, KU_GET_ERROR());
cfg_close(cfg);
preturn KU_GET_ERROR();
}
i++;
}
if ( code != KE_NONE )
{
plogfn(gettext("Failed to process a resource file on line %d: %d.\n"), \
cfg->cfg_line, code);
cfg_close(cfg);
preturn code;
}
if ( cfg_close(cfg) != KE_NONE )
plogfn(gettext("Warning: failed to close a resource file: %d.\n"), KU_GET_ERROR());
plogfn(gettext("%d images added.\n"), i);
preturn KE_NONE;
}
kucode_t NAME(abtree_free)( ABTREE *tree )
{
pstart();
NAME(abtree_empty)(tree);
dfree(tree);
pstop();
return KE_NONE;
}
gui_event_st button_mdown( gui_obj_t *obj, int x, int y, int z )
{
gui_button_t *const widget = (gui_button_t*)obj->widget;
pstart();
button_ch_state(obj, BUTTON_MDN);
widget->st_mdown = 1;
preturn GUIE_EAT;
}
kucode_t gfx_img_draw( const gfx_image_t *img, int x, int y )
{
pstart();
_
preturn gfx_img_draw_adv(img, GFX_IMG_PIECE, x, y, 0, 0, 0, 0);
//glWindowPos2i(x, y);
//glDrawPixels(src->w, src->h, src->format, GL_UNSIGNED_BYTE, src->pixels);
//preturn KE_NONE;
}
gui_event_st button_moff( gui_obj_t *obj, int x, int y, int z )
{
gui_button_t *const widget = (gui_button_t*)obj->widget;
pstart();
if ( !widget->st_mdown )
button_ch_state(obj, BUTTON_NORM);
widget->st_mon = 0;
preturn GUIE_EAT;
}
var_t *var_define( const char *name, const char *val_types, ... )
{
var_t *var;
va_list ap;
pstart();
va_start(ap, val_types);
var = var_define_v(name, val_types, ap);
va_end(ap);
preturn var;
}
kucode_t vspace_undef( vspace_t *space )
{
pstart();
if ( space->vars != NULL )
ku_abtree_free(space->vars, var_freef);
if ( space->spaces != NULL )
ku_abtree_free(space->spaces, vspace_freef);
dfree(space);
preturn KE_NONE;
}
gfx_image_t *gfx_img_fromSDL( SDL_Surface *src )
{
gfx_image_t *img;
uint oldy, newy;
pstart();
preturn (gfx_image_t*)src;
SDL_LockSurface(src);
img = dmalloc(sizeof(gfx_image_t)+ \
src->pitch*src->h);
if ( img == NULL )
{
plogfn_i("IMAGE", gettext("Out of memory.\n"));
SDL_FreeSurface(src);
preturn NULL;
}
img->w = src->w;
img->h = src->h;
switch ( src->format->BitsPerPixel )
{
case 24:
{
img->format = GL_RGB;
break;
}
case 32:
{
img->format = GL_RGBA;
break;
}
default:
{
plogfn(gettext("Not supported image pixel format: %d bits.\n"), \
src->format->BitsPerPixel);
dfree(img);
return NULL;
}
}
img->pixels = (int8_t*)img+sizeof(gfx_image_t);
for ( oldy = img->h-1, newy = 0; newy < img->h; oldy--, newy++ )
memmove((int8_t*)(img->pixels)+newy*src->pitch, \
(int8_t*)(src->pixels)+oldy*src->pitch, \
src->pitch);
SDL_UnlockSurface(src);
SDL_FreeSurface(src);
preturn img;
}
kucode_t button_draw( gui_obj_t *obj, int x, int y )
{
gui_button_t *const widget = (gui_button_t*)obj->widget;
pstart();
if ( gfx_img_draw(widget->face, x, y) != KE_NONE )
KU_ERRQ_PASS();
if ( widget->fontface && (gfx_img_draw(widget->fontface, x+widget->font_rx, y+widget->font_ry) != KE_NONE) )
KU_ERRQ_PASS();
preturn KE_NONE;
}
/*
* Create a local process for the routine and start him executing.
* Also do all the initialization that is required.
* TODO - get rid of this.
*/
static AESPD *iprocess(BYTE *pname, PFVOID routine)
{
ULONG ldaddr;
KDEBUG(("iprocess(\"%s\")\n", (const char*)pname));
/* figure out load addr */
ldaddr = (ULONG) routine;
/* create process to execute it */
return pstart(routine, pname, ldaddr);
}
// загрузка данных кнопки
kucode_t button_load( gui_obj_t *obj )
{
gui_button_t *const widget = (gui_button_t*)obj->widget;
pstart();
ku_avoid( obj->status != GUI_NOTLOADED );
// загружаем главное изображение, не может быть NULL
ku_avoid( widget->back_nor_name == NULL );
obj->updated = BUTTON_UD_NORM;
/*
загружаем изображение активной кнопки,
если NULL, то используется нормальное изображение
*/
if ( widget->back_mon_name )
obj->updated |= BUTTON_UD_MON; else
widget->back_mon = NULL;
/*
загружаем изображение нажатой кнопки,
если NULL, то используется нормальное изображение
*/
if ( widget->back_mdn_name )
obj->updated |= BUTTON_UD_MDN; else
widget->back_mdn = NULL;
/*
загружаем шрифт текста кнопки,
если NULL, то кнопка не будет иметь текста
*/
if ( widget->font_name )
{
obj->updated |= BUTTON_UD_FONT;
// если установлен текст кнопки..
if ( widget->caption )
obj->updated |= BUTTON_UD_CAPTION; else
widget->fontface = NULL;
} else
{
widget->font = NULL;
widget->fontface = NULL;
}
if ( button_update(obj) != KE_NONE )
KU_ERRQ_PASS();
button_ch_state(obj, BUTTON_NORM);
preturn KE_NONE;
}
/*
* Create a local process for the routine and start him executing.
* Also do all the initialization that is required.
* TODO - get rid of this.
*/
static PD *iprocess(BYTE *pname, void (*routine)())
{
register ULONG ldaddr;
#if DBG_GEMINIT
kprintf("iprocess(\"%s\")\n", (const char*)pname);
#endif
/* figure out load addr */
ldaddr = (ULONG) routine;
/* create process to execute it */
return( pstart(routine, pname, ldaddr) );
}
gui_event_st button_mup( gui_obj_t *obj, int x, int y, int z )
{
gui_button_t *const widget = (gui_button_t*)obj->widget;
pstart();
widget->st_mdown = 0;
if ( widget->st_mon )
button_ch_state(obj, BUTTON_MON); else
button_ch_state(obj, BUTTON_NORM);
if ( widget->click && (widget->click(obj, (void*)z) != KE_NONE) )
preturn GUIE_ERROR;
preturn GUIE_EAT;
}
vspace_t *vspace_define( const char *name )
{
vspace_t *space;
pstart();
space = dmalloc(sizeof(vspace_t)+strlen(name)+1);
if ( space == NULL )
KU_ERRQNT_V(KE_MEMORY, NULL);
space->name = (char*)space + sizeof(vspace_t);
strcpy(space->name, name);
space->vars = space->spaces = NULL;
preturn space;
}
/*
* Termchar routine for command mode.
* Watch for possible switching to -nl mode.
* Otherwise flush into next level of buffering when
* small buffer fills or at a newline.
*/
void
termchar(int c)
{
if (pfast == 0 && phadnl)
pstart();
if (c == '\n')
phadnl = 1;
else if (linp >= &linb[63])
flush1();
*linp++ = c;
if (linp >= &linb[63]) {
fgoto();
flush1();
}
}
ABTREE *NAME(abtree_create)( void )
{
ABTREE *tree;
pstart();
tree=(ABTREE*)dmalloc(sizeof(ABTREE));
if ( tree==NULL )
{
kucode=KE_MEMORY;
return NULL;
}
tree->ptr=NULL;
pstop();
return tree;
}
