mib_object_t * MibRegister( ul32 *Id, u16 IdLen, mib_callback_t Rqs, u16 Type, u16 Support, void *Param ) { mib_object_t *object; object = (mib_object_t *)x_malloc(sizeof(mib_object_t)); if (object == 0) { x_dbg("XSNMP, MibRegister: object is 0\n", TRUE); return 0; } if( !IdLen ) x_dbg("XSNMP, MibRegister: Idlen == 0\n", TRUE); object->Id = (ul32 *)x_malloc(IdLen * sizeof(l32)); if (object->Id == 0) { x_dbg("XSNMP, MibRegister: object->ID is 0\n", TRUE); return 0; } x_memcpy(object->Id, Id, IdLen * sizeof(l32)); object->IdLen = IdLen; object->Rqs = Rqs; object->Type = Type; object->Support = Support; object->Param = Param; if (!MibObjectInsert(object)) { x_free(object->Id); x_free(object); x_dbg("XSNMP, MibRegister: MibObjectInsert fail\n", TRUE); return 0; } return object; }
void apply_voronoi (hf_wrapper_struct *hfw) { // gint t1; if (!hfw->hf_struct->tmp_buf) hf_backup(hfw->hf_struct); if (!hfw->hf_struct->result_buf) hfw->hf_struct->result_buf = (hf_type *) x_malloc(sizeof(hf_type) * hfw->hf_struct->max_x * hfw->hf_struct->max_y, "hf_type (result_buf in apply_voronoi)"); if (!hfw->hf_struct->tmp2_buf) hfw->hf_struct->tmp2_buf = (hf_type *) x_malloc(sizeof(hf_type) * hfw->hf_struct->max_x * hfw->hf_struct->max_y, "hf_type (tmp2_buf in apply_voronoi)"); // t1 = clock(); // Convention: // 1. tmp_buf: original HF // 2. tmp2_buf: distance HF // 3. result_buf: crackled HF (base level + black lines == cracks) // 4. hf_buf: output = crackled HF + distance HF (for lifting edges) set_watch_cursor(hfw); hf_voronoi(hfw->hf_struct, hfw->hf_options->img->voronoi); voronoi_adjust_edges (hfw->hf_struct->result_buf, hfw->hf_struct->hf_buf, hfw->hf_struct->tmp2_buf, hfw->hf_options->img->voronoi->edges_level, hfw->hf_struct->max_x, hfw->hf_struct->max_y); unset_watch_cursor(hfw); // printf("TEMPS DE CRAQU�LEMENT: %d\n",clock() - t1); }
static int verify_object(struct conf *conf, struct manifest *mf, struct object *obj, struct hashtable *stated_files, struct hashtable *hashed_files) { for (uint32_t i = 0; i < obj->n_file_info_indexes; i++) { struct file_info *fi = &mf->file_infos[obj->file_info_indexes[i]]; char *path = mf->files[fi->index]; struct file_stats *st = hashtable_search(stated_files, path); if (!st) { struct stat file_stat; if (x_stat(path, &file_stat) != 0) { return 0; } st = x_malloc(sizeof(*st)); st->size = file_stat.st_size; st->mtime = file_stat.st_mtime; st->ctime = file_stat.st_ctime; hashtable_insert(stated_files, x_strdup(path), st); } if (fi->size != st->size) { return 0; } if (conf->sloppiness & SLOPPY_FILE_STAT_MATCHES) { if (fi->mtime == st->mtime && fi->ctime == st->ctime) { cc_log("mtime/ctime hit for %s", path); continue; } else { cc_log("mtime/ctime miss for %s", path); } } struct file_hash *actual = hashtable_search(hashed_files, path); if (!actual) { struct mdfour hash; hash_start(&hash); int result = hash_source_code_file(conf, &hash, path); if (result & HASH_SOURCE_CODE_ERROR) { cc_log("Failed hashing %s", path); return 0; } if (result & HASH_SOURCE_CODE_FOUND_TIME) { return 0; } actual = x_malloc(sizeof(*actual)); hash_result_as_bytes(&hash, actual->hash); actual->size = hash.totalN; hashtable_insert(hashed_files, x_strdup(path), actual); } if (memcmp(fi->hash, actual->hash, mf->hash_size) != 0 || fi->size != actual->size) { return 0; } } return 1; }
struct args * args_init(int init_argc, char **init_args) { struct args *args = (struct args *)x_malloc(sizeof(struct args)); args->argc = 0; args->argv = (char **)x_malloc(sizeof(char *)); args->argv[0] = NULL; for (int i = 0; i < init_argc; i++) { args_add(args, init_args[i]); } return args; }
static struct hashtable * create_file_info_index_map(struct file_info *infos, uint32_t len) { struct hashtable *h = create_hashtable(1000, hash_from_file_info, file_infos_equal); for (uint32_t i = 0; i < len; i++) { struct file_info *fi = x_malloc(sizeof(*fi)); *fi = infos[i]; uint32_t *index = x_malloc(sizeof(*index)); *index = i; hashtable_insert(h, fi, index); } return h; }
bignum_t * bignum_reverse (bignum_t * num) { bignum_t * rev = x_malloc (sizeof (bignum_t)); bignum_init (rev); rev->allocated = num->used; rev->used = num->used; rev->digits = x_malloc (rev->allocated); for (size_t i = 0; i < num->used; i++) rev->digits[i] = num->digits[num->used - 1 - i]; return rev; }
static void conv_write_comms() { int i, j; int n, p, t; /*MPI Communicators*/ for (i=0; i<numcomm; i++) { if ( commtab[i].numbyte ) { char *name = x_malloc(16 * sizeof(char)); unsigned int *array; int num = 0; for (j=0; j<(commtab[i].numbyte*8); j++) { if ( (1 << (j % 8)) & commtab[i].bits[j/8] ) num++; } if (num) commtab[i].array = array = x_malloc(num * sizeof(unsigned int)); num = 0; for (j=0; j<(commtab[i].numbyte*8); j++) { if ( (1 << (j % 8)) & commtab[i].bits[j/8] ) array[num++] = get_comm_loc(j); } commtab[i].numarray = num; if ( commtab[i].mode & ELG_GROUP_FLAG ) sprintf(name, "group %d", i); else sprintf(name, "comm %d", i); if (num) wbytes += VTF3_WriteDefcpugrp(fcb, ++grpid, num, array, name); } } /*OpenMP Thread Groups*/ if ( isthreaded ) { for (n=0; n<machine[0].num_member; n++) { Group *node = machine[0].member + n; for (p=0; p<node->num_member; p++) { Group *proc = node->member + p; char *name = x_malloc(16 * sizeof(char)); unsigned int *array = x_malloc(proc->num_member * sizeof(unsigned int)); for (t=0; t<proc->num_member; t++) { array[t] = proc->member[t].id; } sprintf(name, "tgroup %d", /*maxcomm + 1 +*/ proc->id); wbytes += VTF3_WriteDefcpugrp(fcb, ++grpid, proc->num_member, array, name); } } } }
int copy_tab_minus_one(char ***dest, char **src, int index) { int cnt; int tmp; int cnt_max; cnt = tmp = 0; while (src[cnt] != '\0') cnt++; cnt_max = cnt; if ((*dest = x_malloc(sizeof(**dest) * (cnt))) == NULL) return (0); cnt = 0; while (cnt <= cnt_max) { if (((*dest)[tmp++] = my_strdup(src[cnt++])) == NULL) return (0); if (cnt == index) cnt++; if (cnt >= cnt_max) { (*dest)[tmp] = '\0'; return (0); } } (*dest)[tmp] = '\0'; return (1); }
error *errorReply(error *in_error, int in_reply_code, const char *in_text, ...) { error *toRet = x_malloc(sizeof(error), errorFree); if (toRet) { memset(toRet, 0, sizeof(error)); toRet->m_code = in_reply_code; if (in_error) { toRet->m_next = in_error->m_next; in_error->m_next = NULL; } va_list v; va_start(v, in_text); vasprintf(&toRet->m_string, in_text, v); va_end(v); } else return &errorDefault; return toRet; }
static bool init_log(void) { extern struct conf *conf; if (debug_log_buffer || logfile || use_syslog) { return true; } assert(conf); if (conf->debug) { debug_log_buffer_capacity = DEBUG_LOG_BUFFER_MARGIN; debug_log_buffer = x_malloc(debug_log_buffer_capacity); debug_log_size = 0; } if (str_eq(conf->log_file, "")) { return conf->debug; } #ifdef HAVE_SYSLOG if (str_eq(conf->log_file, "syslog")) { use_syslog = true; openlog("ccache", LOG_PID, LOG_USER); return true; } #endif logfile = fopen(conf->log_file, "a"); if (logfile) { #ifndef _WIN32 set_cloexec_flag(fileno(logfile)); #endif return true; } else { return false; } }
static bool _internal_get_from_bb_bin_alloc (xmmsv_t *bb, unsigned char **buf, unsigned int *len) { unsigned char *b; int32_t l; if (!_internal_get_from_bb_int32_positive (bb, &l)) { return false; } b = x_malloc (l); if (!b) { return false; } if (!_internal_get_from_bb_data (bb, b, l)) { free (b); return false; } *buf = b; *len = l; return true; }
void save_render_options_inc (render_struct *rs) { // Private method, added 2007-01-01 // Save some render options in render_options.inc, in the current directory // those that are not camera related // and that cannot be specified on the command line FILE *fin; gchar *msg_buf, str_format[100], *ext; if (!(fin=fopen("render_options.inc","wb"))) { msg_buf = (gchar *) x_malloc(sizeof(gchar) + strlen("render_options.inc") + strlen(_("Not able to open '%s' file for writing"))+5, "const gchar (msg_buf - open file for writing)"); sprintf(msg_buf,_("Not able to open '%s' file for writing"),"render_options.inc"); my_msg(msg_buf,WARNING); } else { // loc = setlocale(LC_NUMERIC,""); // Povray uses "." as decimal separator instead of "," // setlocale(LC_NUMERIC,"C"); if (*rs->if_creation || *rs->if_modified) { // The PNG file to render is written in a temporary directory fprintf(fin,"#declare hf_to_render = %c%s%c;\n",'\"',HF_OUTPUT_FOR_RENDERING,'\"'); fprintf(fin,"#declare temporary_directory = %c%s%c;\n",'\"',TMP_DIR,'\"'); } else // If the current height field has not been changed, we render the source file fprintf(fin,"#declare hf_to_render = %c%s%c;\n",'\"',*rs->filename,'\"'); fprintf(fin,"#declare current_directory = %c%s%c;\n",'\"',*rs->dirname,'\"'); ext = strstr(*rs->filename,".png"); if (ext) { sprintf(str_format, "#declare fname_radix = %%c%%%d.%ds%%c;\n", ext-*rs->filename,ext-*rs->filename); // printf("STR_FORMAT: %s\n",str_format); fprintf(fin,str_format,'\"',*rs->filename,'\"'); } // setlocale(LC_NUMERIC,loc); fclose(fin); } }
/** * set attribute of type to malloc'ed value copy of val. */ static int stun_set_attr_d(stun_packet_t *pkt, int atype, int len, char *val) { int i; i = stun_attr_id(pkt, atype); //TRACE("))))))))))))))))) 2 i=%d, attrnum(%d)\n",i,(int)pkt->attrnum); if (i < 0) { pkt->attrs = x_realloc(pkt->attrs, sizeof(stun_attr_t) * (pkt->attrnum + 2)); i = pkt->attrnum; } //TRACE("))))))))))))))))) 3\n"); pkt->attrs[i].type = (uint16_t) atype; pkt->attrs[i].len = (uint16_t) len; if (pkt->attrs[pkt->attrnum].len) { // TRACE("))))))))))))))))) 4\n"); pkt->attrs[i].data = x_malloc(pkt->attrs[i].len); x_memcpy(pkt->attrs[pkt->attrnum].data, val, len); } else pkt->attrs[i].data = NULL; // end with NULL pkt->attrs[++pkt->attrnum].type = 0; // TRACE("))))))))))))))))) 5\n"); return 0; }
/** * returns x-mapped address buffer */ static char * stun_x_mapped(struct sockaddr_in *saddr) { uint16_t port; uint32_t ip; char *xmapped; ENTER; xmapped = (char *) x_memset(x_malloc(8), 0, 8); xmapped[0] = 0; xmapped[1] = 1; // ipv4 TRACE("MAPPING %s:%d\n", inet_ntoa(saddr->sin_addr), ntohs(saddr->sin_port)); ip = ntohl(saddr->sin_addr.s_addr); port = ntohs(saddr->sin_port); port ^= 0x2112; ip ^= STUN_M_COOKIE; port = htons(port); ip = htonl(ip); x_memcpy(xmapped + 2, &port, 2); x_memcpy(xmapped + 4, &ip, 4); EXIT; return xmapped; }
swirl_struct *swirl_pen_new() { swirl_struct *s; s = (swirl_struct *) x_malloc(sizeof(swirl_struct), "swirl_struct"); s->size = 81; s->angle = 0; return s; }
bignum_t * bignum_get_str (const char * value) { bignum_t * num = x_malloc (sizeof (bignum_t)); bignum_init (num); while (isblank (*value)) value++; if (*value == '-') num->sign = true; const char * tail_ptr = NULL; if (!*value) tail_ptr = value; else tail_ptr = value + strlen (value) - 1; while (tail_ptr > value && isspace (*tail_ptr)) tail_ptr--; while (tail_ptr >= value && isdigit (*tail_ptr)) { ensure_allocation (num); num->digits[num->used++] = *tail_ptr - '0'; tail_ptr--; } if (num->allocated == 0) { free (num); return bignum_get (0); } return num; }
//Creates a new coherence engine mpCoherence *mpCCreate(int in_data, int in_tasks, int in_cache) { errorAssert(in_data > 0, error_flags, "Need positive number of data sets"); errorAssert(in_tasks > 0, error_flags, "Need positive number of tasks"); errorAssert(in_cache > 0, error_flags, "Need positive number of caches"); mpCoherence *o = x_malloc(sizeof(mpCoherence), mpCFree); memset(o, 0, sizeof(mpCoherence)); x_pthread_mutex_init(&o->m_mutex, NULL); o->r_tasks = malloc(sizeof(mpCoTask) * in_tasks); memset(o->r_tasks, 0, sizeof(mpCoTask) * in_tasks); errorAssert(o->r_tasks != NULL, error_memory, "Failed allocating %i bytes for tasks", sizeof(mpCoTask) * in_tasks); o->m_nMaxTasks = in_tasks; o->m_nData = in_data; o->m_cacheSize = in_cache; #ifdef SEQUENTIAL o->r_stack = mpStackCreate(in_tasks * 2); #endif #ifdef COHERENCE_TQ o->r_q = mpQueueCreate(2048); #else o->r_q = mpQueueCreate(2); //Nice temp value #endif return o; }
static void get_path(t_env *val) { int i; int j; char *str; i = 5; j = 0; while (val->env[j] != '\0') { if (val->env[j][0] == 'P' && val->env[j][1] == 'A' && val->env[j][2] == 'T' && val->env[j][3] == 'H') break ; else j++; } str = (char *)x_malloc(sizeof(char) * ft_strlen(val->env[j]) - 4); while (val->env[j][i] != '\0') { str[i - 5] = val->env[j][i]; i++; } val->path = ft_strsplit(str, ':'); free(str); str = NULL; }
char *get_string_conf(char *conf_str, char *buf) { char *ptr1, *ptr2, *opt_conf; if((strncmp(buf, conf_str, strlen(conf_str))) == 0) { ptr1 = strchr(buf, '{'); if(ptr1 == NULL) return NULL; ptr1++; ptr2 = strchr(buf, '}'); if(ptr2 == NULL) return NULL; if((ptr2 - ptr1) > (MAX_CONFIGURATION_LINE_LEN - strlen(conf_str))) return NULL; opt_conf = (char *) x_malloc(ptr2 - ptr1 + 1); strlcpy(opt_conf, ptr1, ptr2 - ptr1 + 1); #ifdef DEBUG fprintf(stdout, "Got string option: %s %s\n", conf_str, opt_conf); #endif } return opt_conf; }
int main(int argc, char *argv[], char *envp[]) { t_tree *tree; t_env *env; char buf[SIZE]; int ret; env = (t_env *)x_malloc(sizeof(t_env)); env->env = get_env(envp); get_path(env); while (argv || argc) { ft_bzero(buf, SIZE); print_prompt(); ft_printf(" $>"); if ((ret = read(0, buf, SIZE)) < 2) continue ; buf[ret - 1] = '\0'; env->fst_cmd = ft_strdup(buf); if (!(tree = init_tree(env->fst_cmd))) continue ; ft_cmd_path(tree, env); ft_process(tree, env); free_tree(tree); free(env->fst_cmd); } return (0); }
static bool _internal_get_from_bb_string_alloc (xmmsv_t *bb, char **buf, unsigned int *len) { char *str; int32_t l; if (!_internal_get_from_bb_int32_positive (bb, &l)) { return false; } str = x_malloc (l + 1); if (!str) { return false; } if (!_internal_get_from_bb_data (bb, str, l)) { free (str); return false; } str[l] = '\0'; *buf = str; *len = l; return true; }
void init_term(t_area *ar, char **argv, int argc) { extern char **environ; ar->term = cpy_from_env(environ, "TERM="); if (ar->term == NULL) { my_put_error(ERR_TERM); exit(EXIT_FAILURE); } x_tgetent(tgetent(ar->bp, ar->term)); ar->area = ar->t; ar->clstr = xtgetstr("cl", &(ar->area)); ar->cmstr = xtgetstr("cm", &(ar->area)); ar->sostr = xtgetstr("so", &(ar->area)); ar->sestr = xtgetstr("se", &(ar->area)); ar->usstr = xtgetstr("us", &(ar->area)); ar->uestr = xtgetstr("ue", &(ar->area)); ar->li = tgetnum("li"); ar->co = tgetnum("co"); tputs(ar->clstr, 1, my_outc); argc = make_argc(ar, argc); ar->ac = argc - 1; ar->res = malloc(argc * sizeof(*(ar->res))); x_malloc(ar->res, argc); init_size(ar, argv); my_arg_cpy(ar, argv, argc); }
log_handler_t *log_create_handler(int verbose_level, int motion, const char *path, char **errstr) { handler_t *handler; char buffer[256]; // allocate handler handler=(handler_t *)x_malloc(sizeof(handler_t)); // set level handler->level=verbose_level; // motion handler->motion=motion; // open stream if(path==NULL) handler->stream=stdout; else { errno=0; handler->stream=fopen(path, "a"); if(handler->stream==NULL) { x_asprintf(errstr, "Error opening log file '%s': %s", path, strerror_r(errno, buffer, 256)); return NULL; } } return (log_handler_t *)handler; }
bool MibObjectInsert( mib_object_t *Object ) { i32 mindex, cmp, i; if(MibRoot->Count >= MibRoot->Size) { i32 n; mib_object_t **p; n = MibRoot->Size + 100; if( MibRoot->Table ) p = (mib_object_t **)x_realloc(MibRoot->Table, n*sizeof(mib_object_t *)); else p = (mib_object_t **)x_malloc(sizeof(mib_object_t *)); if (p == 0) return FALSE; MibRoot->Table = p; MibRoot->Size = n; } MibRoot->Table[MibRoot->Count] = Object; MibRoot->Count++; mindex = MibObjectFind(Object->Id, Object->IdLen, &cmp); if (cmp == 0 && mindex != MibRoot->Count-1) { MibRoot->Count--; return FALSE; } for(i = MibRoot->Count-1; i > mindex; i--) MibRoot->Table[i] = MibRoot->Table[i-1]; MibRoot->Table[mindex] = Object; return TRUE; }
char *epur_line(char *line) { int i; int n; char *ret; i = 0; n = 0; if (line == NULL) return (NULL); ret = x_malloc(strlen(line)); while (line[i] == ' ' || line[i] == '\t') i++; while (line[i + n] != '\0') { while (line[i + n] != '\0' && (line[i + n] == ' ' || line[i + n] == '\t') && (line[i + n + 1] == ' ' || line[i + n + 1] == '\t')) i++; ret[n] = line[i + n]; if (line[i + n] != '\0') n++; } ret[n] = '\0'; free (line); return (ret); }
static int x_vcam_on_append(x_object *so, x_object *parent) { int ofd; virtual_camera_t *mctl = (virtual_camera_t *) so; ENTER; mctl->w = 320; mctl->h = 240; /* init capture */ mctl->vfd = v4l2_capture_init(&mctl->_framebuf, &mctl->w, &mctl->h); mctl->framebuf = x_malloc(mctl->w * mctl->h * 3 / 2 + 1); TRACE("Opend camera at %dx%d\n", mctl->w, mctl->h); mctl->cam_qwartz.data = (void *) so; /** @todo This should be moved in x_object API */ ev_periodic_init(&mctl->cam_qwartz, __vcam_periodic_cb, 0., 0.06667, 0); x_object_add_watcher(so, &mctl->cam_qwartz, EVT_PERIODIC); #ifdef DEBUG ofd = open("yuv.out.dump", O_RDWR | O_TRUNC | O_CREAT, S_IRWXU | S_IRWXG | S_IRWXO); close(ofd); #endif EXIT; return 0; }
mib_local_t * MibInsert( snmp_object_t *Obj, mib_local_t **local, u16 IdLen, u16 IdSize ) { mib_local_t * Junk; mib_local_t * Local = *local; if(Obj->IdLen != (u32)(IdLen + IdSize) || Obj->Id[IdLen] < 1) { return NULL; } if((Junk = (mib_local_t *)x_malloc(sizeof(mib_local_t))) == NULL) { return NULL; } Junk->Index = Obj->Id[IdLen]; if(Local == NULL || Local->Index > Junk->Index) { Junk->Next = Local; *local = Junk; return Junk; } while(Local->Next != NULL && Local->Next->Index <= Junk->Index) Local = Local->Next; if(Local->Index == Junk->Index) { x_free(Junk); return Local; } Junk->Next = Local->Next; Local->Next = Junk; return Junk; }
char *get_next_line(const int fd, t_mysh *all) { int rd; char *output; static int i = 0; static char *buffer = NULL; /* if (fd == 0) return (empty_buffer(buffer));*/ rd = 1; if (buffer == NULL || buffer[i] == '\0') if ((buffer = my_read(fd, &i, &rd, buffer)) == NULL) return (NULL); output = x_malloc(sizeof(output) * (BUF_SIZE + 1)); all->gnl_j = 0; while (buffer[i] != '\n' && rd > 0) if (buffer[i] == '\0') { if ((buffer = my_read(fd, &i, &rd, buffer)) == NULL) return (output); output = my_realloc(all->gnl_j, output); } else output[all->gnl_j++] = buffer[i++]; output[all->gnl_j] = '\0'; i++; return (output); }
void gl_save_water_inc (gl_preview_struct *gl_preview) { // Public method // Save the current water plane parameters in "geomorph_water.inc" in the current directory // Eventually move in a scene management file FILE *fin; gchar *loc, *tmp, *msg_buf; if (!(fin=fopen("water.inc","wb"))) { msg_buf = (gchar *) x_malloc(sizeof(gchar) + strlen("water.inc") + strlen(_("Not able to open '%s' file for writing"))+5 , "const gchar (msg_buf - open file for writing)"); sprintf(msg_buf,_("Not able to open '%s' file for writing"),"water.inc"); my_msg(msg_buf,WARNING); } else { tmp = setlocale(LC_NUMERIC,NULL); // Povray uses "." as decimal separator instead of "," loc = (gchar *) malloc(strlen(tmp)+1); strcpy(loc,tmp); setlocale(LC_NUMERIC,"C"); if (gl_preview->use_water && *gl_preview->use_water) fprintf(fin,"#declare preview_water_level = %5.2f;\n",*gl_preview->water_level); else fprintf(fin," "); setlocale(LC_NUMERIC,loc); free(loc); fclose(fin); } }
view_struct *view_struct_new_with_rgb (gint width, gint height, void (*calc_buf) (gpointer, unsigned char*, gint, gint), gpointer external_data, gboolean if_rgb) { // Builds a preview structure, for a 8 bits image view_struct *vs; vs = (view_struct *) x_malloc(sizeof(view_struct), "view_struct"); // printf("View_struct_new: %d\n",vs); vs->width = width; vs->height = height; vs->calc_buf = calc_buf; vs->external_data = external_data; vs->if_rgb = if_rgb; if (if_rgb) vs->buf8 = (unsigned char *) x_calloc(3*width*height,sizeof(unsigned char), "unsigned char (vs->buf8 in view_area.c)"); else vs->buf8 = (unsigned char *) x_calloc(width*height,sizeof(unsigned char), "unsigned char (vs->buf8 in view_area.c)"); vs->area = gtk_drawing_area_new(); gtk_widget_set_size_request( GTK_WIDGET(vs->area), vs->width, vs->height); gtk_signal_connect(GTK_OBJECT(vs->area), "configure_event", (GtkSignalFunc) area_configure_event, (gpointer) vs); gtk_signal_connect(GTK_OBJECT(vs->area),"expose_event", (GtkSignalFunc) area_expose_event, (gpointer) vs); gtk_widget_show(vs->area); vs->viewport = NULL; return vs; }