// int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg); // http://man7.org/linux/man-pages/man2/msgsnd.2.html // // Sends a message to the message queue. VALUE sysvmq_send(int argc, VALUE *argv, VALUE self) { VALUE message; VALUE priority = INT2FIX(1); VALUE flags = INT2FIX(0); sysvmq_blocking_call_t blocking; sysvmq_t* sysv; if (argc > 3 || argc == 0) { rb_raise(rb_eArgError, "Wrong number of arguments (1..3)"); } message = argv[0]; if (argc >= 2) priority = argv[1]; if (argc == 3) flags = argv[2]; message = rb_funcall(message, rb_intern("to_s"), 0); TypedData_Get_Struct(self, sysvmq_t, &sysvmq_type, sysv); Check_Type(flags, T_FIXNUM); Check_Type(priority, T_FIXNUM); // TODO: Call to_s on message if it responds to // Attach blocking call parameters to the struct passed to the blocking // function wrapper. blocking.flags = FIX2INT(flags); blocking.size = RSTRING_LEN(message); blocking.sysv = sysv; // See msgrcv(2) wrapper blocking.error = UNINITIALIZED_ERROR; blocking.length = UNINITIALIZED_ERROR; // The buffer can be obtained from `sysvmq_maybe_blocking_send`, instead of // passing it, set it directly on the instance struct. sysv->msgbuf->mtype = FIX2INT(priority); if (blocking.size > sysv->buffer_size) { rb_raise(rb_eArgError, "Size of message is bigger than buffer size."); } // TODO: Can a string copy be avoided? memcpy(sysv->msgbuf->mtext, RSTRING_PTR(message), blocking.size); // Non-blocking call, skip the expensive GVL release/acquire if ((blocking.flags & IPC_NOWAIT) == IPC_NOWAIT) { while(sysvmq_maybe_blocking_send(&blocking) == NULL && blocking.error < 0) { if (errno == EINTR) { continue; } rb_sys_fail("Failed sending message to queue"); } } else { // msgsnd(2) can block waiting for a message, if IPC_NOWAIT is not passed. // We unlock the GVL waiting for the call so other threads (e.g. signal // handling) can continue to work. while (WITHOUT_GVL(sysvmq_maybe_blocking_send, &blocking, RUBY_UBF_IO, NULL) == NULL && blocking.error < 0) { if (errno == EINTR || blocking.error == UNINITIALIZED_ERROR) { continue; } rb_sys_fail("Failed sending message to queue"); } } return message; }
static VALUE rb_thread_safe_level(VALUE thread, SEL sel) { return INT2FIX(rb_vm_thread_safe_level(GetThreadPtr(thread))); }
void init_mpcrnd() { ID new_id = rb_intern ("new"); cMPC = rb_define_class ("MPC", rb_cNumeric); cMPC_Rnd = rb_define_class_under (cMPC, "Rnd", rb_cObject); rb_define_singleton_method (cMPC_Rnd, "new", r_mpcrndsg_new, -1); rb_define_method (cMPC_Rnd, "initialize", r_mpcrnd_initialize, -1); rb_define_method (cMPC_Rnd, "inspect", r_mpcrnd_inspect, 0); rb_define_attr (cMPC_Rnd, "mode", 1, 0); rb_define_attr (cMPC_Rnd, "name", 1, 0); rb_define_attr (cMPC_Rnd, "ieee754", 1, 0); rb_define_const(cMPC, "MPC_RNDNN", rb_funcall (cMPC_Rnd, new_id, 1, INT2FIX(0))); rb_define_const(cMPC, "MPC_RNDNZ", rb_funcall (cMPC_Rnd, new_id, 1, INT2FIX(16))); rb_define_const(cMPC, "MPC_RNDNU", rb_funcall (cMPC_Rnd, new_id, 1, INT2FIX(32))); rb_define_const(cMPC, "MPC_RNDND", rb_funcall (cMPC_Rnd, new_id, 1, INT2FIX(48))); rb_define_const(cMPC, "MPC_RNDZN", rb_funcall (cMPC_Rnd, new_id, 1, INT2FIX(1))); rb_define_const(cMPC, "MPC_RNDZZ", rb_funcall (cMPC_Rnd, new_id, 1, INT2FIX(17))); rb_define_const(cMPC, "MPC_RNDZU", rb_funcall (cMPC_Rnd, new_id, 1, INT2FIX(33))); rb_define_const(cMPC, "MPC_RNDZD", rb_funcall (cMPC_Rnd, new_id, 1, INT2FIX(49))); rb_define_const(cMPC, "MPC_RNDUN", rb_funcall (cMPC_Rnd, new_id, 1, INT2FIX(2))); rb_define_const(cMPC, "MPC_RNDUZ", rb_funcall (cMPC_Rnd, new_id, 1, INT2FIX(18))); rb_define_const(cMPC, "MPC_RNDUU", rb_funcall (cMPC_Rnd, new_id, 1, INT2FIX(34))); rb_define_const(cMPC, "MPC_RNDUD", rb_funcall (cMPC_Rnd, new_id, 1, INT2FIX(50))); rb_define_const(cMPC, "MPC_RNDDN", rb_funcall (cMPC_Rnd, new_id, 1, INT2FIX(3))); rb_define_const(cMPC, "MPC_RNDDZ", rb_funcall (cMPC_Rnd, new_id, 1, INT2FIX(19))); rb_define_const(cMPC, "MPC_RNDDU", rb_funcall (cMPC_Rnd, new_id, 1, INT2FIX(35))); rb_define_const(cMPC, "MPC_RNDDD", rb_funcall (cMPC_Rnd, new_id, 1, INT2FIX(51))); }
VALUE string_spec_RSTRING_LENINT(VALUE self, VALUE str) { return INT2FIX(RSTRING_LENINT(str)); }
VALUE string_spec_rb_str_set_len_RSTRING_LEN(VALUE self, VALUE str, VALUE len) { rb_str_set_len(str, NUM2LONG(len)); return INT2FIX(RSTRING_LEN(str)); }
void camera_update(GF_Camera *cam, GF_Matrix2D *user_transform, Bool center_coords, Fixed horizontal_shift, Fixed nominal_view_distance, Fixed view_distance_offset, u32 camera_layout) { Fixed vlen, h, w, ar; SFVec3f corner, center; GF_Matrix post_model_view; if (! (cam->flags & CAM_IS_DIRTY)) return; ar = gf_divfix(cam->width, cam->height); gf_mx_init(post_model_view); if (cam->is_3D) { /*setup perspective*/ if (camera_layout==GF_3D_CAMERA_OFFAXIS) { Fixed left, right, top, bottom, shift, wd2, ndfl, viewing_distance; SFVec3f eye, pos, tar, disp; viewing_distance = (nominal_view_distance + view_distance_offset); wd2 = cam->z_near * gf_tan(cam->fieldOfView/2); ndfl = gf_divfix(cam->z_near, viewing_distance); /*compute h displacement*/ shift = gf_mulfix(horizontal_shift, ndfl); top = wd2; bottom = -top; left = -ar * wd2 - shift; right = ar * wd2 - shift; gf_mx_init(cam->projection); cam->projection.m[0] = gf_divfix(2*cam->z_near, (right-left)); cam->projection.m[5] = gf_divfix(2*cam->z_near, (top-bottom)); cam->projection.m[8] = gf_divfix(right+left, right-left); cam->projection.m[9] = gf_divfix(top+bottom, top-bottom); cam->projection.m[10] = gf_divfix(cam->z_far+cam->z_near, cam->z_near-cam->z_far); cam->projection.m[11] = -FIX_ONE; cam->projection.m[14] = 2*gf_muldiv(cam->z_near, cam->z_far, cam->z_near-cam->z_far); cam->projection.m[15] = 0; gf_vec_diff(eye, cam->target, cam->position); gf_vec_norm(&eye); disp = gf_vec_cross(eye, cam->up); gf_vec_norm(&disp); gf_vec_diff(center, cam->world_bbox.center, cam->position); vlen = gf_vec_len(center); vlen += view_distance_offset * (vlen/nominal_view_distance); shift = horizontal_shift * vlen / viewing_distance; pos = gf_vec_scale(disp, shift); gf_vec_add(pos, pos, cam->position); gf_vec_add(tar, pos, eye); /*setup modelview*/ gf_mx_lookat(&cam->modelview, pos, tar, cam->up); } else { gf_mx_perspective(&cam->projection, cam->fieldOfView, ar, cam->z_near, cam->z_far); /*setup modelview*/ gf_mx_lookat(&cam->modelview, cam->position, cam->target, cam->up); } if (!center_coords) { gf_mx_add_scale(&post_model_view, 1, -1, 1); gf_mx_add_translation(&post_model_view, -cam->width / 2, -cam->height / 2, 0); } /*compute center and radius - CHECK ME!*/ vlen = cam->z_far - cam->z_near; h = gf_mulfix(vlen , gf_tan(cam->fieldOfView / 2)); w = gf_mulfix(h, ar); center.x = 0; center.y = 0; center.z = cam->z_near + vlen / 2; corner.x = w; corner.y = h; corner.z = vlen; gf_vec_diff(corner, corner, center); cam->radius = gf_vec_len(corner); gf_vec_diff(cam->center, cam->target, cam->position); gf_vec_norm(&cam->center); cam->center = gf_vec_scale(cam->center, cam->z_near + vlen/2); gf_vec_add(cam->center, cam->center, cam->position); } else { GF_BBox b; Fixed hw, hh; hw = cam->width / 2; hh = cam->height / 2; cam->z_near = INT2FIX(NEAR_PLANE_2D); cam->z_far = INT2FIX(FAR_PLANE_2D); /*setup ortho*/ gf_mx_ortho(&cam->projection, -hw, hw, -hh, hh, cam->z_near, cam->z_far); /*setup modelview*/ gf_mx_init(cam->modelview); #ifdef FORCE_CAMERA_3D if (! (cam->flags & CAM_NO_LOOKAT)) gf_mx_lookat(&cam->modelview, cam->position, cam->target, cam->up); #endif if (!center_coords) { gf_mx_add_scale(&post_model_view, 1, -1, 1); gf_mx_add_translation(&post_model_view, -hw, -hh, 0); } if (user_transform) { #ifdef FORCE_CAMERA_3D if (! (cam->flags & CAM_NO_LOOKAT)) { GF_Matrix mx; gf_mx_from_mx2d(&mx, user_transform); mx.m[10] = mx.m[0]; gf_mx_add_matrix(&post_model_view, &mx); } else #endif gf_mx_add_matrix_2d(&post_model_view, user_transform); } if (cam->end_zoom != FIX_ONE) gf_mx_add_scale(&post_model_view, cam->end_zoom, cam->end_zoom, cam->end_zoom); if (cam->flags & CAM_HAS_VIEWPORT) gf_mx_add_matrix(&post_model_view, &cam->viewport); /*compute center & radius*/ b.max_edge.x = hw; b.max_edge.y = hh; b.min_edge.x = -hw; b.min_edge.y = -hh; b.min_edge.z = b.max_edge.z = (cam->z_near+cam->z_far) / 2; gf_bbox_refresh(&b); cam->center = b.center; cam->radius = b.radius; if (camera_layout==GF_3D_CAMERA_OFFAXIS) camera_layout=GF_3D_CAMERA_LINEAR; } if (camera_layout == GF_3D_CAMERA_CIRCULAR) { GF_Matrix mx; Fixed viewing_distance = nominal_view_distance + view_distance_offset; SFVec3f pos, target; Fixed angle; gf_vec_diff(center, cam->world_bbox.center, cam->position); vlen = gf_vec_len(center); vlen += view_distance_offset * (vlen/nominal_view_distance); gf_vec_diff(pos, cam->target, cam->position); gf_vec_norm(&pos); pos = gf_vec_scale(pos, vlen); gf_vec_add(target, pos, cam->position); gf_mx_init(mx); gf_mx_add_translation(&mx, target.x, target.y, target.z); angle = gf_atan2(horizontal_shift, viewing_distance); gf_mx_add_rotation(&mx, angle, cam->up.x, cam->up.y, cam->up.z); gf_mx_add_translation(&mx, -target.x, -target.y, -target.z); pos = cam->position; gf_mx_apply_vec(&mx, &pos); gf_mx_lookat(&cam->modelview, pos, target, cam->up); } else if (camera_layout == GF_3D_CAMERA_LINEAR) { Fixed viewing_distance = nominal_view_distance + view_distance_offset; GF_Vec eye, disp, pos, tar; gf_vec_diff(center, cam->world_bbox.center, cam->position); vlen = gf_vec_len(center); vlen += view_distance_offset * (vlen/nominal_view_distance); gf_vec_diff(eye, cam->target, cam->position); gf_vec_norm(&eye); tar = gf_vec_scale(eye, vlen); gf_vec_add(tar, tar, cam->position); disp = gf_vec_cross(eye, cam->up); gf_vec_norm(&disp); disp= gf_vec_scale(disp, vlen*horizontal_shift/viewing_distance); gf_vec_add(pos, cam->position, disp); gf_mx_lookat(&cam->modelview, pos, tar, cam->up); } gf_mx_add_matrix(&cam->modelview, &post_model_view); /*compute frustum planes*/ gf_mx_copy(cam->unprojection, cam->projection); gf_mx_add_matrix_4x4(&cam->unprojection, &cam->modelview); camera_frustum_from_matrix(cam, &cam->unprojection); /*also compute reverse PM for unprojections*/ gf_mx_inverse_4x4(&cam->unprojection); cam->flags &= ~CAM_IS_DIRTY; }
VALUE string_spec_rb_str_len(VALUE self, VALUE str) { return INT2FIX(rb_str_len(str)); }
static VALUE control_block_reqprio_get(VALUE cb) { rb_aiocb_t *cbs = GetCBStruct(cb); return INT2FIX(cbs->cb.aio_reqprio); }
static VALUE control_block_lio_opcode_get(VALUE cb) { rb_aiocb_t *cbs = GetCBStruct(cb); return INT2FIX(cbs->cb.aio_lio_opcode); }
static VALUE control_block_nbytes_get(VALUE cb) { rb_aiocb_t *cbs = GetCBStruct(cb); return INT2FIX(cbs->cb.aio_nbytes); }
static VALUE control_block_offset_get(VALUE cb) { rb_aiocb_t *cbs = GetCBStruct(cb); return INT2FIX(cbs->cb.aio_offset); }
static VALUE rb_GSL_FFT_Wavetable_nf(VALUE obj) { GSL_FFT_Wavetable *table; Data_Get_Struct(obj, GSL_FFT_Wavetable, table); return INT2FIX(table->nf); }
/* * call-seq: * IO.console -> #<File:/dev/tty> * * Returns an File instance opened console. * * You must require 'io/console' to use this method. */ static VALUE console_dev(VALUE klass) { VALUE con = 0; rb_io_t *fptr; if (klass == rb_cIO) klass = rb_cFile; if (rb_const_defined(klass, id_console)) { con = rb_const_get(klass, id_console); if (RB_TYPE_P(con, T_FILE)) { if ((fptr = RFILE(con)->fptr) && GetReadFD(fptr) != -1) return con; } rb_mod_remove_const(klass, ID2SYM(id_console)); } { VALUE args[2]; #if defined HAVE_TERMIOS_H || defined HAVE_TERMIO_H || defined HAVE_SGTTY_H # define CONSOLE_DEVICE "/dev/tty" #elif defined _WIN32 # define CONSOLE_DEVICE "con$" # define CONSOLE_DEVICE_FOR_READING "conin$" # define CONSOLE_DEVICE_FOR_WRITING "conout$" #endif #ifndef CONSOLE_DEVICE_FOR_READING # define CONSOLE_DEVICE_FOR_READING CONSOLE_DEVICE #endif #ifdef CONSOLE_DEVICE_FOR_WRITING VALUE out; rb_io_t *ofptr; #endif int fd; #ifdef CONSOLE_DEVICE_FOR_WRITING fd = rb_cloexec_open(CONSOLE_DEVICE_FOR_WRITING, O_RDWR, 0); if (fd < 0) return Qnil; rb_update_max_fd(fd); args[1] = INT2FIX(O_WRONLY); args[0] = INT2NUM(fd); out = rb_class_new_instance(2, args, klass); #endif fd = rb_cloexec_open(CONSOLE_DEVICE_FOR_READING, O_RDWR, 0); if (fd < 0) { #ifdef CONSOLE_DEVICE_FOR_WRITING rb_io_close(out); #endif return Qnil; } rb_update_max_fd(fd); args[1] = INT2FIX(O_RDWR); args[0] = INT2NUM(fd); con = rb_class_new_instance(2, args, klass); GetOpenFile(con, fptr); #ifdef HAVE_RUBY_IO_H fptr->pathv = rb_obj_freeze(rb_str_new2(CONSOLE_DEVICE)); #else fptr->path = ruby_strdup(CONSOLE_DEVICE); #endif #ifdef CONSOLE_DEVICE_FOR_WRITING GetOpenFile(out, ofptr); # ifdef HAVE_RB_IO_GET_WRITE_IO ofptr->pathv = fptr->pathv; fptr->tied_io_for_writing = out; # else fptr->f2 = ofptr->f; ofptr->f = 0; # endif ofptr->mode |= FMODE_SYNC; #endif fptr->mode |= FMODE_SYNC; rb_const_set(klass, id_console, con); } return con; }
static void svg2bifs_node_start(void *sax_cbck, const char *name, const char *name_space, const GF_XMLAttribute *attributes, u32 nb_attributes) { u32 i; SVG2BIFS_Converter *converter = (SVG2BIFS_Converter *)sax_cbck; SVGPropertiesPointers *backup_props; char *id_string = NULL; u32 tag; SVG_Element *elt; SVG_DeferedAnimation *anim = NULL; tag = gf_xml_get_element_tag(name, 0); elt = (SVG_Element*)gf_node_new(converter->svg_sg, tag); if (!gf_sg_get_root_node(converter->svg_sg)) { gf_node_register((GF_Node *)elt, NULL); gf_sg_set_root_node(converter->svg_sg, (GF_Node *)elt); } else { gf_node_register((GF_Node *)elt, converter->svg_parent); //gf_node_list_add_child(&((GF_ParentNode*)converter->svg_parent)->children, (GF_Node *)elt); } // fprintf(stdout, "Converting %s\n", gf_node_get_class_name((GF_Node *)elt)); // if (converter->bifs_parent) fprintf(stdout, "%s\n", gf_node_get_class_name(converter->bifs_parent)); if (gf_svg_is_animation_tag(tag)) { GF_SAFEALLOC(anim, SVG_DeferedAnimation); /*default anim target is parent node*/ anim->animation_elt = elt; if (converter->svg_parent) { anim->target = anim->anim_parent = (SVG_Element*) converter->svg_parent; } } for (i=0; i<nb_attributes; i++) { GF_XMLAttribute *att = (GF_XMLAttribute *)&attributes[i]; if (!att->value || !strlen(att->value)) continue; if (!stricmp(att->name, "style")) { gf_svg_parse_style((GF_Node *)elt, att->value); } else if (!stricmp(att->name, "id") || !stricmp(att->name, "xml:id")) { gf_svg_parse_element_id((GF_Node *)elt, att->value, 0); id_string = att->value; } else if (anim && !stricmp(att->name, "to")) { anim->to = gf_strdup(att->value); } else if (anim && !stricmp(att->name, "from")) { anim->from = gf_strdup(att->value); } else if (anim && !stricmp(att->name, "by")) { anim->by = gf_strdup(att->value); } else if (anim && !stricmp(att->name, "values")) { anim->values = gf_strdup(att->value); } else if (anim && (tag == TAG_SVG_animateTransform) && !stricmp(att->name, "type")) { anim->type = gf_strdup(att->value); } else { GF_FieldInfo info; if (gf_node_get_field_by_name((GF_Node *)elt, att->name, &info)==GF_OK) { gf_svg_parse_attribute((GF_Node *)elt, &info, att->value, 0); } else { fprintf(stdout, "Skipping attribute %s\n", att->name); } } } if (anim) { svg_parse_animation(converter->svg_sg, anim); } memset(&converter->all_atts, 0, sizeof(SVGAllAttributes)); gf_svg_flatten_attributes(elt, &converter->all_atts); backup_props = gf_malloc(sizeof(SVGPropertiesPointers)); memcpy(backup_props, &converter->svg_props, sizeof(SVGPropertiesPointers)); gf_node_set_private((GF_Node *)elt, backup_props); gf_svg_apply_inheritance(&converter->all_atts, &converter->svg_props); fprintf(stdout, "START\t%s\t%s\t%s", converter->svg_parent ? gf_node_get_class_name(converter->svg_parent) : "none", converter->bifs_parent ? gf_node_get_class_name(converter->bifs_parent) : "none", name); converter->svg_parent = (GF_Node *)elt; if (!gf_sg_get_root_node(converter->bifs_sg)) { if (tag == TAG_SVG_svg) { GF_Node *node, *child; converter->bifs_sg->usePixelMetrics = 1; if (converter->all_atts.width && converter->all_atts.width->type == SVG_NUMBER_VALUE) { converter->bifs_sg->width = FIX2INT(converter->all_atts.width->value); } else { converter->bifs_sg->width = 320; } if (converter->all_atts.height && converter->all_atts.height->type == SVG_NUMBER_VALUE) { converter->bifs_sg->height = FIX2INT(converter->all_atts.height->value); } else { converter->bifs_sg->height = 200; } node = gf_node_new(converter->bifs_sg, TAG_MPEG4_OrderedGroup); gf_node_register(node, NULL); gf_sg_set_root_node(converter->bifs_sg, node); child = gf_node_new(converter->bifs_sg, TAG_MPEG4_QuantizationParameter); gf_node_register(child, node); gf_node_list_add_child(&((GF_ParentNode*)node)->children, child); { M_QuantizationParameter *qp = (M_QuantizationParameter *)child; qp->useEfficientCoding = 1; } /* SVG to BIFS coordinate transformation */ child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Viewport); gf_node_register(child, node); gf_node_list_add_child(&((GF_ParentNode*)node)->children, child); { M_Viewport *vp = (M_Viewport*)child; if (converter->all_atts.viewBox) { vp->size.x = converter->all_atts.viewBox->width; vp->size.y = converter->all_atts.viewBox->height; vp->position.x = converter->all_atts.viewBox->x+converter->all_atts.viewBox->width/2; vp->position.y = -(converter->all_atts.viewBox->y+converter->all_atts.viewBox->height/2); } else { vp->size.x = INT2FIX(converter->bifs_sg->width); vp->size.y = INT2FIX(converter->bifs_sg->height); vp->position.x = INT2FIX(converter->bifs_sg->width)/2; vp->position.y = -INT2FIX(converter->bifs_sg->height)/2; } } child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Background2D); gf_node_register(child, node); gf_node_list_add_child(&((GF_ParentNode*)node)->children, child); { M_Background2D *b = (M_Background2D *)child; b->backColor.red = FIX_ONE; b->backColor.green = FIX_ONE; b->backColor.blue = FIX_ONE; } child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Transform2D); gf_node_register(child, node); gf_node_list_add_child(&((GF_ParentNode*)node)->children, child); node = child; child = NULL; { M_Transform2D *tr = (M_Transform2D *)node; tr->scale.y = -FIX_ONE; } converter->bifs_parent = node; } } else { GF_Node *node, *child; node = converter->bifs_parent; switch(tag) { case TAG_SVG_g: { if (converter->all_atts.transform) { node = add_transform_matrix(converter, node); converter->bifs_parent = node; } else { M_Group *g = (M_Group*)gf_node_new(converter->bifs_sg, TAG_MPEG4_Group); gf_node_register((GF_Node *)g, node); gf_node_list_add_child(&((GF_ParentNode*)node)->children, (GF_Node *)g); node = (GF_Node *)g; converter->bifs_parent = node; } } break; case TAG_SVG_rect: { Bool is_parent_set = 0; if (converter->all_atts.transform) { node = add_transform_matrix(converter, node); converter->bifs_parent = node; is_parent_set = 1; } if (converter->force_transform) { node = add_transform2d(converter, node); if (!is_parent_set) { converter->bifs_parent = node; is_parent_set = 1; } } if (converter->all_atts.x || converter->all_atts.y) { child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Transform2D); gf_node_register(child, node); gf_node_list_add_child(&((GF_ParentNode*)node)->children, child); node = child; child = NULL; if (!is_parent_set) { converter->bifs_parent = node; is_parent_set = 1; } { M_Transform2D *tr = (M_Transform2D *)node; if (converter->all_atts.x) tr->translation.x = converter->all_atts.x->value + (converter->all_atts.width?converter->all_atts.width->value/2:0); if (converter->all_atts.y) tr->translation.y = converter->all_atts.y->value + (converter->all_atts.height?converter->all_atts.height->value/2:0); } } child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Shape); gf_node_register(child, node); gf_node_list_add_child(&((GF_ParentNode*)node)->children, child); node = child; child = NULL; if (!is_parent_set) converter->bifs_parent = node; { M_Shape *shape = (M_Shape *)node; shape->geometry = gf_node_new(converter->bifs_sg, TAG_MPEG4_Rectangle); gf_node_register(shape->geometry, (GF_Node *)shape); { M_Rectangle *rect = (M_Rectangle *)shape->geometry; if (converter->all_atts.width) rect->size.x = converter->all_atts.width->value; if (converter->all_atts.height) rect->size.y = converter->all_atts.height->value; } shape->appearance = create_appearance(&converter->svg_props, converter->bifs_sg); gf_node_register(shape->appearance, (GF_Node *)shape); } } break; case TAG_SVG_path: { Bool is_parent_set = 0; if (converter->all_atts.transform) { node = add_transform_matrix(converter, node); converter->bifs_parent = node; is_parent_set = 1; } if (converter->force_transform) { node = add_transform2d(converter, node); if (!is_parent_set) { converter->bifs_parent = node; is_parent_set = 1; } } if (converter->all_atts.x || converter->all_atts.y) { child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Transform2D); gf_node_register(child, node); gf_node_list_add_child(&((GF_ParentNode*)node)->children, child); node = child; child = NULL; if (!is_parent_set) { converter->bifs_parent = node; is_parent_set = 1; } { M_Transform2D *tr = (M_Transform2D *)node; if (converter->all_atts.x) tr->translation.x = converter->all_atts.x->value; if (converter->all_atts.y) tr->translation.y = converter->all_atts.y->value; } } child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Shape); gf_node_register(child, node); gf_node_list_add_child(&((GF_ParentNode*)node)->children, child); node = child; child = NULL; if (!is_parent_set) converter->bifs_parent = node; { M_Shape *shape = (M_Shape *)node; shape->geometry = gf_node_new(converter->bifs_sg, TAG_MPEG4_XCurve2D); gf_node_register(shape->geometry, (GF_Node *)shape); if (converter->all_atts.d) { M_Coordinate2D *c2d; M_XCurve2D *xc = (M_XCurve2D *)shape->geometry; u32 i, j, c, k; xc->point = gf_node_new(converter->bifs_sg, TAG_MPEG4_Coordinate2D); c2d = (M_Coordinate2D *)xc->point; gf_node_register(xc->point, (GF_Node *)xc); gf_sg_vrml_mf_alloc(&c2d->point, GF_SG_VRML_MFVEC2F, converter->all_atts.d->n_points); gf_sg_vrml_mf_alloc(&xc->type, GF_SG_VRML_MFINT32, converter->all_atts.d->n_points); c = 0; k = 0; j = 0; c2d->point.vals[k] = converter->all_atts.d->points[0]; k++; xc->type.vals[0] = 0; for (i = 1; i < converter->all_atts.d->n_points; ) { switch(converter->all_atts.d->tags[i]) { case GF_PATH_CURVE_ON: c2d->point.vals[k] = converter->all_atts.d->points[i]; k++; if (i-1 == converter->all_atts.d->contours[c]) { xc->type.vals[j] = 0; c++; } else { xc->type.vals[j] = 1; } i++; break; case GF_PATH_CURVE_CUBIC: c2d->point.vals[k] = converter->all_atts.d->points[i]; c2d->point.vals[k+1] = converter->all_atts.d->points[i+1]; c2d->point.vals[k+2] = converter->all_atts.d->points[i+2]; k+=3; xc->type.vals[j] = 2; if (converter->all_atts.d->tags[i+2]==GF_PATH_CLOSE) { j++; xc->type.vals[j] = 6; } i+=3; break; case GF_PATH_CLOSE: xc->type.vals[j] = 6; i++; break; case GF_PATH_CURVE_CONIC: c2d->point.vals[k] = converter->all_atts.d->points[i]; c2d->point.vals[k+1] = converter->all_atts.d->points[i+1]; k+=2; xc->type.vals[j] = 7; if (converter->all_atts.d->tags[i+1]==GF_PATH_CLOSE) { j++; xc->type.vals[j] = 6; } i+=2; break; } j++; } xc->type.count = j; c2d->point.count = k; } shape->appearance = create_appearance(&converter->svg_props, converter->bifs_sg); gf_node_register(shape->appearance, (GF_Node *)shape); } } break; case TAG_SVG_polyline: { Bool is_parent_set = 0; if (converter->all_atts.transform) { node = add_transform_matrix(converter, node); converter->bifs_parent = node; is_parent_set = 1; } if (converter->force_transform) { node = add_transform2d(converter, node); if (!is_parent_set) { converter->bifs_parent = node; is_parent_set = 1; } } child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Shape); gf_node_register(child, node); gf_node_list_add_child(&((GF_ParentNode*)node)->children, child); node = child; child = NULL; if (!is_parent_set) converter->bifs_parent = node; { M_Shape *shape = (M_Shape *)node; shape->geometry = gf_node_new(converter->bifs_sg, TAG_MPEG4_IndexedFaceSet2D); gf_node_register(shape->geometry, (GF_Node *)shape); if (converter->all_atts.points) { M_Coordinate2D *c2d; M_IndexedFaceSet2D *ifs = (M_IndexedFaceSet2D *)shape->geometry; u32 i; ifs->coord = gf_node_new(converter->bifs_sg, TAG_MPEG4_Coordinate2D); c2d = (M_Coordinate2D *)ifs->coord; gf_node_register(ifs->coord, (GF_Node *)ifs); gf_sg_vrml_mf_alloc(&c2d->point, GF_SG_VRML_MFVEC2F, gf_list_count(*converter->all_atts.points)); for (i = 0; i < gf_list_count(*converter->all_atts.points); i++) { SVG_Point *p = (SVG_Point *)gf_list_get(*converter->all_atts.points, i); c2d->point.vals[i].x = p->x; c2d->point.vals[i].y = p->y; } } shape->appearance = create_appearance(&converter->svg_props, converter->bifs_sg); gf_node_register(shape->appearance, (GF_Node *)shape); } } break; case TAG_SVG_text: { Bool is_parent_set = 0; if (converter->all_atts.transform) { node = add_transform_matrix(converter, node); converter->bifs_parent = node; is_parent_set = 1; } if (converter->force_transform) { node = add_transform2d(converter, node); if (!is_parent_set) { converter->bifs_parent = node; is_parent_set = 1; } } child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Transform2D); gf_node_register(child, node); gf_node_list_add_child(&((GF_ParentNode*)node)->children, child); { M_Transform2D *tr = (M_Transform2D *)child; if (converter->all_atts.text_x) tr->translation.x = ((SVG_Coordinate *)gf_list_get(*converter->all_atts.text_x, 0))->value; if (converter->all_atts.text_y) tr->translation.y = ((SVG_Coordinate *)gf_list_get(*converter->all_atts.text_y, 0))->value; tr->scale.y = -FIX_ONE; } node = child; child = NULL; if (!is_parent_set) { converter->bifs_parent = node; is_parent_set = 1; } child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Shape); gf_node_register(child, node); gf_node_list_add_child(&((GF_ParentNode*)node)->children, child); node = child; child = NULL; if (!is_parent_set) converter->bifs_parent = node; { M_FontStyle *fs; M_Text *text; M_Shape *shape = (M_Shape *)node; text = (M_Text *)gf_node_new(converter->bifs_sg, TAG_MPEG4_Text); shape->geometry = (GF_Node *)text; converter->bifs_text_node = shape->geometry; gf_node_register(shape->geometry, (GF_Node *)shape); fs = (M_FontStyle *)gf_node_new(converter->bifs_sg, TAG_MPEG4_XFontStyle); gf_node_register((GF_Node *)fs, (GF_Node*)text); text->fontStyle = (GF_Node *)fs; gf_sg_vrml_mf_alloc(&fs->family, GF_SG_VRML_MFSTRING, 1); fs->family.vals[0] = gf_strdup(converter->svg_props.font_family->value); fs->size = converter->svg_props.font_size->value; shape->appearance = create_appearance(&converter->svg_props, converter->bifs_sg); gf_node_register(shape->appearance, (GF_Node *)shape); } } break; case TAG_SVG_ellipse: case TAG_SVG_circle: { Bool is_parent_set = 0; if (converter->all_atts.transform) { node = add_transform_matrix(converter, node); converter->bifs_parent = node; is_parent_set = 1; } if (converter->force_transform) { node = add_transform2d(converter, node); if (!is_parent_set) { converter->bifs_parent = node; is_parent_set = 1; } } if (converter->all_atts.cx || converter->all_atts.cy) { child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Transform2D); gf_node_register(child, node); gf_node_list_add_child(&((GF_ParentNode*)node)->children, child); { M_Transform2D *tr = (M_Transform2D *)child; if (converter->all_atts.cx) tr->translation.x = converter->all_atts.cx->value; if (converter->all_atts.cy) tr->translation.y = converter->all_atts.cy->value; } node = child; child = NULL; if (!is_parent_set) { converter->bifs_parent = node; is_parent_set = 1; } } child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Shape); gf_node_register(child, node); gf_node_list_add_child(&((GF_ParentNode*)node)->children, child); node = child; child = NULL; if (!is_parent_set) converter->bifs_parent = node; { M_Shape *shape = (M_Shape *)node; if (tag == TAG_SVG_ellipse) { M_Ellipse *e = (M_Ellipse *)gf_node_new(converter->bifs_sg, TAG_MPEG4_Ellipse); shape->geometry = (GF_Node *)e; e->radius.x = converter->all_atts.rx->value; e->radius.y = converter->all_atts.ry->value; } else { M_Circle *c = (M_Circle *)gf_node_new(converter->bifs_sg, TAG_MPEG4_Circle); shape->geometry = (GF_Node *)c; c->radius = converter->all_atts.r->value; } gf_node_register(shape->geometry, (GF_Node *)shape); shape->appearance = create_appearance(&converter->svg_props, converter->bifs_sg); gf_node_register(shape->appearance, (GF_Node *)shape); } } break; case TAG_SVG_defs: { child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Switch); gf_node_register(child, node); gf_node_list_add_child(&((GF_ParentNode*)node)->children, child); node = child; child = NULL; { M_Switch *sw = (M_Switch *)node; sw->whichChoice = -1; } converter->bifs_parent = node; } break; case TAG_SVG_solidColor: { child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Shape); gf_node_register(child, node); gf_node_list_add_child(&((GF_ParentNode*)node)->children, child); node = child; child = NULL; converter->bifs_parent = node; } break; case TAG_SVG_animateTransform: { GF_Node *child_ts; if (!gf_node_get_id(node)) { gf_node_set_id(node, gf_sg_get_next_available_node_id(converter->bifs_sg), NULL); } child_ts = gf_node_new(converter->bifs_sg, TAG_MPEG4_TimeSensor); if (!gf_node_get_id(child_ts)) { gf_node_set_id(child_ts, gf_sg_get_next_available_node_id(converter->bifs_sg), NULL); } gf_node_register(child_ts, node); gf_node_list_add_child(&((GF_ParentNode *)node)->children, child_ts); { M_TimeSensor *ts = (M_TimeSensor *)child_ts; if (converter->all_atts.dur) { ts->cycleInterval = converter->all_atts.dur->clock_value; } if (converter->all_atts.repeatCount && converter->all_atts.repeatCount->type == SMIL_REPEATCOUNT_INDEFINITE) { ts->loop = 1; } } if (converter->all_atts.transform_type) { GF_FieldInfo fromField, toField; switch (*converter->all_atts.transform_type) { case SVG_TRANSFORM_ROTATE: child = gf_node_new(converter->bifs_sg, TAG_MPEG4_PositionInterpolator2D); if (!gf_node_get_id(child)) { gf_node_set_id(child, gf_sg_get_next_available_node_id(converter->bifs_sg), NULL); } gf_node_register(child, node); gf_node_list_add_child(&((GF_ParentNode *)node)->children, child); gf_node_get_field_by_name(child_ts, "fraction_changed", &fromField); gf_node_get_field_by_name(child, "set_fraction", &toField); gf_sg_route_new(converter->bifs_sg, child_ts, fromField.fieldIndex, child, toField.fieldIndex); gf_node_get_field_by_name(child, "value_changed", &fromField); gf_node_get_field_by_name(node, "rotationAngle", &toField); gf_sg_route_new(converter->bifs_sg, child, fromField.fieldIndex, node, toField.fieldIndex); { M_PositionInterpolator2D *pi2d = (M_PositionInterpolator2D *)child; if (converter->all_atts.keyTimes) { SFFloat *g; u32 count, i; count = gf_list_count(*converter->all_atts.keyTimes); for (i = 0; i < count; i++) { Fixed *f = gf_list_get(*converter->all_atts.keyTimes, i); gf_sg_vrml_mf_append(&pi2d->key, GF_SG_VRML_MFFLOAT, &g); *g = *f; } } if (converter->all_atts.values) { SFVec2f *g; u32 count, i; count = gf_list_count(converter->all_atts.values->values); for (i = 0; i < count; i++) { SVG_Point_Angle *p; p = gf_list_get(converter->all_atts.values->values, i); gf_sg_vrml_mf_append(&pi2d->keyValue, GF_SG_VRML_MFVEC2F, &g); g->x = p->x; g->y = p->y; } } } child = gf_node_new(converter->bifs_sg, TAG_MPEG4_ScalarInterpolator); if (!gf_node_get_id(child)) { gf_node_set_id(child, gf_sg_get_next_available_node_id(converter->bifs_sg), NULL); } gf_node_register(child, node); gf_node_list_add_child(&((GF_ParentNode *)node)->children, child); gf_node_get_field_by_name(child_ts, "fraction_changed", &fromField); gf_node_get_field_by_name(child, "set_fraction", &toField); gf_sg_route_new(converter->bifs_sg, child_ts, fromField.fieldIndex, child, toField.fieldIndex); gf_node_get_field_by_name(child, "value_changed", &fromField); gf_node_get_field_by_name(node, "center", &toField); gf_sg_route_new(converter->bifs_sg, child, fromField.fieldIndex, node, toField.fieldIndex); { M_ScalarInterpolator *si = (M_ScalarInterpolator *)child; if (converter->all_atts.keyTimes) { SFFloat *g; u32 count, i; count = gf_list_count(*converter->all_atts.keyTimes); for (i = 0; i < count; i++) { Fixed *f = gf_list_get(*converter->all_atts.keyTimes, i); gf_sg_vrml_mf_append(&si->key, GF_SG_VRML_MFFLOAT, &g); *g = *f; } } if (converter->all_atts.values) { SFFloat *g; u32 count, i; count = gf_list_count(converter->all_atts.values->values); for (i = 0; i < count; i++) { SVG_Point_Angle *p; p = gf_list_get(converter->all_atts.values->values, i); gf_sg_vrml_mf_append(&si->keyValue, GF_SG_VRML_MFFLOAT, &g); *g = p->angle; } } } break; case SVG_TRANSFORM_SCALE: case SVG_TRANSFORM_TRANSLATE: child = gf_node_new(converter->bifs_sg, TAG_MPEG4_PositionInterpolator2D); if (!gf_node_get_id(child)) { gf_node_set_id(child, gf_sg_get_next_available_node_id(converter->bifs_sg), NULL); } gf_node_register(child, node); gf_node_list_add_child(&((GF_ParentNode *)node)->children, child); gf_node_get_field_by_name(child_ts, "fraction_changed", &fromField); gf_node_get_field_by_name(child, "set_fraction", &toField); gf_sg_route_new(converter->bifs_sg, child_ts, fromField.fieldIndex, child, toField.fieldIndex); gf_node_get_field_by_name(child, "value_changed", &fromField); if (*converter->all_atts.transform_type == SVG_TRANSFORM_SCALE) gf_node_get_field_by_name(node, "scale", &toField); else gf_node_get_field_by_name(node, "translation", &toField); gf_sg_route_new(converter->bifs_sg, child, fromField.fieldIndex, node, toField.fieldIndex); { M_PositionInterpolator2D *pi2d = (M_PositionInterpolator2D *)child; if (converter->all_atts.keyTimes) { SFFloat *g; u32 count, i; count = gf_list_count(*converter->all_atts.keyTimes); for (i = 0; i < count; i++) { Fixed *f = gf_list_get(*converter->all_atts.keyTimes, i); gf_sg_vrml_mf_append(&pi2d->key, GF_SG_VRML_MFFLOAT, &g); *g = *f; } } if (converter->all_atts.values) { SFVec2f *g; u32 count, i; count = gf_list_count(converter->all_atts.values->values); for (i = 0; i < count; i++) { SVG_Point *p; p = gf_list_get(converter->all_atts.values->values, i); gf_sg_vrml_mf_append(&pi2d->keyValue, GF_SG_VRML_MFVEC2F, &g); g->x = p->x; g->y = p->y; } } } break; default: fprintf(stdout, "Warning: transformation type not supported \n"); } } //converter->bifs_parent = node; } break; default: { fprintf(stdout, "Warning: element %s not supported \n", gf_node_get_class_name((GF_Node *)elt)); child = gf_node_new(converter->bifs_sg, TAG_MPEG4_Transform2D); gf_node_register(child, node); //gf_node_list_add_child(&((GF_ParentNode*)node)->children, child); node = child; child = NULL; converter->bifs_parent = node; } break; } if (id_string) gf_node_set_id(converter->bifs_parent, gf_sg_get_next_available_node_id(converter->bifs_sg), NULL);//gf_node_get_name((GF_Node *)elt)); } fprintf(stdout, "\t%s\n", converter->bifs_parent ? gf_node_get_class_name(converter->bifs_parent) : "none"); }
/* GravityFind {{{ */ static VALUE GravityFind(char *source, int flags) { int ngravities = 0; char **gravities = NULL; VALUE ret = Qnil; subSubtlextConnect(NULL); ///< Implicit open connection /* Get gravity list */ if((gravities = subSharedPropertyGetStrings(display, DefaultRootWindow(display), XInternAtom(display, "SUBTLE_GRAVITY_LIST", False), &ngravities))) { int i, selid = -1; XRectangle geometry = { 0 }; char buf[30] = { 0 }; VALUE klass_grav = Qnil, klass_geom = Qnil, meth = Qnil; VALUE gravity = Qnil, geom = Qnil; regex_t *preg = NULL; /* Fetch data */ klass_grav = rb_const_get(mod, rb_intern("Gravity")); klass_geom = rb_const_get(mod, rb_intern("Geometry")); meth = rb_intern("new"); /* Create if source is given */ if(source) { if(isdigit(source[0])) selid = atoi(source); preg = subSharedRegexNew(source); } /* Create gravity list */ for(i = 0; i < ngravities; i++) { sscanf(gravities[i], "%hdx%hd+%hd+%hd#%s", &geometry.x, &geometry.y, &geometry.width, &geometry.height, buf); /* Check if gravity matches */ if(!source || (source && (selid == i || (-1 == selid && ((flags & SUB_MATCH_EXACT && 0 == strcmp(source, buf)) || (preg && !(flags & SUB_MATCH_EXACT) && subSharedRegexMatch(preg, buf))))))) { /* Create new gravity */ gravity = rb_funcall(klass_grav, meth, 1, rb_str_new2(buf)); geom = rb_funcall(klass_geom, meth, 4, INT2FIX(geometry.x), INT2FIX(geometry.y), INT2FIX(geometry.width), INT2FIX(geometry.height)); rb_iv_set(gravity, "@id", INT2FIX(i)); rb_iv_set(gravity, "@geometry", geom); ret = subSubtlextOneOrMany(gravity, ret); } } if(preg) subSharedRegexKill(preg); XFreeStringList(gravities); } else rb_raise(rb_eStandardError, "Failed getting gravity list"); return NIL_P(ret) ? rb_ary_new() : ret; } /* }}} */
VALUE rb_utf_collate(UNUSED(VALUE self), VALUE str, VALUE other) { return INT2FIX(utf_collate(StringValuePtr(str), StringValuePtr(other))); }
VALUE subGravityUpdate(VALUE self) { int id = -1; XRectangle geom = { 0 }; char *name = NULL; VALUE match = Qnil; /* Check ruby object */ rb_check_frozen(self); GET_ATTR(self, "@name", match); /* Find gravity */ if(-1 == (id = GravityFindId(RSTRING_PTR(match), &name, &geom))) { SubMessageData data = { { 0, 0, 0, 0, 0 } }; VALUE geometry = rb_iv_get(self, "@geometry"); if(NIL_P(geometry = rb_iv_get(self, "@geometry"))) rb_raise(rb_eStandardError, "No geometry given"); subGeometryToRect(geometry, &geom); ///< Get values /* Create new gravity */ snprintf(data.b, sizeof(data.b), "%hdx%hd+%hd+%hd#%s", geom.x, geom.y, geom.width, geom.height, RSTRING_PTR(match)); subSharedMessage(display, DefaultRootWindow(display), "SUBTLE_GRAVITY_NEW", data, 8, True); id = GravityFindId(RSTRING_PTR(match), NULL, NULL); } else ///< Update gravity { VALUE geometry = Qnil; geometry = subGeometryInstantiate(geom.x, geom.y, geom.width, geom.height); rb_iv_set(self, "@name", rb_str_new2(name)); rb_iv_set(self, "@gravity", geometry); free(name); } /* Guess gravity id */ if(-1 == id) { int ngravities = 0; char **gravities = NULL; gravities = subSharedPropertyGetStrings(display, DefaultRootWindow(display), XInternAtom(display, "SUBTLE_GRAVITY_LIST", False), &ngravities); id = ngravities; ///< New id should be last XFreeStringList(gravities); } rb_iv_set(self, "@id", INT2FIX(id)); return Qnil; } /* }}} */
void Init_swfblendmode() { rb_cSWFBlendMode = rb_define_class_under(rb_mMing, "SWFBlendMode", rb_cObject); rb_define_const(rb_cSWFBlendMode, "NULL", INT2FIX(SWFBLEND_MODE_NULL)); rb_define_const(rb_cSWFBlendMode, "NORMAL", INT2FIX(SWFBLEND_MODE_NORMAL)); rb_define_const(rb_cSWFBlendMode, "LAYER", INT2FIX(SWFBLEND_MODE_LAYER)); rb_define_const(rb_cSWFBlendMode, "MULT", INT2FIX(SWFBLEND_MODE_MULT)); rb_define_const(rb_cSWFBlendMode, "SCREEN", INT2FIX(SWFBLEND_MODE_SCREEN)); rb_define_const(rb_cSWFBlendMode, "LIGHTEN", INT2FIX(SWFBLEND_MODE_LIGHTEN)); rb_define_const(rb_cSWFBlendMode, "DARKEN", INT2FIX(SWFBLEND_MODE_DARKEN)); rb_define_const(rb_cSWFBlendMode, "DIFF", INT2FIX(SWFBLEND_MODE_DIFF)); rb_define_const(rb_cSWFBlendMode, "ADD", INT2FIX(SWFBLEND_MODE_ADD)); rb_define_const(rb_cSWFBlendMode, "SUB", INT2FIX(SWFBLEND_MODE_SUB)); rb_define_const(rb_cSWFBlendMode, "INV", INT2FIX(SWFBLEND_MODE_INV)); rb_define_const(rb_cSWFBlendMode, "ALPHA", INT2FIX(SWFBLEND_MODE_ALPHA)); rb_define_const(rb_cSWFBlendMode, "ERASE", INT2FIX(SWFBLEND_MODE_ERASE)); rb_define_const(rb_cSWFBlendMode, "OVER_LAY", INT2FIX(SWFBLEND_MODE_OVERLAY)); rb_define_const(rb_cSWFBlendMode, "HARD_LIGHT", INT2FIX(SWFBLEND_MODE_HARDLIGHT)); return; }
static void args_setup_kw_parameters(VALUE* const passed_values, const int passed_keyword_len, const VALUE *const passed_keywords, const rb_iseq_t * const iseq, VALUE * const locals) { const ID *acceptable_keywords = iseq->body->param.keyword->table; const int req_key_num = iseq->body->param.keyword->required_num; const int key_num = iseq->body->param.keyword->num; const VALUE * const default_values = iseq->body->param.keyword->default_values; VALUE missing = 0; int i, di, found = 0; int unspecified_bits = 0; VALUE unspecified_bits_value = Qnil; for (i=0; i<req_key_num; i++) { ID key = acceptable_keywords[i]; if (args_setup_kw_parameters_lookup(key, &locals[i], passed_keywords, passed_values, passed_keyword_len)) { found++; } else { if (!missing) missing = rb_ary_tmp_new(1); rb_ary_push(missing, ID2SYM(key)); } } if (missing) argument_kw_error(GET_THREAD(), iseq, "missing", missing); for (di=0; i<key_num; i++, di++) { if (args_setup_kw_parameters_lookup(acceptable_keywords[i], &locals[i], passed_keywords, passed_values, passed_keyword_len)) { found++; } else { if (default_values[di] == Qundef) { locals[i] = Qnil; if (LIKELY(i < 32)) { /* TODO: 32 -> Fixnum's max bits */ unspecified_bits |= 0x01 << di; } else { if (NIL_P(unspecified_bits_value)) { /* fixnum -> hash */ int j; unspecified_bits_value = rb_hash_new(); for (j=0; j<32; j++) { if (unspecified_bits & (0x01 << j)) { rb_hash_aset(unspecified_bits_value, INT2FIX(j), Qtrue); } } } rb_hash_aset(unspecified_bits_value, INT2FIX(di), Qtrue); } } else { locals[i] = default_values[di]; } } } if (iseq->body->param.flags.has_kwrest) { const int rest_hash_index = key_num + 1; locals[rest_hash_index] = make_unused_kw_hash(passed_keywords, passed_keyword_len, passed_values, FALSE); } else { if (found != passed_keyword_len) { VALUE keys = make_unused_kw_hash(passed_keywords, passed_keyword_len, passed_values, TRUE); argument_kw_error(GET_THREAD(), iseq, "unknown", keys); } } if (NIL_P(unspecified_bits_value)) { unspecified_bits_value = INT2FIX(unspecified_bits); } locals[key_num] = unspecified_bits_value; }
static VALUE RenderImage_GetHeight( VALUE self ) { sf::RenderImage *object = NULL; Data_Get_Struct( self, sf::RenderImage, object ); return INT2FIX( object->GetHeight() ); }
VALUE string_spec_rb_str_resize_RSTRING_LEN(VALUE self, VALUE str, VALUE size) { VALUE modified = rb_str_resize(str, FIX2INT(size)); return INT2FIX(RSTRING_LEN(modified)); }
void rb_sqlite3_raise(sqlite3 * db, int status) { VALUE klass = Qnil; /* Consider only lower 8 bits, to work correctly when extended result codes are enabled. */ switch(status & 0xff) { case SQLITE_OK: return; break; case SQLITE_ERROR: klass = rb_path2class("SQLite3::SQLException"); break; case SQLITE_INTERNAL: klass = rb_path2class("SQLite3::InternalException"); break; case SQLITE_PERM: klass = rb_path2class("SQLite3::PermissionException"); break; case SQLITE_ABORT: klass = rb_path2class("SQLite3::AbortException"); break; case SQLITE_BUSY: klass = rb_path2class("SQLite3::BusyException"); break; case SQLITE_LOCKED: klass = rb_path2class("SQLite3::LockedException"); break; case SQLITE_NOMEM: klass = rb_path2class("SQLite3::MemoryException"); break; case SQLITE_READONLY: klass = rb_path2class("SQLite3::ReadOnlyException"); break; case SQLITE_INTERRUPT: klass = rb_path2class("SQLite3::InterruptException"); break; case SQLITE_IOERR: klass = rb_path2class("SQLite3::IOException"); break; case SQLITE_CORRUPT: klass = rb_path2class("SQLite3::CorruptException"); break; case SQLITE_NOTFOUND: klass = rb_path2class("SQLite3::NotFoundException"); break; case SQLITE_FULL: klass = rb_path2class("SQLite3::FullException"); break; case SQLITE_CANTOPEN: klass = rb_path2class("SQLite3::CantOpenException"); break; case SQLITE_PROTOCOL: klass = rb_path2class("SQLite3::ProtocolException"); break; case SQLITE_EMPTY: klass = rb_path2class("SQLite3::EmptyException"); break; case SQLITE_SCHEMA: klass = rb_path2class("SQLite3::SchemaChangedException"); break; case SQLITE_TOOBIG: klass = rb_path2class("SQLite3::TooBigException"); break; case SQLITE_CONSTRAINT: klass = rb_path2class("SQLite3::ConstraintException"); break; case SQLITE_MISMATCH: klass = rb_path2class("SQLite3::MismatchException"); break; case SQLITE_MISUSE: klass = rb_path2class("SQLite3::MisuseException"); break; case SQLITE_NOLFS: klass = rb_path2class("SQLite3::UnsupportedException"); break; case SQLITE_AUTH: klass = rb_path2class("SQLite3::AuthorizationException"); break; case SQLITE_FORMAT: klass = rb_path2class("SQLite3::FormatException"); break; case SQLITE_RANGE: klass = rb_path2class("SQLite3::RangeException"); break; case SQLITE_NOTADB: klass = rb_path2class("SQLite3::NotADatabaseException"); break; default: klass = rb_eRuntimeError; } klass = rb_exc_new2(klass, sqlite3_errmsg(db)); rb_iv_set(klass, "@code", INT2FIX(status)); rb_exc_raise(klass); }
static VALUE string_spec_rb_str_hash(VALUE self, VALUE str) { return INT2FIX(rb_str_hash(str)); }
/* * call-seq: * Errno.code => Fixnum * * Returns the current errno value. */ static VALUE errno_code(VALUE self, SEL sel) { return INT2FIX(errno); }
static void TraverseUntransform(GF_Node *node, void *rs, Bool is_destroy) { UntransformStack *stack = (UntransformStack *)gf_node_get_private(node); GF_TraverseState *tr_state = (GF_TraverseState *) rs; if (is_destroy) { gf_free(stack); return; } if (tr_state->traversing_mode==TRAVERSE_SORT) { if (gf_node_dirty_get(node)) { Untransform_GetNode(node, &stack->untr); /*lets place it below*/ gf_node_dirty_clear(node, GF_SG_NODE_DIRTY); } } #ifndef GPAC_DISABLE_3D if (tr_state->visual->type_3d) { GF_Matrix mx_model; GF_Camera backup_cam; if (!tr_state->camera) return; gf_mx_copy(mx_model, tr_state->model_matrix); gf_mx_init(tr_state->model_matrix); memcpy(&backup_cam, tr_state->camera, sizeof(GF_Camera)); camera_invalidate(tr_state->camera); tr_state->camera->is_3D=0; tr_state->camera->flags |= CAM_NO_LOOKAT; tr_state->camera->end_zoom = FIX_ONE; camera_update(tr_state->camera, NULL, 1, 0, 0, 0, GF_3D_CAMERA_STRAIGHT); if (tr_state->traversing_mode == TRAVERSE_SORT) { visual_3d_set_matrix_mode(tr_state->visual, V3D_MATRIX_PROJECTION); visual_3d_matrix_load(tr_state->visual, tr_state->camera->projection.m); visual_3d_set_matrix_mode(tr_state->visual, V3D_MATRIX_MODELVIEW); visual_3d_matrix_load(tr_state->visual, tr_state->camera->modelview.m); visual_3d_set_viewport(tr_state->visual, tr_state->camera->vp); gf_node_traverse_children((GF_Node *)&stack->untr, tr_state); gf_mx_copy(tr_state->model_matrix, mx_model); memcpy(tr_state->camera, &backup_cam, sizeof(GF_Camera)); visual_3d_set_matrix_mode(tr_state->visual, V3D_MATRIX_PROJECTION); visual_3d_matrix_load(tr_state->visual, tr_state->camera->projection.m); visual_3d_set_matrix_mode(tr_state->visual, V3D_MATRIX_MODELVIEW); visual_3d_matrix_load(tr_state->visual, tr_state->camera->modelview.m); visual_3d_set_viewport(tr_state->visual, tr_state->camera->vp); } else if (tr_state->traversing_mode == TRAVERSE_PICK) { Fixed prev_dist = tr_state->visual->compositor->hit_square_dist; GF_Ray r = tr_state->ray; tr_state->ray.orig.x = INT2FIX(tr_state->pick_x); tr_state->ray.orig.y = INT2FIX(tr_state->pick_y); tr_state->ray.orig.z = 0; tr_state->ray.dir.x = 0; tr_state->ray.dir.y = 0; tr_state->ray.dir.z = -FIX_ONE; tr_state->visual->compositor->hit_square_dist=0; gf_node_traverse_children((GF_Node *)&stack->untr, tr_state); gf_mx_copy(tr_state->model_matrix, mx_model); memcpy(tr_state->camera, &backup_cam, sizeof(GF_Camera)); tr_state->ray = r; /*nothing picked, restore previous pick*/ if (!tr_state->visual->compositor->hit_square_dist) tr_state->visual->compositor->hit_square_dist = prev_dist; } else { gf_node_traverse_children((GF_Node *)&stack->untr, tr_state); gf_mx_copy(tr_state->model_matrix, mx_model); memcpy(tr_state->camera, &backup_cam, sizeof(GF_Camera)); } } else #endif { GF_Matrix2D mx2d_backup; gf_mx2d_copy(mx2d_backup, tr_state->transform); gf_mx2d_init(tr_state->transform); group_2d_traverse((GF_Node *)&stack->untr, (GroupingNode2D *)stack, tr_state); gf_mx2d_copy(tr_state->transform, mx2d_backup); } }
static Bool compositor_handle_navigation_3d(GF_Compositor *compositor, GF_Event *ev) { Fixed x, y, trans_scale; Fixed dx, dy, key_trans, key_pan, key_exam; s32 key_inv; u32 keys; Bool is_pixel_metrics; GF_Camera *cam; Fixed zoom = compositor->zoom; cam = NULL; if (compositor->active_layer) { #ifndef GPAC_DISABLE_VRML cam = compositor_layer3d_get_camera(compositor->active_layer); is_pixel_metrics = gf_sg_use_pixel_metrics(gf_node_get_graph(compositor->active_layer)); #endif } if (!cam) { cam = &compositor->visual->camera; assert(compositor); assert(compositor->scene); is_pixel_metrics = compositor->traverse_state->pixel_metrics; } keys = compositor->key_states; if (!cam->navigate_mode && !(keys & GF_KEY_MOD_ALT) ) return 0; x = y = 0; /*renorm between -1, 1*/ if (ev->type<=GF_EVENT_MOUSEWHEEL) { x = gf_divfix( INT2FIX(ev->mouse.x + (s32) compositor->visual->width/2), INT2FIX(compositor->visual->width)); y = gf_divfix( INT2FIX(ev->mouse.y + (s32) compositor->visual->height/2), INT2FIX(compositor->visual->height)); } dx = (x - compositor->grab_x); dy = (compositor->grab_y - y); /* trans_scale = is_pixel_metrics ? cam->width/2 : INT2FIX(10); key_trans = is_pixel_metrics ? INT2FIX(10) : cam->avatar_size.x; */ trans_scale = cam->width/20; key_trans = cam->avatar_size.x; if (cam->world_bbox.is_set && (key_trans*5 > cam->world_bbox.radius)) { key_trans = cam->world_bbox.radius / 10; } key_pan = FIX_ONE/25; key_exam = FIX_ONE/10; key_inv = 1; if (keys & GF_KEY_MOD_SHIFT) { dx *= 4; dy *= 4; key_pan *= 4; key_exam *= 4; key_trans*=4; } switch (ev->type) { case GF_EVENT_MOUSEDOWN: /*left*/ if (ev->mouse.button==GF_MOUSE_LEFT) { compositor->grab_x = x; compositor->grab_y = y; compositor->navigation_state = 1; /*change vp and examine center to current location*/ if ((keys & GF_KEY_MOD_CTRL) && compositor->hit_square_dist) { cam->vp_position = cam->position; cam->vp_orientation = camera_get_orientation(cam->position, cam->target, cam->up); cam->vp_fov = cam->fieldOfView; cam->examine_center = compositor->hit_world_point; camera_changed(compositor, cam); return 1; } } /*right*/ else if (ev->mouse.button==GF_MOUSE_RIGHT) { if (compositor->navigation_state && (cam->navigate_mode==GF_NAVIGATE_WALK)) { camera_jump(cam); gf_sc_invalidate(compositor, NULL); return 1; } else if (keys & GF_KEY_MOD_CTRL) gf_sc_fit_world_to_screen(compositor); } break; /* note: shortcuts are mostly the same as blaxxun contact, I don't feel like remembering 2 sets...*/ case GF_EVENT_MOUSEMOVE: if (!compositor->navigation_state) { if (cam->navigate_mode==GF_NAVIGATE_GAME) { /*init mode*/ compositor->grab_x = x; compositor->grab_y = y; compositor->navigation_state = 1; } return 0; } compositor->navigation_state++; switch (cam->navigate_mode) { /*FIXME- we'll likely need a "step" value for walk at some point*/ case GF_NAVIGATE_WALK: case GF_NAVIGATE_FLY: view_pan_x(compositor, cam, -dx); if (keys & GF_KEY_MOD_CTRL) view_pan_y(compositor, cam, dy); else view_translate_z(compositor, cam, gf_mulfix(dy, trans_scale)); break; case GF_NAVIGATE_VR: view_pan_x(compositor, cam, -dx); if (keys & GF_KEY_MOD_CTRL) view_zoom(compositor, cam, dy); else view_pan_y(compositor, cam, dy); break; case GF_NAVIGATE_PAN: view_pan_x(compositor, cam, -dx); if (keys & GF_KEY_MOD_CTRL) view_translate_z(compositor, cam, gf_mulfix(dy, trans_scale)); else view_pan_y(compositor, cam, dy); break; case GF_NAVIGATE_SLIDE: view_translate_x(compositor, cam, gf_mulfix(dx, trans_scale)); if (keys & GF_KEY_MOD_CTRL) view_translate_z(compositor, cam, gf_mulfix(dy, trans_scale)); else view_translate_y(compositor, cam, gf_mulfix(dy, trans_scale)); break; case GF_NAVIGATE_EXAMINE: if (keys & GF_KEY_MOD_CTRL) { view_translate_z(compositor, cam, gf_mulfix(dy, trans_scale)); view_roll(compositor, cam, gf_mulfix(dx, trans_scale)); } else { view_exam_x(compositor, cam, -gf_mulfix(GF_PI, dx)); view_exam_y(compositor, cam, gf_mulfix(GF_PI, dy)); } break; case GF_NAVIGATE_ORBIT: if (keys & GF_KEY_MOD_CTRL) { view_translate_z(compositor, cam, gf_mulfix(dy, trans_scale)); } else { view_orbit_x(compositor, cam, -gf_mulfix(GF_PI, dx)); view_orbit_y(compositor, cam, gf_mulfix(GF_PI, dy)); } break; case GF_NAVIGATE_GAME: view_pan_x(compositor, cam, -dx); view_pan_y(compositor, cam, dy); break; } compositor->grab_x = x; compositor->grab_y = y; return 1; case GF_EVENT_MOUSEWHEEL: switch (cam->navigate_mode) { /*FIXME- we'll likely need a "step" value for walk at some point*/ case GF_NAVIGATE_WALK: case GF_NAVIGATE_FLY: view_pan_y(compositor, cam, gf_mulfix(key_pan, ev->mouse.wheel_pos)); break; case GF_NAVIGATE_VR: view_zoom(compositor, cam, gf_mulfix(key_pan, ev->mouse.wheel_pos)); break; case GF_NAVIGATE_SLIDE: case GF_NAVIGATE_EXAMINE: case GF_NAVIGATE_ORBIT: case GF_NAVIGATE_PAN: if (cam->is_3D) { view_translate_z(compositor, cam, gf_mulfix(trans_scale, ev->mouse.wheel_pos) * ((keys & GF_KEY_MOD_SHIFT) ? 4 : 1)); } else { nav_set_zoom_trans_2d(compositor->visual, zoom + INT2FIX(ev->mouse.wheel_pos)/10, 0, 0); } } return 1; case GF_EVENT_MOUSEUP: if (ev->mouse.button==GF_MOUSE_LEFT) compositor->navigation_state = 0; break; case GF_EVENT_KEYDOWN: switch (ev->key.key_code) { case GF_KEY_BACKSPACE: gf_sc_reset_graphics(compositor); return 1; case GF_KEY_C: compositor->collide_mode = compositor->collide_mode ? GF_COLLISION_NONE : GF_COLLISION_DISPLACEMENT; return 1; case GF_KEY_J: if (cam->navigate_mode==GF_NAVIGATE_WALK) { camera_jump(cam); gf_sc_invalidate(compositor, NULL); return 1; } break; case GF_KEY_HOME: if (!compositor->navigation_state) { compositor->visual->camera.start_zoom = compositor->zoom; compositor->zoom = FIX_ONE; compositor->interoccular_offset = 0; compositor->view_distance_offset = 0; compositor->interoccular_offset = 0; compositor->view_distance_offset = 0; compositor_3d_reset_camera(compositor); } break; case GF_KEY_END: if (cam->navigate_mode==GF_NAVIGATE_GAME) { cam->navigate_mode = GF_NAVIGATE_WALK; compositor->navigation_state = 0; return 1; } break; case GF_KEY_LEFT: key_inv = -1; case GF_KEY_RIGHT: if (keys & GF_KEY_MOD_ALT) { if ( (keys & GF_KEY_MOD_SHIFT) && (compositor->visual->nb_views > 1) ) { compositor->view_distance_offset += key_inv * (is_pixel_metrics ? INT2FIX(1) : FLT2FIX(0.1)); cam->flags |= CAM_IS_DIRTY; fprintf(stdout, "AutoStereo view distance %f\n", FIX2FLT(compositor->view_distance_offset + compositor->video_out->view_distance)/100); gf_sc_invalidate(compositor, NULL); return 1; } return 0; } switch (cam->navigate_mode) { case GF_NAVIGATE_SLIDE: if (keys & GF_KEY_MOD_CTRL) view_pan_x(compositor, cam, key_inv * key_pan); else view_translate_x(compositor, cam, key_inv * key_trans); break; case GF_NAVIGATE_EXAMINE: if (keys & GF_KEY_MOD_CTRL) view_roll(compositor, cam, gf_mulfix(dx, trans_scale)); else view_exam_x(compositor, cam, -key_inv * key_exam); break; case GF_NAVIGATE_ORBIT: if (keys & GF_KEY_MOD_CTRL) view_translate_x(compositor, cam, key_inv * key_trans); else view_orbit_x(compositor, cam, -key_inv * key_exam); break; case GF_NAVIGATE_GAME: view_translate_x(compositor, cam, key_inv * key_trans); break; case GF_NAVIGATE_VR: view_pan_x(compositor, cam, -key_inv * key_pan); break; /*walk/fly/pan*/ default: if (keys & GF_KEY_MOD_CTRL) view_translate_x(compositor, cam, key_inv * key_trans); else view_pan_x(compositor, cam, -key_inv * key_pan); break; } return 1; case GF_KEY_DOWN: key_inv = -1; case GF_KEY_UP: if (keys & GF_KEY_MOD_ALT) { if ( (keys & GF_KEY_MOD_SHIFT) && (compositor->visual->nb_views > 1) ) { compositor->interoccular_offset += FLT2FIX(0.5) * key_inv; fprintf(stdout, "AutoStereo interoccular distance %f\n", FIX2FLT(compositor->interoccular_offset)+6.8); cam->flags |= CAM_IS_DIRTY; gf_sc_invalidate(compositor, NULL); return 1; } return 0; } switch (cam->navigate_mode) { case GF_NAVIGATE_SLIDE: if (keys & GF_KEY_MOD_CTRL) view_translate_z(compositor, cam, key_inv * key_trans); else view_translate_y(compositor, cam, key_inv * key_trans); break; case GF_NAVIGATE_EXAMINE: if (keys & GF_KEY_MOD_CTRL) view_translate_z(compositor, cam, key_inv * key_trans); else view_exam_y(compositor, cam, -key_inv * key_exam); break; case GF_NAVIGATE_ORBIT: if (keys & GF_KEY_MOD_CTRL) view_translate_y(compositor, cam, key_inv * key_trans); else view_orbit_y(compositor, cam, -key_inv * key_exam); break; case GF_NAVIGATE_PAN: if (keys & GF_KEY_MOD_CTRL) view_translate_y(compositor, cam, key_inv * key_trans); else view_pan_y(compositor, cam, key_inv * key_pan); break; case GF_NAVIGATE_GAME: view_translate_z(compositor, cam, key_inv * key_trans); break; case GF_NAVIGATE_VR: if (keys & GF_KEY_MOD_CTRL) view_zoom(compositor, cam, key_inv * key_pan); else view_pan_y(compositor, cam, key_inv * key_pan); break; /*walk/fly*/ default: if (keys & GF_KEY_MOD_CTRL) view_pan_y(compositor, cam, key_inv * key_pan); else view_translate_z(compositor, cam, key_inv * key_trans); break; } return 1; case GF_KEY_PAGEDOWN: if (keys & GF_KEY_MOD_CTRL) { view_zoom(compositor, cam, FIX_ONE/10); return 1; } break; case GF_KEY_PAGEUP: if (keys & GF_KEY_MOD_CTRL) { view_zoom(compositor, cam, -FIX_ONE/10); return 1; } break; } break; } return 0; }
/* * Returns the record in this DtraceBufdata. Records are returned as * either DtraceRecords or DtraceStackRecords as appropriate for the * type of action. */ VALUE dtracebufdata_record(VALUE self) { dtrace_bufdata_t *bufdata; const dtrace_recdesc_t *rec; dtrace_actkind_t act = DTRACEACT_NONE; const char *s; VALUE v = Qnil; VALUE dtracerecord; VALUE dtraceaggdata; VALUE dtracerecdesc; Data_Get_Struct(self, dtrace_bufdata_t, bufdata); if (bufdata->dtbda_aggdata) { dtraceaggdata = Data_Wrap_Struct(cDtraceAggData, 0, NULL, (dtrace_bufdata_t *)bufdata); return dtraceaggdata; } s = bufdata->dtbda_buffered; if (s == NULL) { return Qnil; } rec = bufdata->dtbda_recdesc; if (rec) { act = rec->dtrd_action; } switch (act) { case DTRACEACT_DIFEXPR: /* trace() action */ break; case DTRACEACT_PRINTF: /* printf action, not available in probedata */ v = rb_str_new2(s); dtracerecord = rb_class_new_instance(0, NULL, rb_path2class("Dtrace::PrintfRecord")); rb_iv_set(dtracerecord, "@from", rb_str_new2("bufdata")); rb_iv_set(dtracerecord, "@value", v); return (dtracerecord); break; case DTRACEACT_STACK: case DTRACEACT_USTACK: case DTRACEACT_JSTACK: /* stand-alone stack(), ustack(), or jstack() action */ v = rb_str_new2(s); dtracerecord = rb_class_new_instance(0, NULL, rb_path2class("Dtrace::StackRecord")); rb_iv_set(dtracerecord, "@from", rb_str_new2("bufdata")); rb_funcall(dtracerecord, rb_intern("parse"), 1, v); return (dtracerecord); break; case DTRACEACT_USYM: case DTRACEACT_UADDR: case DTRACEACT_UMOD: case DTRACEACT_SYM: case DTRACEACT_MOD: v = rb_str_new2(s); break; case DTRACEACT_PRINTA: v = rb_str_new2(s); break; default: /* * The record handle defers nothing else to this * bufhandler. */ break; } if (!NIL_P(v)) { dtracerecord = rb_class_new_instance(0, NULL, rb_path2class("Dtrace::Record")); rb_iv_set(dtracerecord, "@value", v); rb_iv_set(dtracerecord, "@action", INT2FIX(act)); rb_iv_set(dtracerecord, "@from", rb_str_new2("bufdata")); return (dtracerecord); } else { return Qnil; } }
static Bool compositor_handle_navigation_2d(GF_VisualManager *visual, GF_Event *ev) { Fixed x, y, dx, dy, key_trans, key_rot, zoom, new_zoom; u32 navigation_mode; s32 key_inv; Bool is_pixel_metrics = visual->compositor->traverse_state->pixel_metrics; u32 keys = visual->compositor->key_states; zoom = visual->compositor->zoom; navigation_mode = visual->compositor->navigate_mode; #ifndef GPAC_DISABLE_3D if (visual->type_3d) navigation_mode = visual->camera.navigate_mode; #endif if (!navigation_mode && !(keys & GF_KEY_MOD_ALT) ) return 0; x = y = 0; /*renorm between -1, 1*/ if (ev->type<=GF_EVENT_MOUSEWHEEL) { x = INT2FIX(ev->mouse.x); y = INT2FIX(ev->mouse.y); } dx = x - visual->compositor->grab_x; dy = visual->compositor->grab_y - y; if (!is_pixel_metrics) { dx /= visual->width; dy /= visual->height; } key_inv = 1; key_trans = INT2FIX(2); key_rot = GF_PI/100; if (keys & GF_KEY_MOD_SHIFT) { dx *= 4; dy *= 4; key_rot *= 4; key_trans*=4; } if (!is_pixel_metrics) { key_trans /= visual->width;} switch (ev->type) { case GF_EVENT_MOUSEDOWN: /*left*/ if (ev->mouse.button==GF_MOUSE_LEFT) { visual->compositor->grab_x = x; visual->compositor->grab_y = y; visual->compositor->navigation_state = 1; /*update zoom center*/ if (keys & GF_KEY_MOD_CTRL) { visual->compositor->trans_x -= visual->compositor->grab_x - INT2FIX(visual->width)/2; visual->compositor->trans_y += INT2FIX(visual->height)/2 - visual->compositor->grab_y; nav_set_zoom_trans_2d(visual, visual->compositor->zoom, 0, 0); } return 0; } break; case GF_EVENT_MOUSEUP: if (ev->mouse.button==GF_MOUSE_LEFT) { visual->compositor->navigation_state = 0; return 0; } break; case GF_EVENT_MOUSEWHEEL: switch (navigation_mode) { case GF_NAVIGATE_SLIDE: new_zoom = zoom + INT2FIX(ev->mouse.wheel_pos)/10; nav_set_zoom_trans_2d(visual, new_zoom, 0, 0); return 1; case GF_NAVIGATE_EXAMINE: if (ev->mouse.wheel_pos>0) visual->compositor->rotation += gf_asin( GF_PI / 10); else visual->compositor->rotation -= gf_asin( GF_PI / 10); nav_set_zoom_trans_2d(visual, zoom, 0, 0); return 1; } return 0; case GF_EVENT_MOUSEMOVE: if (!visual->compositor->navigation_state) return 0; visual->compositor->navigation_state++; switch (navigation_mode) { case GF_NAVIGATE_SLIDE: if (keys & GF_KEY_MOD_CTRL) { if (dy) { new_zoom = zoom; if (new_zoom > FIX_ONE) new_zoom += dy/20; else new_zoom += dy/80; nav_set_zoom_trans_2d(visual, new_zoom, 0, 0); } } else { nav_set_zoom_trans_2d(visual, zoom, dx, dy); } break; case GF_NAVIGATE_EXAMINE: { Fixed sin = gf_mulfix(GF_PI, dy) / visual->height; //truncate in [-1;1] for arcsin() if (sin < -FIX_ONE) sin = -FIX_ONE; if (sin > FIX_ONE) sin = FIX_ONE; visual->compositor->rotation += gf_asin(sin); nav_set_zoom_trans_2d(visual, zoom, 0, 0); } break; } visual->compositor->grab_x = x; visual->compositor->grab_y = y; return 1; case GF_EVENT_KEYDOWN: switch (ev->key.key_code) { case GF_KEY_BACKSPACE: gf_sc_reset_graphics(visual->compositor); return 1; case GF_KEY_HOME: if (!visual->compositor->navigation_state) { visual->compositor->trans_x = visual->compositor->trans_y = 0; visual->compositor->rotation = 0; visual->compositor->zoom = FIX_ONE; nav_set_zoom_trans_2d(visual, FIX_ONE, 0, 0); } return 1; case GF_KEY_LEFT: key_inv = -1; case GF_KEY_RIGHT: if (navigation_mode == GF_NAVIGATE_SLIDE) { nav_set_zoom_trans_2d(visual, zoom, key_inv*key_trans, 0); } else { visual->compositor->rotation -= key_inv * key_rot; nav_set_zoom_trans_2d(visual, zoom, 0, 0); } return 1; case GF_KEY_DOWN: key_inv = -1; case GF_KEY_UP: if (navigation_mode == GF_NAVIGATE_SLIDE) { if (keys & GF_KEY_MOD_CTRL) { Fixed new_zoom = zoom; if (new_zoom > FIX_ONE) new_zoom += key_inv*FIX_ONE/10; else new_zoom += key_inv*FIX_ONE/20; nav_set_zoom_trans_2d(visual, new_zoom, 0, 0); } else { nav_set_zoom_trans_2d(visual, zoom, 0, key_inv*key_trans); } } else { visual->compositor->rotation += key_inv*key_rot; nav_set_zoom_trans_2d(visual, zoom, 0, 0); } return 1; } break; } return 0; }
VALUE event_cast<VALUE, jobject>(jobject jEvent) { RHO_TRACE("eventToRuby"); if (!jEvent) return Qnil; RHO_TRACE("eventToRuby init JNI"); JNIEnv *env = jnienv(); if (!init_event_stuff(env)) { RHO_TRACE("eventToRuby failed to init JNI"); return Qnil; } RHO_TRACE("eventToRuby alloc event hash"); VALUE rEvent = rb_hash_new(); RHO_TRACE("eventToRuby get event id"); jstring jId = (jstring)env->GetObjectField(jEvent, fidId); std::string s = rho_cast<std::string>(env, jId); env->DeleteLocalRef(jId); rb_hash_aset(rEvent, rb_str_new2(RUBY_EV_ID), rb_str_new2(s.c_str())); RHO_TRACE("eventToRuby get title"); jstring jTitle = (jstring)env->GetObjectField(jEvent, fidTitle); s = rho_cast<std::string>(env, jTitle); env->DeleteLocalRef(jTitle); rb_hash_aset(rEvent, rb_str_new2(RUBY_EV_TITLE), rb_str_new2(s.c_str())); RHO_TRACE("eventToRuby get start date"); jobject jStartDate = env->GetObjectField(jEvent, fidStartDate); rb_hash_aset(rEvent, rb_str_new2(RUBY_EV_START_DATE), date_cast<VALUE>(jStartDate)); env->DeleteLocalRef(jStartDate); RHO_TRACE("eventToRuby get end date"); jobject jEndDate = env->GetObjectField(jEvent, fidEndDate); rb_hash_aset(rEvent, rb_str_new2(RUBY_EV_END_DATE), date_cast<VALUE>(jEndDate)); env->DeleteLocalRef(jEndDate); RHO_TRACE("eventToRuby get last modified date"); jobject jLastModified = env->GetObjectField(jEvent, fidLastModified); rb_hash_aset(rEvent, rb_str_new2(RUBY_EV_LAST_MODIFIED), date_cast<VALUE>(jLastModified)); env->DeleteLocalRef(jLastModified); RHO_TRACE("eventToRuby get location"); jstring jLocation = (jstring)env->GetObjectField(jEvent, fidLocation); if (jLocation) { s = rho_cast<std::string>(env, jLocation); env->DeleteLocalRef(jLocation); rb_hash_aset(rEvent, rb_str_new2(RUBY_EV_LOCATION), rb_str_new2(s.c_str())); } RHO_TRACE("eventToRuby get notes"); jstring jNotes = (jstring)env->GetObjectField(jEvent, fidNotes); if (jNotes) { s = rho_cast<std::string>(env, jNotes); env->DeleteLocalRef(jNotes); rb_hash_aset(rEvent, rb_str_new2(RUBY_EV_NOTES), rb_str_new2(s.c_str())); } RHO_TRACE("eventToRuby get privacy"); jstring jPrivacy = (jstring)env->GetObjectField(jEvent, fidPrivacy); if (jPrivacy) { s = rho_cast<std::string>(env, jPrivacy); env->DeleteLocalRef(jPrivacy); rb_hash_aset(rEvent, rb_str_new2(RUBY_EV_PRIVACY), rb_str_new2(s.c_str())); } RHO_TRACE("eventToRuby frequency"); jstring jFrequency = (jstring)env->GetObjectField(jEvent, fidFrequency); if(jFrequency) { RHO_TRACE("eventToRuby parse frequency"); VALUE rRecurrence = rb_hash_new(); jboolean isCopy; const char* str = env->GetStringUTFChars (jFrequency, &isCopy); if(strcasecmp(str, RUBY_EV_RECURRENCE_FREQUENCY_DAILY) == 0 || strcasecmp(str, RUBY_EV_RECURRENCE_FREQUENCY_WEEKLY) == 0 || strcasecmp(str, RUBY_EV_RECURRENCE_FREQUENCY_MONTHLY) == 0 || strcasecmp(str, RUBY_EV_RECURRENCE_FREQUENCY_YEARLY) == 0) { s = rho_cast<std::string>(env, jFrequency); } else { s = "undefined"; // rb_raise(rb_eArgError, "Wrong recurrence frequency: %s", frequency); } if (isCopy == JNI_TRUE) { env->ReleaseStringUTFChars (jFrequency, str); } rb_hash_aset(rRecurrence, rb_str_new2(RUBY_EV_RECURRENCE_FREQUENCY), rb_str_new2(s.c_str())); env->DeleteLocalRef(jFrequency); jint jInterval = (jint)env->GetIntField(jEvent, fidInterval); rb_hash_aset(rRecurrence, rb_str_new2(RUBY_EV_RECURRENCE_INTERVAL), INT2FIX((int)jInterval)); jhobject jhUntil = env->GetObjectField(jEvent, fidRecurrenceEnd); if(jhUntil.get()) { rb_hash_aset(rRecurrence, rb_str_new2(RUBY_EV_RECURRENCE_END), date_cast<VALUE>(jhUntil.get())); } jint jCount = env->GetIntField(jEvent, fidRecurrenceTimes); rb_hash_aset(rRecurrence, rb_str_new2(RUBY_EV_RECURRENCE_COUNT), INT2FIX((int)jCount)); rb_hash_aset(rEvent, rb_str_new2(RUBY_EV_RECURRENCE), rRecurrence); } RHO_TRACE("eventToRuby: return"); return rEvent; }
void Init_gdk_window(VALUE mGdk) { GObjectClass *g_class; VALUE RG_TARGET_NAMESPACE = G_DEF_CLASS(GDK_TYPE_WINDOW, "Window", mGdk); g_class = g_type_class_peek(GDK_TYPE_WINDOW); RG_DEF_METHOD(initialize, 3); RG_DEF_METHOD(destroy, 0); RG_DEF_METHOD(window_type, 0); RG_DEF_SMETHOD(at_pointer, 0); RG_DEF_SMETHOD(constrain_size, 4); RG_DEF_SMETHOD(process_all_updates, 0); RG_DEF_SMETHOD(set_debug_updates, 1); RG_DEF_METHOD(show, 0); RG_DEF_METHOD(show_unraised, 0); RG_DEF_METHOD(hide, 0); RG_DEF_METHOD_P(visible, 0); RG_DEF_METHOD_P(viewable, 0); RG_DEF_METHOD(withdraw, 0); RG_DEF_METHOD(state, 0); RG_DEF_METHOD(iconify, 0); RG_DEF_METHOD(deiconify, 0); RG_DEF_METHOD(stick, 0); RG_DEF_METHOD(unstick, 0); RG_DEF_METHOD(maximize, 0); RG_DEF_METHOD(unmaximize, 0); RG_DEF_METHOD(fullscreen, 0); RG_DEF_METHOD(unfullscreen, 0); RG_DEF_METHOD(set_keep_above, 1); RG_DEF_METHOD(set_keep_below, 1); RG_DEF_METHOD(move, 2); RG_DEF_METHOD(resize, 2); RG_DEF_METHOD(move_resize, 4); RG_DEF_METHOD(scroll, 2); RG_DEF_METHOD(move_region, 3); RG_DEF_METHOD(reparent, 3); RG_DEF_METHOD(raise, 0); RG_DEF_METHOD(lower, 0); RG_DEF_METHOD(focus, 1); RG_DEF_METHOD(register_dnd, 0); RG_DEF_METHOD(beep, 0); RG_DEF_METHOD(begin_resize_drag, 5); RG_DEF_METHOD(begin_move_drag, 4); RG_DEF_METHOD(begin_paint, 1); RG_DEF_METHOD(end_paint, 0); RG_DEF_METHOD(invalidate, 2); RG_DEF_METHOD(invalidate_maybe_recurse, 1); RG_DEF_METHOD(update_area, 0); RG_DEF_METHOD(freeze_updates, 0); RG_DEF_METHOD(thaw_updates, 0); RG_DEF_METHOD(process_updates, 1); RG_DEF_METHOD(configure_finished, 0); RG_DEF_METHOD(enable_synchronized_configure, 0); RG_DEF_METHOD(set_user_data, 1); RG_DEF_METHOD(set_override_redirect, 1); RG_DEF_METHOD(set_accept_focus, 1); RG_DEF_METHOD(set_focus_on_map, 1); RG_DEF_METHOD(shape_combine_region, 3); RG_DEF_METHOD(set_child_shapes, 0); RG_DEF_METHOD(merge_child_shapes, 0); RG_DEF_METHOD(input_shape_combine_region, 3); RG_DEF_METHOD(set_child_input_shapes, 0); RG_DEF_METHOD(merge_child_input_shapes, 0); RG_DEF_METHOD(set_static_gravities, 1); RG_DEF_METHOD(set_title, 1); RG_DEF_METHOD(set_background, 1); RG_DEF_METHOD(user_data, 0); RG_DEF_METHOD(geometry, 0); RG_DEF_METHOD(set_geometry_hints, 2); RG_DEF_METHOD(width, 0); RG_DEF_METHOD(height, 0); RG_DEF_METHOD(set_icon_list, 1); RG_DEF_METHOD(set_modal_hint, 1); RG_DEF_METHOD(set_type_hint, 1); RG_DEF_METHOD(type_hint, 0); RG_DEF_METHOD(set_skip_taskbar_hint, 1); RG_DEF_METHOD(set_skip_pager_hint, 1); RG_DEF_METHOD(set_urgency_hint, 1); RG_DEF_METHOD(position, 0); RG_DEF_METHOD(root_origin, 0); RG_DEF_METHOD(frame_extents, 0); RG_DEF_METHOD(origin, 0); RG_DEF_METHOD(pointer, 0); RG_DEF_METHOD(parent, 0); RG_DEF_METHOD(toplevel, 0); RG_DEF_SMETHOD(default_root_window, 0); RG_DEF_METHOD(children, 0); RG_DEF_METHOD(events, 0); RG_DEF_METHOD(set_events, 1); /* deprecated RG_DEF_METHOD(set_icon, 3); */ RG_DEF_METHOD(set_icon_name, 1); RG_DEF_METHOD(set_transient_for, 1); RG_DEF_METHOD(set_role, 1); RG_DEF_METHOD(set_group, 1); RG_DEF_METHOD(group, 0); RG_DEF_METHOD(set_decorations, 1); RG_DEF_METHOD(decorations, 0); RG_DEF_METHOD(set_functions, 1); RG_DEF_METHOD(set_composited, 1); RG_DEF_METHOD(set_opacity, 1); RG_DEF_METHOD(set_startup_id, 1); /* deprecated RG_DEF_SMETHOD(toplevels, 0); RG_DEF_SMETHOD(foreign_new, -1); RG_DEF_SMETHOD(lookup, -1); */ RG_DEF_METHOD(drag_begin, 1); RG_DEF_METHOD(drag_protocol, 0); G_DEF_CLASS(GDK_TYPE_WINDOW_TYPE, "Type", RG_TARGET_NAMESPACE); /* TODO G_DEF_CLASS(GDK_TYPE_WINDOW_CLASS, "Class", RG_TARGET_NAMESPACE); */ G_DEF_CLASS(GDK_TYPE_WINDOW_HINTS, "Hints", RG_TARGET_NAMESPACE); G_DEF_CLASS(GDK_TYPE_GRAVITY, "Gravity", RG_TARGET_NAMESPACE); G_DEF_CLASS(GDK_TYPE_WINDOW_EDGE, "Edge", RG_TARGET_NAMESPACE); G_DEF_CLASS(GDK_TYPE_WINDOW_TYPE_HINT, "TypeHint", RG_TARGET_NAMESPACE); G_DEF_CLASS(GDK_TYPE_WINDOW_ATTRIBUTES_TYPE, "AttributesType", RG_TARGET_NAMESPACE); G_DEF_CLASS(GDK_TYPE_FILTER_RETURN, "FilterReturn", RG_TARGET_NAMESPACE); G_DEF_CLASS(GDK_TYPE_MODIFIER_TYPE, "ModifierType", RG_TARGET_NAMESPACE); G_DEF_CLASS(GDK_TYPE_WM_DECORATION, "WMDecoration", RG_TARGET_NAMESPACE); G_DEF_CLASS(GDK_TYPE_WM_FUNCTION, "WMFunction", RG_TARGET_NAMESPACE); rb_define_const(RG_TARGET_NAMESPACE, "PARENT_RELATIVE", INT2FIX(GDK_PARENT_RELATIVE)); #ifdef GDK_WINDOWING_X11 G_DEF_CLASS3("GdkWindowImplX11", "WindowImplX11", mGdk); #elif defined(GDK_WINDOWING_WIN32) G_DEF_CLASS3("GdkWindowImplWin32", "WindowImplWin32", mGdk); #elif defined(GDK_WINDOWING_FB) G_DEF_CLASS3("GdkWindowFB", "WindowFB", mGdk); #endif }