int clip_COM_INIT(ClipMachine * mp) { v24_port_t *gz; int ret = -1, *err; int fd = _clip_parni(mp, 1); int baud = 9600, data = 8, stop = 1; char *parity = "N"; if (fd < 1 || fd > 32) return EG_ARG; fd = keys[fd]; gz = (v24_port_t *) _clip_fetch_c_item(mp, fd, _C_ITEM_TYPE_COMPORT); if (!gz) return EG_ARG; if (_clip_parinfo(mp, 2) == NUMERIC_t) baud = _clip_parni(mp, 2); if (_clip_parinfo(mp, 3) == CHARACTER_t) parity = _clip_parc(mp, 3); if (_clip_parinfo(mp, 4) == NUMERIC_t) data = _clip_parni(mp, 4); if (_clip_parinfo(mp, 5) == NUMERIC_t) stop = _clip_parni(mp, 5); err = _clip_fetch_item(mp, HASH_ferror); ret = v24SetParameters(gz, baud_val(baud), data_val(data), parity_val(parity)); _clip_retl(mp, ret ? 0 : 1); return 0; }
/* Set the pixmap in a node. */ int clip_GTK_CTREENODESETPIXTEXT(ClipMachine * cm) { C_widget *cctree = _fetch_cw_arg(cm); C_object *cnode = _fetch_cobject(cm,_clip_spar(cm,2)); gint column = _clip_parni(cm,3); gchar *text = _clip_parc(cm,4); gint spacing = _clip_parni(cm,5); C_widget *cpixmap = _fetch_cwidget(cm,_clip_spar(cm,6)); GdkPixmap *pixmap=NULL; GdkBitmap *mask=NULL; CHECKCWID(cctree,GTK_IS_CTREE); CHECKOPT2(2,MAP_t,NUMERIC_t); CHECKCOBJOPT(cnode,cnode->type==GTK_TYPE_CTREE_NODE); CHECKOPT(3,NUMERIC_t); CHECKOPT(4,CHARACTER_t); CHECKOPT(5,NUMERIC_t); CHECKOPT2(6,MAP_t,NUMERIC_t); CHECKCWIDOPT(cpixmap,GTK_IS_PIXMAP); if (_clip_parinfo(cm,3)==UNDEF_t) column = 1; if (_clip_parinfo(cm,4)==UNDEF_t) text = ""; if (cpixmap) { pixmap = GTK_PIXMAP(cpixmap->widget)->pixmap; mask = GTK_PIXMAP(cpixmap->widget)->mask; } LOCALE_TO_UTF(text); gtk_ctree_node_set_pixtext(GTK_CTREE(cctree->widget), GTK_CTREE_NODE(cnode->object), column-1, text,spacing,pixmap,mask); FREE_TEXT(text); return 0; err: return 1; }
int clip_DATE(ClipMachine * ClipMachineMemory) { int yy, mm, dd; #ifdef _WIN32 SYSTEMTIME st; GetLocalTime(&st); yy = st.wYear; mm = st.wMonth; dd = st.wDay; #else struct tm *sysTime; sysTime = _clip_sysdate(); yy = sysTime->tm_year + 1900; mm = sysTime->tm_mon + 1; dd = sysTime->tm_mday; free(sysTime); #endif if (_clip_parinfo(ClipMachineMemory, 1) == NUMERIC_type_of_ClipVarType) yy = _clip_parni(ClipMachineMemory, 1); if (_clip_parinfo(ClipMachineMemory, 2) == NUMERIC_type_of_ClipVarType) mm = _clip_parni(ClipMachineMemory, 2); if (_clip_parinfo(ClipMachineMemory, 3) == NUMERIC_type_of_ClipVarType) dd = _clip_parni(ClipMachineMemory, 3); _clip_retdc(ClipMachineMemory, yy, mm, dd); return 0; }
/* Sets the packing parameters for the bookmark of child. * See GtkBoxPackStart for the exact meanings. */ int clip_GTK_NOTEBOOKSETTABLABELPACKING(ClipMachine * ClipMachineMemory) { C_widget *cntb = _fetch_cw_arg(ClipMachineMemory); C_widget *cchild = _fetch_cwidget(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2)); gboolean expand = _clip_parl(ClipMachineMemory, 3); gboolean fill = _clip_parl(ClipMachineMemory, 4); guint packing_type = _clip_parni(ClipMachineMemory, 5); CHECKCWID(cntb, GTK_IS_NOTEBOOK); CHECKARG2(2, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType); CHECKCWID(cchild, GTK_IS_WIDGET); CHECKOPT(3, LOGICAL_type_of_ClipVarType); CHECKOPT(4, LOGICAL_type_of_ClipVarType); CHECKOPT(5, NUMERIC_type_of_ClipVarType); if (_clip_parinfo(ClipMachineMemory, 3) == UNDEF_type_of_ClipVarType) expand = TRUE; if (_clip_parinfo(ClipMachineMemory, 4) == UNDEF_type_of_ClipVarType) fill = TRUE; gtk_notebook_set_tab_label_packing(GTK_NOTEBOOK(cntb->widget), cchild->widget, expand, fill, packing_type); return 0; err: return 1; }
int clip_CHMOD(ClipMachine * ClipMachineMemory) { int lp = 0, *err = NULL; char buf[PATH_MAX]; char *fname = _clip_parc(ClipMachineMemory, 1); _clip_retl(ClipMachineMemory, 1); err = _clip_fetch_item(ClipMachineMemory, HASH_ferror); *err = 0; if (_clip_parinfo(ClipMachineMemory, 2) == CHARACTER_type_of_ClipVarType) lp = _clip_fileStrModeToNumMode(_clip_parc(ClipMachineMemory, 2)); if (_clip_parinfo(ClipMachineMemory, 2) == NUMERIC_type_of_ClipVarType) lp = _clip_parni(ClipMachineMemory, 2); if (fname == NULL || lp == 0) { _clip_retl(ClipMachineMemory, 0); return _clip_trap_err(ClipMachineMemory, EG_ARG, 0, 0, __FILE__, __LINE__, "CHMOD"); } _clip_translate_path(ClipMachineMemory, fname, buf, sizeof(buf)); if (chmod(buf, lp) == 0) return 0; _clip_retl(ClipMachineMemory, 0); *err = errno; return 0; }
/* Moves a child of a GtkFixed container to the given position. */ int clip_GTK_FIXEDMOVE(ClipMachine * ClipMachineMemory) { C_widget *cfix = _fetch_cw_arg(ClipMachineMemory); C_widget *cwid = _fetch_cwidget(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2)); gint x = _clip_parni(ClipMachineMemory, 3); gint y = _clip_parni(ClipMachineMemory, 4); CHECKARG2(2, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType); CHECKOPT(3, NUMERIC_type_of_ClipVarType); CHECKOPT(4, NUMERIC_type_of_ClipVarType); CHECKCWID(cfix, GTK_IS_FIXED); CHECKCWID(cwid, GTK_IS_WIDGET); if (_clip_parinfo(ClipMachineMemory, 3) == UNDEF_type_of_ClipVarType) x = cwid->widget->allocation.x; if (_clip_parinfo(ClipMachineMemory, 4) == UNDEF_type_of_ClipVarType) y = cwid->widget->allocation.y; gtk_fixed_move(GTK_FIXED(cfix->widget), cwid->widget, x, y); return 0; err: return 1; }
int clip_GTK_ALIGNMENTSET(ClipMachine * ClipMachineMemory) { C_widget *cali = _fetch_cw_arg(ClipMachineMemory); gfloat xalign = _clip_parnd(ClipMachineMemory, 2); gfloat yalign = _clip_parnd(ClipMachineMemory, 3); gfloat xscale = _clip_parnd(ClipMachineMemory, 4); gfloat yscale = _clip_parnd(ClipMachineMemory, 5); CHECKCWID(cali, GTK_IS_ALIGNMENT); CHECKOPT(2, NUMERIC_type_of_ClipVarType); CHECKOPT(3, NUMERIC_type_of_ClipVarType); CHECKOPT(4, NUMERIC_type_of_ClipVarType); CHECKOPT(5, NUMERIC_type_of_ClipVarType); if (_clip_parinfo(ClipMachineMemory, 4) == UNDEF_type_of_ClipVarType) xscale = 1; if (_clip_parinfo(ClipMachineMemory, 5) == UNDEF_type_of_ClipVarType) yscale = 1; gtk_alignment_set(GTK_ALIGNMENT(cali->widget), xalign, yalign, xscale, yscale); return 0; err: return 1; }
int clip_BITTOC(ClipMachine * mp) { unsigned int Num = _clip_parni(mp, 1); int LenPattern; char *BitPattern = _clip_parcl(mp, 2, &LenPattern); char *p, res[] = " "; unsigned int Mask; int Len = _clip_parinfo(mp, 0), RealLen; int t1 = _clip_parinfo(mp, 1); int t2 = _clip_parinfo(mp, 2); if (Len < 2 || t1 != NUMERIC_t || t2 != CHARACTER_t) { _clip_retc(mp, ""); return _clip_trap_err(mp, EG_ARG, 0, 0, __FILE__, __LINE__, "BITTOC"); } if (LenPattern > 16) LenPattern = 16; if (_clip_parl(mp, 3)) { for (RealLen = LenPattern, Len = 0, Mask = 1 << (LenPattern - 1); Len < LenPattern; Mask >>= 1, Len++) if (Num & Mask) res[Len] = BitPattern[Len]; } else { for (RealLen = 0, p = res, Len = 0, Mask = 1 << (LenPattern - 1); Len < LenPattern; Mask >>= 1, Len++)
/* Sets default size for window */ int clip_GTK_WINDOWSETDEFAULTSIZE(ClipMachine * cm) { C_widget *cwin = _fetch_cw_arg(cm); gint width = _clip_parni(cm,2); gint height = _clip_parni(cm,3); GtkArg arg; CHECKCWID(cwin,GTK_IS_WINDOW); CHECKOPT(2,NUMERIC_t); CHECKOPT(3,NUMERIC_t); if (_clip_parinfo(cm,2)==UNDEF_t) { arg.type = GTK_TYPE_INT; arg.name = "width"; gtk_widget_get(cwin->widget, &arg); if (arg.d.int_data == -1) arg.d.int_data = cwin->widget->requisition.width; width = arg.d.int_data; } if (_clip_parinfo(cm,3)==UNDEF_t) { arg.type = GTK_TYPE_INT; arg.name = "height"; gtk_widget_get(cwin->widget, &arg); if (arg.d.int_data == -1) arg.d.int_data = cwin->widget->requisition.height; height = arg.d.int_data; } gtk_window_set_default_size(GTK_WINDOW(cwin->widget), width, height); return 0; err: return 1; }
CLIP_DLLEXPORT C_object* _fetch_co_arg(ClipMachine* cm) { C_object* cobj; if (_clip_parinfo(cm,1)==NUMERIC_t) { cobj = (C_object*)_clip_fetch_c_item(cm,_clip_parni(cm,1), _C_ITEM_TYPE_WIDGET); } else { if (_clip_parinfo(cm,1)==MAP_t) { double h; _clip_mgetn(cm, _clip_spar(cm,1), HASH_HANDLE, &h); cobj = (C_object *) _clip_fetch_c_item(cm, (int) h, _C_ITEM_TYPE_WIDGET); } else { _clip_trap_err(cm,EG_ARG,0,0,"CLIP_GTK_SYSTEM", EG_ARG,"Bad object descriptor"); return NULL; } } if(!cobj) { _clip_trap_err(cm,EG_ARG,0,0,"CLIP_GTK_SYSTEM", EG_ARG,"Bad object descriptor"); return NULL; } return cobj; }
int clip_SCREENSTRING(ClipMachine * ClipMachineMemory) { int top = _clip_parni(ClipMachineMemory, 1); int left = _clip_parni(ClipMachineMemory, 2); int l = _clip_parni(ClipMachineMemory, 3); Screen *sp = ClipMachineMemory->screen; char *r; if ((_clip_parinfo(ClipMachineMemory, 1) != NUMERIC_type_of_ClipVarType) || (top < 0) || (top >= sp->base->Lines)) top = sp->y; if ((_clip_parinfo(ClipMachineMemory, 2) != NUMERIC_type_of_ClipVarType) || (left < 0) || (left >= sp->base->Columns)) left = sp->x; if ((_clip_parinfo(ClipMachineMemory, 3) != NUMERIC_type_of_ClipVarType) || (l < 1) || (left + l > sp->base->Columns)) l = sp->base->Columns - left; r = calloc(1, l + 1); memcpy(r, sp->chars[top] + left, l); _clip_retcn_m(ClipMachineMemory, r, l); return 0; }
/* Inserts in notebook a new page whose content is child, and whose bookmark * is tab_label. The page is inserted just before the page number position, * starting with 0. If position is out of bounds, it is assumed to be the * current number of pages. */ int clip_GTK_NOTEBOOKINSERTPAGE(ClipMachine * cm) { C_widget *cntb = _fetch_cw_arg(cm); C_widget *cchild = _fetch_cwidget(cm,_clip_spar(cm,2)); C_widget *clabel; GtkWidget *label; gint position = _clip_parni(cm,4); CHECKCWID(cntb,GTK_IS_NOTEBOOK); CHECKARG2(2,MAP_t,NUMERIC_t); CHECKCWID(cchild,GTK_IS_WIDGET); CHECKARG3(3,MAP_t,NUMERIC_t,CHARACTER_t); CHECKOPT(4,NUMERIC_t); if (_clip_parinfo(cm,3)==CHARACTER_t) { char * caption = _clip_parc(cm, 3); LOCALE_TO_UTF(caption); label = gtk_label_new_with_mnemonic(caption); FREE_TEXT(caption); } else { clabel = _fetch_cwidget(cm,_clip_spar(cm,3)); CHECKCWID(clabel,GTK_IS_WIDGET); if (clabel) label = clabel->widget; } if (_clip_parinfo(cm,4)==UNDEF_t) position = 1; gtk_notebook_insert_page(GTK_NOTEBOOK(cntb->widget), cchild->widget, label, position-1); return 0; err: return 1; }
/* winbuf_copy(scr_buf,top1,left1,height1,width1,dest_buf,top2,left2) - ����� ������ scr_buf, ������ ������ top1,left1,height1,width1 �dest_buf � ������top2,left2 */ int clip_WINBUF_COPY(ClipMachine * ClipMachineMemory) { int no; WinBuf *wp, *d_wp; int top, left, hi, wi, d_top, d_left; int x, y, d_y, d_x; if (ClipMachineMemory->argc < 6) return EG_ARG; no = _clip_parni(ClipMachineMemory, 1); wp = find_WinBuf(no); if (!wp) return EG_ARG; no = _clip_parni(ClipMachineMemory, 6); d_wp = find_WinBuf(no); if (!d_wp) return EG_ARG; top = _clip_parni(ClipMachineMemory, 2); left = _clip_parni(ClipMachineMemory, 3); if (_clip_parinfo(ClipMachineMemory, 4) == NUMERIC_type_of_ClipVarType) hi = _clip_parni(ClipMachineMemory, 4); else hi = wp->hi; if (hi > wp->hi) hi = wp->hi; if (_clip_parinfo(ClipMachineMemory, 5) == NUMERIC_type_of_ClipVarType) wi = _clip_parni(ClipMachineMemory, 5); else wi = wp->wi; if (wi > wp->wi) wi = wp->wi; d_top = _clip_parni(ClipMachineMemory, 7); d_left = _clip_parni(ClipMachineMemory, 8); for (y = top, d_y = d_top; y < hi && d_y < d_wp->hi; y++, d_y++) { if (y < 0 || d_y < 0) continue; for (x = left, d_x = d_left; x < wi && d_x < d_wp->wi; x++, d_x++) { if (x < 0 || d_x < 0) continue; d_wp->chars[d_y][d_x] = wp->chars[y][x]; d_wp->colors[d_y][d_x] = wp->colors[y][x]; d_wp->attrs[d_y][d_x] = wp->attrs[y][x]; } } return 0; }
/* Inserts in notebook a new page whose content is child, whose bookmark is * tab_label, and whose menu label is menu_label. The page is inserted just * before the page number position, starting with 0. If position is out of * bounds, it is assumed to be the current number of pages. */ int clip_GTK_NOTEBOOKINSERTPAGEMENU(ClipMachine * ClipMachineMemory) { C_widget *cntb = _fetch_cw_arg(ClipMachineMemory); C_widget *cchild = _fetch_cwidget(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2)); C_widget *ctab_label; GtkWidget *tab_label; C_widget *cmenu_label; GtkWidget *menu_label; gint position = _clip_parni(ClipMachineMemory, 5); CHECKCWID(cntb, GTK_IS_NOTEBOOK); CHECKARG2(2, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType); CHECKCWID(cchild, GTK_IS_WIDGET); CHECKARG3(3, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType, CHARACTER_type_of_ClipVarType); CHECKARG3(4, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType, CHARACTER_type_of_ClipVarType); CHECKOPT(5, NUMERIC_type_of_ClipVarType); if (_clip_parinfo(ClipMachineMemory, 3) == CHARACTER_type_of_ClipVarType) { char *caption = _clip_parc(ClipMachineMemory, 3); LOCALE_TO_UTF(caption); tab_label = gtk_label_new(caption); FREE_TEXT(caption); } else { ctab_label = _fetch_cwidget(ClipMachineMemory, _clip_spar(ClipMachineMemory, 3)); CHECKCWID(ctab_label, GTK_IS_WIDGET); if (ctab_label) tab_label = ctab_label->widget; } if (_clip_parinfo(ClipMachineMemory, 4) == CHARACTER_type_of_ClipVarType) { char *menu_text = _clip_parc(ClipMachineMemory, 4); LOCALE_TO_UTF(menu_text); menu_label = gtk_label_new(menu_text); FREE_TEXT(menu_text); } else { cmenu_label = _fetch_cwidget(ClipMachineMemory, _clip_spar(ClipMachineMemory, 4)); CHECKCWID(cmenu_label, GTK_IS_WIDGET); if (cmenu_label) menu_label = cmenu_label->widget; } if (_clip_parinfo(ClipMachineMemory, 5) == UNDEF_type_of_ClipVarType) position = 1; gtk_notebook_insert_page_menu(GTK_NOTEBOOK(cntb->widget), cchild->widget, tab_label, menu_label, position - 1); return 0; err: return 1; }
int clip_GDK_WINDOWGETPOINTER(ClipMachine * cm) { // C_object *cwin = _fetch_co_arg(cm); C_widget *cwin = _fetch_cw_arg(cm); gint x = _clip_parni(cm,2); gint y = _clip_parni(cm,3); gint * px, * py; GdkWindow *win = NULL; GdkModifierType mask; CHECKCWID(cwin,GTK_IS_WIDGET); CHECKOPT(2,NUMERIC_t); CHECKOPT(3,NUMERIC_t); px = _clip_parinfo(cm,2) == UNDEF_t ? NULL : &x; py = _clip_parinfo(cm,3) == UNDEF_t ? NULL : &y; if (cwin && cwin->widget) win = cwin->widget->window; gdk_window_get_pointer(win, px, py, &mask); _clip_storni(cm,*px,2,0); _clip_storni(cm,*py,3,0); _clip_storni(cm,mask,4,0); return 0; err: return 1; }
/* TREE_TYPE_PIXBUF */ int /****************************************************************************** * gtk_ListStoreNew(map, ncolumns, type1, ...) ******************************************************************************/ clip_GTK_LISTSTORENEW(ClipMachine * cm) { ClipVar * cv = _clip_spar(cm, 1); gint ncolumns = _clip_parni(cm, 2); ClipArrVar *cvcol = (ClipArrVar *)_clip_vptr(_clip_spar(cm, 3)); ClipVar *utypes; GType types[ncolumns]; int i; long d; GtkListStore *list; C_object *clist; CHECKOPT(1,MAP_t); CHECKARG(2,NUMERIC_t); //CHECKARG2(3, NUMERIC_t, ARRAY_t); memset(types, 0, sizeof(types)); utypes = NEW(ClipVar); if ( _clip_parinfo(cm,3)==ARRAY_t && cvcol->count != ncolumns ) return 1; if ( _clip_parinfo(cm,3) != UNDEF_t ) // defined column types as parameters or in array __list_store_set_types(cm, ncolumns, types, utypes); else { // if third parameter is empty - use column with G_TYPE_STRING type ClipVar type; d = ncolumns; memset(&type, 0, sizeof(type)); type.t.type = NUMERIC_t; type.n.d = 0; _clip_array(cm, utypes, 1, &d); for ( i=0, d=0; i<ncolumns; i++, d++ ) { types[i] = G_TYPE_STRING; _clip_aset(cm, utypes, &type, 1, &d); } _clip_destroy(cm, &type); } list = gtk_list_store_newv(ncolumns, types); if (list) { clist = _list_get_cobject(cm,list); if (!clist) clist = _register_object(cm,list,GTK_TYPE_LIST_STORE,cv,__list_store_destroy); if (clist) { _clip_madd(cm, &clist->obj, HASH_UTYPES, utypes); _clip_mclone(cm,RETPTR(cm),&clist->obj); } } free(utypes); return 0; err: return 1; }
int clip_UDPSENDTO(ClipMachine *mp) // UDPSENDTO( nCF, cIPaddr, nPort, cMsg, [nLen], [nTimeout] ) { int fd = _clip_parni(mp, 1); C_FILE *cf = (C_FILE *) _clip_fetch_c_item(mp, fd, _C_ITEM_TYPE_FILE); char *ipaddr = _clip_parc(mp, 2); int port = _clip_parni(mp,3), lenbuf; char *msg = _clip_parcl(mp,4, &lenbuf); long len = _clip_parnl(mp,5); int timeout = _clip_parni(mp,6); int ret = -1, *err = _clip_fetch_item(mp, HASH_ferror); struct sockaddr_in sin; struct timeval tv; fd_set set; if (cf == NULL || cf->type != FT_SOCKET) *err = EBADF; else { if (_clip_parinfo(mp, 5) != NUMERIC_t) len = lenbuf; if (len > lenbuf) len = lenbuf; if (_clip_parinfo(mp, 6) != NUMERIC_t) timeout = cf->timeout; if ( timeout >= 0 ) { FD_ZERO(&set); FD_SET(cf->fileno, &set); tv.tv_sec = timeout / 1000; tv.tv_usec = (timeout % 1000) * 1000; } memset( (void *) &sin, 0, sizeof(sin) ); sin.sin_family = PF_INET; sin.sin_addr.s_addr = inet_addr(ipaddr); sin.sin_port = htons(port); if ( timeout < 0 || select( cf->fileno+1, NULL, &set, NULL, &tv ) > 0 ) { ret = sendto( cf->fileno, msg, len, 0, (struct sockaddr *) &sin, sizeof(sin) ); *err = ret == -1 ? errno : 0; } else #ifdef OS_MINGW *err = EAGAIN; #else *err = ETIMEDOUT; #endif } _clip_retnl(mp, ret); return 0; }
/* COM_OPEN(nPort|cDevice,[dontused],[dontused],[dontused],l_RTSCTS,l_XONXOFF,lDebug) */ int clip_COM_OPEN(ClipMachine * mp) { int no = _clip_parni(mp, 1); char *dev = _clip_parc(mp, 1); char buf[V24_SZ_PORTNAME+1]; int ctsrts = _clip_parl(mp, 5); int xonxoff = _clip_parl(mp, 6); int dbg = _clip_parl(mp, 7); v24_port_t *gz; int *err, k; if (!_clip_parinfo(mp, 5) && !!_clip_parinfo(mp, 5)) ctsrts = 1; if (!dev && (no < 1 || no > 32)) return EG_ARG; if (!dev) { v24PortName(no - 1, buf); dev = buf; } gz = v24OpenPort(dev, V24_STANDARD | V24_LOCK /*| V24_NO_DELAY*/ | (ctsrts ? V24_RTS_CTS : 0) | (xonxoff ? V24_XON_XOFF : 0) | V24_DROP_DTR | (dbg ? V24_DEBUG_ON : 0) ); if (!gz) { err = _clip_fetch_item(mp, HASH_ferror); *err = errno; _clip_retl(mp, 0); return 0; } k = _clip_store_c_item(mp, gz, _C_ITEM_TYPE_COMPORT, destroy_com_port); keys[no] = k; _clip_retl(mp, 1); return 0; }
/* Controls the alignment of the text within the progress bar area. */ int clip_GTK_PROGRESSSETTEXTALIGNMENT(ClipMachine * cm) { C_widget *cprg = _fetch_cw_arg(cm); gfloat x_align = _clip_parnd(cm,2); gfloat y_align = _clip_parnd(cm,2); CHECKCWID(cprg,GTK_IS_PROGRESS); CHECKOPT(2,NUMERIC_t); CHECKOPT(3,NUMERIC_t); if (_clip_parinfo(cm,2)==UNDEF_t) x_align = GTK_PROGRESS(cprg->widget)->x_align; if (_clip_parinfo(cm,3)==UNDEF_t) y_align = GTK_PROGRESS(cprg->widget)->y_align; gtk_progress_set_text_alignment(GTK_PROGRESS(cprg->widget), x_align, y_align); return 0; err: return 1; }
int clip_SAVESCREEN(ClipMachine * ClipMachineMemory) { int l; int top = _clip_parni(ClipMachineMemory, 1); int left = _clip_parni(ClipMachineMemory, 2); int bottom = _clip_parni(ClipMachineMemory, 3); int right = _clip_parni(ClipMachineMemory, 4); int par = _clip_parinfo(ClipMachineMemory, 0); int mainscreen = (_clip_parl(ClipMachineMemory, 5) != 0 ? 0 : ClipMachineMemory->wnum); int modescreen = (_clip_parl(ClipMachineMemory, 5) == 0 ? 0 : 2); ClipVar *rp; char *s; ClipWindow *wp; wp = ClipMachineMemory->windows + mainscreen; _clip_fullscreen(ClipMachineMemory); if (par < 3 || _clip_parinfo(ClipMachineMemory, 3) == UNDEF_type_of_ClipVarType) bottom = wp->ClipRect_rect_of_ClipWindow.bottom_of_ClipRect; if (par < 4 || _clip_parinfo(ClipMachineMemory, 3) == UNDEF_type_of_ClipVarType) right = wp->ClipRect_rect_of_ClipWindow.right_of_ClipRect; clip_region(ClipMachineMemory, &top, &left, &bottom, &right, modescreen, mainscreen); s = save_region(ClipMachineMemory, 0, top, left, bottom, right, &l); rp = RETPTR(ClipMachineMemory); rp->ClipType_t_of_ClipVar.ClipVartype_type_of_ClipType = CHARACTER_type_of_ClipVarType; rp->ClipType_t_of_ClipVar.ClipFlags_flags_of_ClipType = F_NONE_ClipFlags; rp->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.buf_of_ClipBuf = s; rp->ClipStrVar_s_of_ClipVar.ClipBuf_str_of_ClipStrVar.len_of_ClipBuf = l; sync_mp(ClipMachineMemory); return 0; }
/* Changes the bookmark label of child. Nothing happens if child is not in notebook. */ int clip_GTK_NOTEBOOKSETTABLABEL(ClipMachine * cm) { C_widget *cntb = _fetch_cw_arg(cm); C_widget *cchild = _fetch_cwidget(cm,_clip_spar(cm,2)); C_widget *clabel; CHECKCWID(cntb,GTK_IS_NOTEBOOK); CHECKARG2(2,MAP_t,NUMERIC_t); CHECKCWID(cchild,GTK_IS_WIDGET); CHECKARG3(3,MAP_t,NUMERIC_t,CHARACTER_t); if (_clip_parinfo(cm,3)==CHARACTER_t) { char * caption = _clip_parc(cm, 3); LOCALE_TO_UTF(caption); gtk_notebook_set_tab_label_text(GTK_NOTEBOOK(cntb->widget), cchild->widget,caption); FREE_TEXT(caption); } else { clabel = _fetch_cwidget(cm,_clip_spar(cm,3)); CHECKCWID(clabel,GTK_IS_WIDGET); if (clabel) gtk_notebook_set_tab_label(GTK_NOTEBOOK(cntb->widget), cchild->widget,clabel->widget); } return 0; err: return 1; }
/**** BUTTON constructor ****/ int clip_GTK_BUTTONNEW(ClipMachine * ClipMachineMemory) { ClipVar *cv = _clip_spar(ClipMachineMemory, 1); char *title = _clip_parc(ClipMachineMemory, 2); char *pchar = _clip_parc(ClipMachineMemory, 3); GtkWidget *wid = NULL, *label = NULL; C_widget *cwid, *clabel = NULL; guint accel_key = 0; CHECKOPT(1, MAP_type_of_ClipVarType); CHECKOPT(2, CHARACTER_type_of_ClipVarType); CHECKOPT(3, CHARACTER_type_of_ClipVarType); if (pchar) { unsigned char *pc; for (pc = (unsigned char *) title; pc && *pc; pc++) if (*pc == *pchar) { *pc = '_'; accel_key = *(pc + 1); } } if (_clip_parinfo(ClipMachineMemory, 2) == CHARACTER_type_of_ClipVarType) { LOCALE_TO_UTF(title); wid = gtk_button_new_with_label(title); label = GTK_BIN(&(GTK_BUTTON(wid)->bin))->child; if (pchar) accel_key = gtk_label_parse_uline(GTK_LABEL(label), title); FREE_TEXT(title); } else { wid = gtk_button_new(); } if (!wid) goto err; cwid = _register_widget(ClipMachineMemory, wid, cv); if (label) clabel = _register_widget(ClipMachineMemory, label, NULL); if (clabel) _clip_madd(ClipMachineMemory, &cwid->obj, HASH_LABEL, &clabel->obj); _clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &cwid->obj); _clip_mputn(ClipMachineMemory, &cwid->obj, HASH_ACCELKEY, accel_key); return 0; err: return 1; }
int clip_GTK_SIGNALEMIT(ClipMachine *cm) { C_widget *cwid = _fetch_cw_arg(cm); SignalTable *sig_table = NULL; int ret=0; CHECKCWID(cwid,GTK_IS_OBJECT); CHECKARG2(2,CHARACTER_t,NUMERIC_t); if (_clip_parinfo(cm,2) == CHARACTER_t) sig_table = _sig_table_by_name(cwid, _clip_parc(cm,2)); else sig_table = _sig_table_by_id(cwid, _clip_parni(cm,2)); if (sig_table && sig_table->emitsigfunction) { if (cwid && cwid->widget && GTK_IS_OBJECT(cwid->widget)) ret = sig_table->emitsigfunction(cwid,sig_table->signame); //int sigfound = gtk_signal_lookup(signame, GTK_WIDGET_TYPE(cwid->widget)); } _clip_retl(cm,sig_table && sig_table->sigfunction); return ret; err: return 1; }
/**** LIST ITEM constructor ****/ int clip_GTK_LISTITEMNEW(ClipMachine * cm) { ClipVar * cv = _clip_spar(cm, 1); C_widget *cchild; GtkWidget *wid = NULL; C_widget *cwid; CHECKOPT(1,MAP_t); CHECKOPT3(2,CHARACTER_t,MAP_t,NUMERIC_t); switch (_clip_parinfo(cm,2)) { case CHARACTER_t: wid = gtk_list_item_new_with_label(_clip_parc(cm,2)); break; case MAP_t: case NUMERIC_t: wid = gtk_list_item_new(); cchild = _fetch_cwidget(cm,_clip_spar(cm,2)); CHECKCWID(cchild,GTK_IS_WIDGET); gtk_container_add(GTK_CONTAINER(wid), cchild->widget); break; } if (!wid) goto err; cwid = _register_widget(cm, wid, cv); _clip_mclone(cm,RETPTR(cm),&cwid->obj); return 0; err: return 1; }
int clip_GTK_CTREENODEGETPIXMAP(ClipMachine * cm) { C_widget *cctree = _fetch_cw_arg(cm); C_object *cnode = _fetch_cobject(cm,_clip_spar(cm,2)); gint column = _clip_parni(cm,3); GdkPixmap *pixmap; GdkBitmap *mask; C_widget *cpixmap; CHECKCWID(cctree,GTK_IS_CTREE); CHECKOPT2(2,MAP_t,NUMERIC_t); CHECKCOBJOPT(cnode,cnode->type==GTK_TYPE_CTREE_NODE); CHECKOPT(3,NUMERIC_t); if (_clip_parinfo(cm,3)==UNDEF_t) column = 1; if (gtk_ctree_node_get_pixmap(GTK_CTREE(cctree->widget), GTK_CTREE_NODE(cnode->object),column-1,&pixmap,&mask)) { if (pixmap) { cpixmap = _list_get_cwidget_by_data(cm,pixmap); if (!cpixmap) cpixmap = _register_widget(cm,gtk_pixmap_new(pixmap,mask),NULL); if (cpixmap) _clip_mclone(cm,RETPTR(cm),&cpixmap->obj); } } return 0; err: return 1; }
/* Changes the menu label of child. Nothing happens if child is not in notebook. */ int clip_GTK_NOTEBOOKSETMENULABEL(ClipMachine * ClipMachineMemory) { C_widget *cntb = _fetch_cw_arg(ClipMachineMemory); C_widget *cchild = _fetch_cwidget(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2)); C_widget *clabel; CHECKCWID(cntb, GTK_IS_NOTEBOOK); CHECKARG2(2, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType); CHECKCWID(cchild, GTK_IS_WIDGET); CHECKARG3(3, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType, CHARACTER_type_of_ClipVarType); if (_clip_parinfo(ClipMachineMemory, 3) == CHARACTER_type_of_ClipVarType) { char *menu_text = _clip_parc(ClipMachineMemory, 3); LOCALE_TO_UTF(menu_text); gtk_notebook_set_menu_label_text(GTK_NOTEBOOK(cntb->widget), cchild->widget, menu_text); FREE_TEXT(menu_text); } else { clabel = _fetch_cwidget(ClipMachineMemory, _clip_spar(ClipMachineMemory, 3)); CHECKCWID(clabel, GTK_IS_WIDGET); if (clabel) gtk_notebook_set_menu_label(GTK_NOTEBOOK(cntb->widget), cchild->widget, clabel->widget); } return 0; err: return 1; }
/* Returns the content of the page number page_num, or * NULL if page_num is out of bounds. */ int clip_GTK_NOTEBOOKGETNTHPAGE(ClipMachine * ClipMachineMemory) { C_widget *cntb = _fetch_cw_arg(ClipMachineMemory); gint page_num = _clip_parni(ClipMachineMemory, 2); C_widget *cwid; GtkWidget *wid; CHECKCWID(cntb, GTK_IS_NOTEBOOK); CHECKOPT(2, NUMERIC_type_of_ClipVarType); if (_clip_parinfo(ClipMachineMemory, 2) == UNDEF_type_of_ClipVarType) page_num = 1; wid = gtk_notebook_get_nth_page(GTK_NOTEBOOK(cntb->widget), page_num - 1); cwid = _list_get_cwidget(ClipMachineMemory, wid); if (!cwid) cwid = _register_widget(ClipMachineMemory, wid, NULL); if (cwid) _clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &cwid->obj); return 0; err: return 1; }
/* Prepends to notebook a page whose content is child, and whose * bookmark is label. */ int clip_GTK_NOTEBOOKPREPENDPAGE(ClipMachine * ClipMachineMemory) { C_widget *cntb = _fetch_cw_arg(ClipMachineMemory); C_widget *cchild = _fetch_cwidget(ClipMachineMemory, _clip_spar(ClipMachineMemory, 2)); C_widget *clabel; GtkWidget *label; CHECKCWID(cntb, GTK_IS_NOTEBOOK); CHECKARG2(2, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType); CHECKCWID(cchild, GTK_IS_WIDGET); CHECKARG3(3, MAP_type_of_ClipVarType, NUMERIC_type_of_ClipVarType, CHARACTER_type_of_ClipVarType); if (_clip_parinfo(ClipMachineMemory, 3) == CHARACTER_type_of_ClipVarType) { char *caption = _clip_parc(ClipMachineMemory, 3); LOCALE_TO_UTF(caption); label = gtk_label_new(caption); FREE_TEXT(caption); } else { clabel = _fetch_cwidget(ClipMachineMemory, _clip_spar(ClipMachineMemory, 3)); CHECKCWID(clabel, GTK_IS_WIDGET); if (clabel) label = clabel->widget; } gtk_notebook_prepend_page(GTK_NOTEBOOK(cntb->widget), cchild->widget, label); return 0; err: return 1; }
/* Sets the text within the GtkLabel widget. It overwrites any text that was * there before. Note that underlines that were there before do not get * overwritten. If you want to erase underlines just send NULL to * gtk_label_set_pattern(). */ int clip_GTK_LABELSETTEXT(ClipMachine * ClipMachineMemory) { C_widget *clbl = _fetch_cw_arg(ClipMachineMemory); char *text = _clip_parc(ClipMachineMemory, 2); char *pchar = _clip_parc(ClipMachineMemory, 3); guint accel_key = 0; CHECKCWID(clbl, GTK_IS_LABEL); CHECKOPT(2, CHARACTER_type_of_ClipVarType); CHECKOPT(3, CHARACTER_type_of_ClipVarType); if (_clip_parinfo(ClipMachineMemory, 2) == UNDEF_type_of_ClipVarType) text = "\0"; LOCALE_TO_UTF(text); gtk_label_set_text(GTK_LABEL(clbl->widget), text); if (pchar) { char *pc; for (pc = text; pc && *pc; pc++) if (*pc == *pchar) *pc = '_'; accel_key = gtk_label_parse_uline(GTK_LABEL(clbl->widget), text); } FREE_TEXT(text); _clip_mputn(ClipMachineMemory, &clbl->obj, HASH_ACCELKEY, accel_key); return 0; err: return 1; }
/* Modify TEXT for a button */ int clip_GTK_BUTTONMODIFYTEXT(ClipMachine * ClipMachineMemory) { C_widget *cbtn = _fetch_cw_arg(ClipMachineMemory); ClipVar *mstyle = _clip_par(ClipMachineMemory, 2); GtkStateType state = _clip_parni(ClipMachineMemory, 3); GdkColor textcolor; double colors[4]; GtkWidget *wid; CHECKARG2(2, MAP_type_of_ClipVarType, ARRAY_type_of_ClipVarType); CHECKOPT(3, NUMERIC_type_of_ClipVarType); CHECKCWID(cbtn, GTK_IS_BUTTON); _map_get_colors(ClipMachineMemory, mstyle, colors); textcolor.red = colors[0]; textcolor.green = colors[1]; textcolor.blue = colors[2]; textcolor.pixel = colors[3]; if (_clip_parinfo(ClipMachineMemory, 3) != NUMERIC_type_of_ClipVarType) state = GTK_STATE_NORMAL; //wid = GTK_BIN(&(GTK_BUTTON(cbtn->widget)->bin))->child; wid = GTK_WIDGET(cbtn->widget); gtk_widget_modify_text(wid, state, &textcolor); return 0; err: return 1; }