bool read_document(PhraseLargeTable3 * phrase_table, FacadePhraseIndex * phrase_index, FILE * document, HashofDocument hash_of_document, HashofUnigram hash_of_unigram){ char * linebuf = NULL;size_t size = 0; phrase_token_t last_token, cur_token = last_token = 0; while ( getline(&linebuf, &size, document) ){ if ( feof(document) ) break; if ( '\n' == linebuf[strlen(linebuf) - 1] ) { linebuf[strlen(linebuf) - 1] = '\0'; } TAGLIB_PARSE_SEGMENTED_LINE(phrase_index, token, linebuf); last_token = cur_token; cur_token = token; /* skip null_token in second word. */ if ( null_token == cur_token ) continue; gpointer value = NULL; gboolean lookup_result = g_hash_table_lookup_extended (hash_of_unigram, GUINT_TO_POINTER(cur_token), NULL, &value); if ( !lookup_result ){ g_hash_table_insert(hash_of_unigram, GUINT_TO_POINTER(cur_token), GUINT_TO_POINTER(1)); } else { guint32 freq = GPOINTER_TO_UINT(value); freq ++; g_hash_table_insert(hash_of_unigram, GUINT_TO_POINTER(cur_token), GUINT_TO_POINTER(freq)); } /* skip pi-gram training. */ if ( null_token == last_token ){ if ( !g_train_pi_gram ) continue; last_token = sentence_start; } /* remember the (last_token, cur_token) word pair. */ HashofSecondWord hash_of_second_word = NULL; lookup_result = g_hash_table_lookup_extended (hash_of_document, GUINT_TO_POINTER(last_token), NULL, &value); if ( !lookup_result ){ hash_of_second_word = g_hash_table_new (g_direct_hash, g_direct_equal); } else { hash_of_second_word = (HashofSecondWord) value; } value = NULL; lookup_result = g_hash_table_lookup_extended (hash_of_second_word, GUINT_TO_POINTER(cur_token), NULL, &value); guint32 count = 0; if ( lookup_result ) { count = GPOINTER_TO_UINT(value); } count ++; g_hash_table_insert(hash_of_second_word, GUINT_TO_POINTER(cur_token), GUINT_TO_POINTER(count)); g_hash_table_insert(hash_of_document, GUINT_TO_POINTER(last_token), hash_of_second_word); } free(linebuf); return true; }
static void gstbt_wave_tab_syn_class_init (GstBtWaveTabSynClass * klass) { GObjectClass *gobject_class = (GObjectClass *) klass; GstElementClass *element_class = (GstElementClass *) klass; GstBtAudioSynthClass *audio_synth_class = (GstBtAudioSynthClass *) klass; GParamSpec *pspec; audio_synth_class->process = gstbt_wave_tab_syn_process; audio_synth_class->setup = gstbt_wave_tab_syn_setup; gobject_class->set_property = gstbt_wave_tab_syn_set_property; gobject_class->get_property = gstbt_wave_tab_syn_get_property; gobject_class->dispose = gstbt_wave_tab_syn_dispose; // describe us gst_element_class_set_static_metadata (element_class, "WaveTabSyn", "Source/Audio", "Wavetable synthesizer", "Stefan Sauer <*****@*****.**>"); gst_element_class_add_metadata (element_class, GST_ELEMENT_METADATA_DOC_URI, "file://" DATADIR "" G_DIR_SEPARATOR_S "gtk-doc" G_DIR_SEPARATOR_S "html" G_DIR_SEPARATOR_S "" PACKAGE "" G_DIR_SEPARATOR_S "GstBtWaveTabSyn.html"); // register own properties g_object_class_install_property (gobject_class, PROP_WAVE_CALLBACKS, g_param_spec_pointer ("wave-callbacks", "Wavetable Callbacks", "The wave-table access callbacks", G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_TUNING, g_param_spec_enum ("tuning", "Tuning", "Harmonic tuning", GSTBT_TYPE_TONE_CONVERSION_TUNING, GSTBT_TONE_CONVERSION_EQUAL_TEMPERAMENT, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_NOTE, g_param_spec_enum ("note", "Musical note", "Musical note (e.g. 'c-3', 'd#4')", GSTBT_TYPE_NOTE, GSTBT_NOTE_NONE, G_PARAM_WRITABLE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_NOTE_LENGTH, g_param_spec_uint ("length", "Note length", "Note length in ticks", 1, 255, 1, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS)); pspec = g_param_spec_uint ("wave", "Wave", "Wave index", 1, 200, 1, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS); g_param_spec_set_qdata (pspec, gstbt_property_meta_quark, GUINT_TO_POINTER (1)); g_param_spec_set_qdata (pspec, gstbt_property_meta_quark_flags, GUINT_TO_POINTER (GSTBT_PROPERTY_META_WAVE)); g_object_class_install_property (gobject_class, PROP_WAVE, pspec); g_object_class_install_property (gobject_class, PROP_OFFSET, g_param_spec_uint ("offset", "Offset", "Wave table offset", 0, 0xFFFF, 0, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_ATTACK, g_param_spec_double ("attack", "Attack", "Volume attack of the tone in seconds", 0.001, 4.0, 0.1, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_PEAK_VOLUME, g_param_spec_double ("peak-volume", "Peak Volume", "Peak volume of tone", 0.0, 1.0, 0.8, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_DECAY, g_param_spec_double ("decay", "Decay", "Volume decay of the tone in seconds", 0.001, 4.0, 0.5, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_SUSTAIN_VOLUME, g_param_spec_double ("sustain-volume", "Sustain Volume", "Sustain volume of tone", 0.0, 1.0, 0.4, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (gobject_class, PROP_RELEASE, g_param_spec_double ("release", "RELEASE", "Volume release of the tone in seconds", 0.001, 4.0, 0.5, G_PARAM_READWRITE | GST_PARAM_CONTROLLABLE | G_PARAM_STATIC_STRINGS)); }
void gui_init(dt_iop_module_t *self) { self->gui_data = malloc(sizeof(dt_iop_levels_gui_data_t)); dt_iop_levels_gui_data_t *c = (dt_iop_levels_gui_data_t *)self->gui_data; dt_iop_levels_params_t *p = (dt_iop_levels_params_t *)self->params; dt_pthread_mutex_init(&c->lock, NULL); dt_pthread_mutex_lock(&c->lock); c->auto_levels[0] = NAN; c->auto_levels[1] = NAN; c->auto_levels[2] = NAN; c->hash = 0; dt_pthread_mutex_unlock(&c->lock); c->modes = NULL; c->mouse_x = c->mouse_y = -1.0; c->dragging = 0; c->activeToggleButton = NULL; c->last_picked_color = -1; self->widget = GTK_WIDGET(gtk_box_new(GTK_ORIENTATION_VERTICAL, 5)); dt_gui_add_help_link(self->widget, dt_get_help_url(self->op)); c->mode = dt_bauhaus_combobox_new(self); dt_bauhaus_widget_set_label(c->mode, NULL, _("mode")); dt_bauhaus_combobox_add(c->mode, C_("mode", "manual")); c->modes = g_list_append(c->modes, GUINT_TO_POINTER(LEVELS_MODE_MANUAL)); dt_bauhaus_combobox_add(c->mode, _("automatic")); c->modes = g_list_append(c->modes, GUINT_TO_POINTER(LEVELS_MODE_AUTOMATIC)); dt_bauhaus_combobox_set_default(c->mode, LEVELS_MODE_MANUAL); dt_bauhaus_combobox_set(c->mode, g_list_index(c->modes, GUINT_TO_POINTER(p->mode))); gtk_box_pack_start(GTK_BOX(self->widget), c->mode, TRUE, TRUE, 0); c->mode_stack = gtk_stack_new(); gtk_stack_set_homogeneous(GTK_STACK(c->mode_stack),FALSE); gtk_box_pack_start(GTK_BOX(self->widget), c->mode_stack, TRUE, TRUE, 0); c->area = GTK_DRAWING_AREA(dtgtk_drawing_area_new_with_aspect_ratio(9.0 / 16.0)); GtkWidget *vbox_manual = GTK_WIDGET(gtk_box_new(GTK_ORIENTATION_VERTICAL, 5)); gtk_box_pack_start(GTK_BOX(vbox_manual), GTK_WIDGET(c->area), TRUE, TRUE, 0); gtk_widget_set_tooltip_text(GTK_WIDGET(c->area),_("drag handles to set black, gray, and white points. " "operates on L channel.")); gtk_widget_add_events(GTK_WIDGET(c->area), GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_LEAVE_NOTIFY_MASK | darktable.gui->scroll_mask); g_signal_connect(G_OBJECT(c->area), "draw", G_CALLBACK(dt_iop_levels_area_draw), self); g_signal_connect(G_OBJECT(c->area), "button-press-event", G_CALLBACK(dt_iop_levels_button_press), self); g_signal_connect(G_OBJECT(c->area), "button-release-event", G_CALLBACK(dt_iop_levels_button_release), self); g_signal_connect(G_OBJECT(c->area), "motion-notify-event", G_CALLBACK(dt_iop_levels_motion_notify), self); g_signal_connect(G_OBJECT(c->area), "leave-notify-event", G_CALLBACK(dt_iop_levels_leave_notify), self); g_signal_connect(G_OBJECT(c->area), "scroll-event", G_CALLBACK(dt_iop_levels_scroll), self); GtkWidget *autobutton = gtk_button_new_with_label(_("auto")); gtk_widget_set_tooltip_text(autobutton, _("apply auto levels")); gtk_widget_set_size_request(autobutton, -1, DT_PIXEL_APPLY_DPI(24)); c->blackpick = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT, NULL); gtk_widget_set_tooltip_text(c->blackpick, _("pick black point from image")); c->greypick = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT, NULL); gtk_widget_set_tooltip_text(c->greypick, _("pick medium gray point from image")); c->whitepick = dtgtk_togglebutton_new(dtgtk_cairo_paint_colorpicker, CPF_STYLE_FLAT, NULL); gtk_widget_set_tooltip_text(c->whitepick, _("pick white point from image")); GdkRGBA color = { 0 }; color.alpha = 1.0; dtgtk_togglebutton_override_color(DTGTK_TOGGLEBUTTON(c->blackpick), &color); color.red = color.green = color.blue = 0.5; dtgtk_togglebutton_override_color(DTGTK_TOGGLEBUTTON(c->greypick), &color); color.red = color.green = color.blue = 1.0; dtgtk_togglebutton_override_color(DTGTK_TOGGLEBUTTON(c->whitepick), &color); GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, DT_PIXEL_APPLY_DPI(10)); gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(autobutton), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(c->blackpick), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(box), GTK_WIDGET(c->greypick), TRUE, TRUE, 0); gtk_box_pack_end(GTK_BOX(box), GTK_WIDGET(c->whitepick), TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox_manual), box, TRUE, TRUE, 0); gtk_widget_show_all(vbox_manual); gtk_stack_add_named(GTK_STACK(c->mode_stack), vbox_manual, "manual"); c->percentile_black = dt_bauhaus_slider_new_with_range(self, 0.0f, 100.0f, .1f, p->percentiles[0], 3); gtk_widget_set_tooltip_text(c->percentile_black, _("black percentile")); dt_bauhaus_slider_set_format(c->percentile_black, "%.1f%%"); dt_bauhaus_widget_set_label(c->percentile_black, NULL, _("black")); c->percentile_grey = dt_bauhaus_slider_new_with_range(self, 0.0f, 100.0f, .1f, p->percentiles[1], 3); gtk_widget_set_tooltip_text(c->percentile_grey, _("gray percentile")); dt_bauhaus_slider_set_format(c->percentile_grey, "%.1f%%"); dt_bauhaus_widget_set_label(c->percentile_grey, NULL, _("gray")); c->percentile_white = dt_bauhaus_slider_new_with_range(self, 0.0f, 100.0f, .1f, p->percentiles[2], 3); gtk_widget_set_tooltip_text(c->percentile_white, _("white percentile")); dt_bauhaus_slider_set_format(c->percentile_white, "%.1f%%"); dt_bauhaus_widget_set_label(c->percentile_white, NULL, _("white")); GtkWidget *vbox_automatic = GTK_WIDGET(gtk_box_new(GTK_ORIENTATION_VERTICAL, 5)); gtk_box_pack_start(GTK_BOX(vbox_automatic), GTK_WIDGET(c->percentile_black), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_automatic), GTK_WIDGET(c->percentile_grey), FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(vbox_automatic), GTK_WIDGET(c->percentile_white), FALSE, FALSE, 0); gtk_widget_show_all(vbox_automatic); gtk_stack_add_named(GTK_STACK(c->mode_stack), vbox_automatic, "automatic"); switch(p->mode) { case LEVELS_MODE_AUTOMATIC: gtk_stack_set_visible_child_name(GTK_STACK(c->mode_stack), "automatic"); break; case LEVELS_MODE_MANUAL: default: gtk_stack_set_visible_child_name(GTK_STACK(c->mode_stack), "manual"); break; } g_signal_connect(G_OBJECT(c->mode), "value-changed", G_CALLBACK(dt_iop_levels_mode_callback), self); g_signal_connect(G_OBJECT(c->percentile_black), "value-changed", G_CALLBACK(dt_iop_levels_percentiles_callback), self); g_signal_connect(G_OBJECT(c->percentile_grey), "value-changed", G_CALLBACK(dt_iop_levels_percentiles_callback), self); g_signal_connect(G_OBJECT(c->percentile_white), "value-changed", G_CALLBACK(dt_iop_levels_percentiles_callback), self); g_signal_connect(G_OBJECT(autobutton), "clicked", G_CALLBACK(dt_iop_levels_autoadjust_callback), (gpointer)self); g_signal_connect(G_OBJECT(c->blackpick), "toggled", G_CALLBACK(dt_iop_color_picker_callback), &c->color_picker); g_signal_connect(G_OBJECT(c->greypick), "toggled", G_CALLBACK(dt_iop_color_picker_callback), &c->color_picker); g_signal_connect(G_OBJECT(c->whitepick), "toggled", G_CALLBACK(dt_iop_color_picker_callback), &c->color_picker); dt_iop_init_picker(&c->color_picker, self, DT_COLOR_PICKER_POINT, _iop_color_picker_get_set, _iop_color_picker_apply, _iop_color_picker_update); }
guint32 _wapi_accept(guint32 fd, struct sockaddr *addr, socklen_t *addrlen) { gpointer handle = GUINT_TO_POINTER (fd); gpointer new_handle; struct _WapiHandle_socket *socket_handle; struct _WapiHandle_socket new_socket_handle = {0}; gboolean ok; int new_fd; if (addr != NULL && *addrlen < sizeof(struct sockaddr)) { WSASetLastError (WSAEFAULT); return(INVALID_SOCKET); } if (_wapi_handle_type (handle) != WAPI_HANDLE_SOCKET) { WSASetLastError (WSAENOTSOCK); return(INVALID_SOCKET); } ok = _wapi_lookup_handle (handle, WAPI_HANDLE_SOCKET, (gpointer *)&socket_handle); if (ok == FALSE) { g_warning ("%s: error looking up socket handle %p", __func__, handle); WSASetLastError (WSAENOTSOCK); return(INVALID_SOCKET); } do { new_fd = accept (fd, addr, addrlen); } while (new_fd == -1 && errno == EINTR && !_wapi_thread_cur_apc_pending()); if (new_fd == -1) { gint errnum = errno; DEBUG ("%s: accept error: %s", __func__, strerror(errno)); errnum = errno_to_WSA (errnum, __func__); WSASetLastError (errnum); return(INVALID_SOCKET); } if (new_fd >= _wapi_fd_reserve) { DEBUG ("%s: File descriptor is too big", __func__); WSASetLastError (WSASYSCALLFAILURE); close (new_fd); return(INVALID_SOCKET); } new_socket_handle.domain = socket_handle->domain; new_socket_handle.type = socket_handle->type; new_socket_handle.protocol = socket_handle->protocol; new_socket_handle.still_readable = 1; new_handle = _wapi_handle_new_fd (WAPI_HANDLE_SOCKET, new_fd, &new_socket_handle); if(new_handle == _WAPI_HANDLE_INVALID) { g_warning ("%s: error creating socket handle", __func__); WSASetLastError (ERROR_GEN_FAILURE); return(INVALID_SOCKET); } DEBUG ("%s: returning newly accepted socket handle %p with", __func__, new_handle); return(new_fd); }
int _wapi_getsockopt(guint32 fd, int level, int optname, void *optval, socklen_t *optlen) { gpointer handle = GUINT_TO_POINTER (fd); int ret; struct timeval tv; void *tmp_val; struct _WapiHandle_socket *socket_handle; gboolean ok; if (_wapi_handle_type (handle) != WAPI_HANDLE_SOCKET) { WSASetLastError (WSAENOTSOCK); return(SOCKET_ERROR); } tmp_val = optval; if (level == SOL_SOCKET && (optname == SO_RCVTIMEO || optname == SO_SNDTIMEO)) { tmp_val = &tv; *optlen = sizeof (tv); } ret = getsockopt (fd, level, optname, tmp_val, optlen); if (ret == -1) { gint errnum = errno; DEBUG ("%s: getsockopt error: %s", __func__, strerror (errno)); errnum = errno_to_WSA (errnum, __func__); WSASetLastError (errnum); return(SOCKET_ERROR); } if (level == SOL_SOCKET && (optname == SO_RCVTIMEO || optname == SO_SNDTIMEO)) { *((int *) optval) = tv.tv_sec * 1000 + (tv.tv_usec / 1000); // milli from micro *optlen = sizeof (int); } if (optname == SO_ERROR) { ok = _wapi_lookup_handle (handle, WAPI_HANDLE_SOCKET, (gpointer *)&socket_handle); if (ok == FALSE) { g_warning ("%s: error looking up socket handle %p", __func__, handle); /* can't extract the last error */ *((int *) optval) = errno_to_WSA (*((int *)optval), __func__); } else { if (*((int *)optval) != 0) { *((int *) optval) = errno_to_WSA (*((int *)optval), __func__); socket_handle->saved_error = *((int *)optval); } else { *((int *)optval) = socket_handle->saved_error; } } } return(ret); }
/* dok_tree_root_get_decl_by_id: */ DokTree *dok_tree_root_get_decl_by_id ( DokTree *tree, DokTreeID id ) { return g_hash_table_lookup(DOK_TREE_ROOT(tree)->decls_by_id, GUINT_TO_POINTER(id)); }
int WSAIoctl (guint32 fd, gint32 command, gchar *input, gint i_len, gchar *output, gint o_len, glong *written, void *unused1, void *unused2) { gpointer handle = GUINT_TO_POINTER (fd); int ret; gchar *buffer = NULL; if (_wapi_handle_type (handle) != WAPI_HANDLE_SOCKET) { WSASetLastError (WSAENOTSOCK); return SOCKET_ERROR; } if (command == SIO_GET_EXTENSION_FUNCTION_POINTER) { int i = 0; WapiGuid *guid = (WapiGuid *)input; if (i_len < sizeof(WapiGuid)) { /* As far as I can tell, windows doesn't * actually set an error here... */ WSASetLastError (WSAEINVAL); return(SOCKET_ERROR); } if (o_len < sizeof(gpointer)) { /* Or here... */ WSASetLastError (WSAEINVAL); return(SOCKET_ERROR); } if (output == NULL) { /* Or here */ WSASetLastError (WSAEINVAL); return(SOCKET_ERROR); } while(extension_functions[i].func != NULL) { if (!memcmp (guid, &extension_functions[i].guid, sizeof(WapiGuid))) { memcpy (output, &extension_functions[i].func, sizeof(gpointer)); *written = sizeof(gpointer); return(0); } i++; } WSASetLastError (WSAEINVAL); return(SOCKET_ERROR); } if (command == SIO_KEEPALIVE_VALS) { uint32_t onoff; uint32_t keepalivetime; uint32_t keepaliveinterval; if (i_len < (3 * sizeof (uint32_t))) { WSASetLastError (WSAEINVAL); return SOCKET_ERROR; } memcpy (&onoff, input, sizeof (uint32_t)); memcpy (&keepalivetime, input + sizeof (uint32_t), sizeof (uint32_t)); memcpy (&keepaliveinterval, input + 2 * sizeof (uint32_t), sizeof (uint32_t)); ret = setsockopt (fd, SOL_SOCKET, SO_KEEPALIVE, &onoff, sizeof (uint32_t)); if (ret < 0) { gint errnum = errno; errnum = errno_to_WSA (errnum, __func__); WSASetLastError (errnum); return SOCKET_ERROR; } if (onoff != 0) { #if defined(TCP_KEEPIDLE) && defined(TCP_KEEPINTVL) /* Values are in ms, but we need s */ uint32_t rem; /* keepalivetime and keepaliveinterval are > 0 (checked in managed code) */ rem = keepalivetime % 1000; keepalivetime /= 1000; if (keepalivetime == 0 || rem >= 500) keepalivetime++; ret = setsockopt (fd, IPPROTO_TCP, TCP_KEEPIDLE, &keepalivetime, sizeof (uint32_t)); if (ret == 0) { rem = keepaliveinterval % 1000; keepaliveinterval /= 1000; if (keepaliveinterval == 0 || rem >= 500) keepaliveinterval++; ret = setsockopt (fd, IPPROTO_TCP, TCP_KEEPINTVL, &keepaliveinterval, sizeof (uint32_t)); } if (ret != 0) { gint errnum = errno; errnum = errno_to_WSA (errnum, __func__); WSASetLastError (errnum); return SOCKET_ERROR; } return 0; #endif } return 0; } if (i_len > 0) { buffer = g_memdup (input, i_len); } ret = ioctl (fd, command, buffer); if (ret == -1) { gint errnum = errno; DEBUG("%s: WSAIoctl error: %s", __func__, strerror (errno)); errnum = errno_to_WSA (errnum, __func__); WSASetLastError (errnum); g_free (buffer); return(SOCKET_ERROR); } if (buffer == NULL) { *written = 0; } else { /* We just copy the buffer to the output. Some ioctls * don't even output any data, but, well... * * NB windows returns WSAEFAULT if o_len is too small */ i_len = (i_len > o_len) ? o_len : i_len; if (i_len > 0 && output != NULL) { memcpy (output, buffer, i_len); } g_free (buffer); *written = i_len; } return(0); }
struct mwChannel *mwChannel_find(struct mwChannelSet *cs, guint32 chan) { g_return_val_if_fail(cs != NULL, NULL); g_return_val_if_fail(cs->map != NULL, NULL); return g_hash_table_lookup(cs->map, GUINT_TO_POINTER(chan)); }
crm_node_t * crm_get_peer(unsigned int id, const char *uname) { crm_node_t *node = NULL; CRM_ASSERT(id > 0 || uname != NULL); crm_peer_init(); if (uname != NULL) { node = g_hash_table_lookup(crm_peer_cache, uname); } if (node == NULL && id > 0) { node = g_hash_table_lookup(crm_peer_id_cache, GUINT_TO_POINTER(id)); if (node && node->uname && uname) { crm_crit("Node %s and %s share the same cluster node id '%u'!", node->uname, uname, id); /* NOTE: Calling crm_new_peer() means the entry in * crm_peer_id_cache will point to the new entity */ /* TODO: Replace the old uname instead? */ node = crm_new_peer(id, uname); CRM_ASSERT(node->uname != NULL); } } if (node == NULL) { node = crm_new_peer(id, uname); if(uname) { const char *uuid = get_uuid(uname); crm_update_peer(__FUNCTION__, 0, 0, 0, -1, 0, uuid, uname, NULL, NULL); } } CRM_ASSERT(node); if (node && uname && node->uname == NULL) { node->uname = crm_strdup(uname); crm_info("Node %u is now known as %s", id, uname); g_hash_table_insert(crm_peer_cache, node->uname, node); if (crm_status_callback) { crm_status_callback(crm_status_uname, node, NULL); } } if (node && node->uname && node->uuid == NULL) { const char *uuid = get_node_uuid(id, node->uname); if (node->uuid) { crm_info("Node %u has uuid %s", id, node->uuid); } else if (uuid) { node->uuid = crm_strdup(uuid); } } if (node && id > 0 && id != node->id) { g_hash_table_remove(crm_peer_id_cache, GUINT_TO_POINTER(node->id)); g_hash_table_insert(crm_peer_id_cache, GUINT_TO_POINTER(id), node); node->id = id; crm_info("Node %s now has id: %u", crm_str(uname), id); } return node; }
menu_info_item_t* menu_info_item_get(menu_info_t* mi, uint32_t index) { return g_hash_table_lookup(mi->items, GUINT_TO_POINTER(index)); }
static struct mwCipherInstance * get_supported(struct mwChannel *chan, guint16 id) { guint32 cid = (guint32) id; return g_hash_table_lookup(chan->supported, GUINT_TO_POINTER(cid)); }
void menu_info_item_add(menu_info_t* mi, uint32_t index, const char* name, const char* desc, const pa_cvolume* vol, int mute, char* tooltip, const char* icon, const char* address) { menu_infos_t* mis = mi->menu_infos; menu_info_item_t* item = g_new(menu_info_item_t, 1); menu_info_item_init(item); item->menu_info = mi; #ifdef DEBUG g_message("[menu_info] adding %s %u %p", menu_info_type_name(mi->type), index, item); #endif item->index = index; item->name = g_strdup(name); item->desc = g_strdup(desc); item->volume = g_memdup(vol, sizeof(pa_cvolume)); item->mute = mute; item->icon = g_strdup(icon); item->address = g_strdup(address); switch(item->menu_info->type) { case MENU_INPUT: item->submenu = menu_info_create(mis, MENU_SINK); item->submenu->parent = item; break; case MENU_OUTPUT: item->submenu = menu_info_create(mis, MENU_SOURCE); item->submenu->parent = item; break; default: break; } switch(mi->type) { case MENU_SERVER: item->widget = systray_add_radio_item(mi, desc, tooltip); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item->widget), (item->address == mi->default_name) || (item->address && mi->default_name && g_str_equal(mi->default_name, item->address))); break; case MENU_SINK: item->context = menu_info_item_context_menu(item); item->widget = systray_add_radio_item(mi, desc, tooltip); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item->widget), g_str_equal(mi->default_name, item->name)); systray_add_item_to_all_submenus(item, &mis->menu_info[MENU_INPUT]); break; case MENU_SOURCE: item->context = menu_info_item_context_menu(item); item->widget = systray_add_radio_item(mi, desc, tooltip); gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item->widget), g_str_equal(mi->default_name, item->name)); systray_add_item_to_all_submenus(item, &mis->menu_info[MENU_OUTPUT]); break; case MENU_INPUT: item->widget = systray_menu_add_submenu(mi->menu, item->submenu, desc, tooltip, icon); systray_add_all_items_to_submenu(&mis->menu_info[MENU_SINK], item); break; case MENU_OUTPUT: item->widget = systray_menu_add_submenu(mi->menu, item->submenu, desc, tooltip, icon); systray_add_all_items_to_submenu(&mis->menu_info[MENU_SOURCE], item); break; } g_signal_connect(item->widget, "button-press-event", G_CALLBACK(menu_info_item_clicked), item); gtk_widget_add_events(item->widget, GDK_SCROLL_MASK); g_signal_connect(item->widget, "scroll-event", G_CALLBACK(menu_info_item_scrolled), item); if(mi->type == MENU_SERVER) g_hash_table_insert(mi->items, item->name, item); else g_hash_table_insert(mi->items, GUINT_TO_POINTER(index), item); /* if this is the default sink, update status icon acording to volume */ if(mi->type == MENU_SINK && item == menu_info_item_get_by_name(mi, mi->default_name)) ui_update_statusicon(item); }
void menu_info_item_update(menu_info_t* mi, uint32_t index, const char* name, const char* desc, const pa_cvolume* vol, int mute, char* tooltip, const char* icon, const char* address) { menu_info_item_t* mii; if(mi->type == MENU_SERVER) mii = menu_info_item_get_by_name(mi, name); else mii = menu_info_item_get(mi, index); if(mii == NULL) return menu_info_item_add(mi, index, name, desc, vol, mute, tooltip, icon, address); #ifdef DEBUG g_message("[menu_info] updating %s %u %s", menu_info_type_name(mii->menu_info->type), index, desc); #endif g_free(mii->name); mii->name = g_strdup(name); g_free(mii->desc); mii->desc = g_strdup(desc); g_free(mii->volume); mii->volume = g_memdup(vol, sizeof(pa_cvolume)); mii->mute = mute; g_free(mii->address); mii->address = g_strdup(address); switch(mi->type) { case MENU_SERVER: case MENU_SINK: case MENU_SOURCE: gtk_menu_item_set_label(GTK_MENU_ITEM(mii->widget), desc); systray_set_tooltip(GTK_WIDGET(mii->widget), tooltip); // submenu to update (if any) menu_info_t* submenu = NULL; switch(mi->type) { case MENU_SINK: submenu = &mi->menu_infos->menu_info[MENU_INPUT]; break; case MENU_SOURCE: submenu = &mi->menu_infos->menu_info[MENU_OUTPUT]; break; default: break; } // change labels in stream submenus if(submenu) { GHashTableIter iter; gpointer key; menu_info_item_t* item; menu_info_item_t* subitem; g_hash_table_iter_init(&iter, submenu->items); while(g_hash_table_iter_next(&iter, &key, (gpointer*)&item)) if((subitem = g_hash_table_lookup(item->submenu->items, GUINT_TO_POINTER(mii->index)))) if(!g_str_equal(subitem->desc, desc)) gtk_menu_item_set_label( GTK_MENU_ITEM(subitem->widget), desc); } break; case MENU_INPUT: case MENU_OUTPUT: gtk_menu_item_set_label(GTK_MENU_ITEM(mii->widget), desc); systray_set_tooltip(GTK_WIDGET(mii->widget), tooltip); break; } /* if this is the default sink, update status icon acording to volume */ if(mi->type == MENU_SINK && mii == menu_info_item_get_by_name(mi, mi->default_name)) ui_update_statusicon(mii); }
gpointer mono_arm_start_gsharedvt_call (GSharedVtCallInfo *info, gpointer *caller, gpointer *callee, gpointer mrgctx_reg, double *caller_fregs, double *callee_fregs) { int i; /* * The caller/callee regs are mapped to slot 0..3, stack slot 0 is mapped to slot 4, etc. */ /* Set vtype ret arg */ if (info->vret_slot != -1) { callee [info->vret_arg_reg] = &callee [info->vret_slot]; } for (i = 0; i < info->map_count; ++i) { int src = info->map [i * 2]; int dst = info->map [(i * 2) + 1]; int arg_marshal = (src >> 24) & 0xff; switch (arg_marshal) { case GSHAREDVT_ARG_NONE: callee [dst] = caller [src]; break; case GSHAREDVT_ARG_BYVAL_TO_BYREF: /* gsharedvt argument passed by addr in reg/stack slot */ src = src & 0xffff; callee [dst] = caller + src; break; case GSHAREDVT_ARG_BYREF_TO_BYVAL: { /* gsharedvt argument passed by value */ int nslots = (src >> 8) & 0xff; int src_slot = src & 0xff; int j; gpointer *addr = (gpointer*)caller [src_slot]; for (j = 0; j < nslots; ++j) callee [dst + j] = addr [j]; break; } case GSHAREDVT_ARG_BYREF_TO_BYVAL_I1: { int src_slot = src & 0xff; gpointer *addr = (gpointer*)caller [src_slot]; callee [dst] = GINT_TO_POINTER ((int)*(gint8*)addr); break; } case GSHAREDVT_ARG_BYREF_TO_BYVAL_I2: { int src_slot = src & 0xff; gpointer *addr = (gpointer*)caller [src_slot]; callee [dst] = GINT_TO_POINTER ((int)*(gint16*)addr); break; } case GSHAREDVT_ARG_BYREF_TO_BYVAL_U1: { int src_slot = src & 0xff; gpointer *addr = (gpointer*)caller [src_slot]; callee [dst] = GUINT_TO_POINTER ((guint)*(guint8*)addr); break; } case GSHAREDVT_ARG_BYREF_TO_BYVAL_U2: { int src_slot = src & 0xff; gpointer *addr = (gpointer*)caller [src_slot]; callee [dst] = GUINT_TO_POINTER ((guint)*(guint16*)addr); break; } default: g_assert_not_reached (); break; } } /* The slot based approach above is very complicated, use a nested switch instead for fp regs */ // FIXME: Use this for the other cases as well if (info->have_fregs) { CallInfo *caller_cinfo = info->caller_cinfo; CallInfo *callee_cinfo = info->callee_cinfo; int aindex; for (aindex = 0; aindex < caller_cinfo->nargs; ++aindex) { ArgInfo *ainfo = &caller_cinfo->args [aindex]; ArgInfo *ainfo2 = &callee_cinfo->args [aindex]; switch (ainfo->storage) { case RegTypeFP: { switch (ainfo2->storage) { case RegTypeFP: callee_fregs [ainfo2->reg / 2] = caller_fregs [ainfo->reg / 2]; break; case RegTypeGSharedVtInReg: callee [ainfo2->reg] = &caller_fregs [ainfo->reg / 2]; break; case RegTypeGSharedVtOnStack: { int sslot = ainfo2->offset / 4; callee [sslot + 4] = &caller_fregs [ainfo->reg / 2]; break; } default: g_assert_not_reached (); break; } break; } case RegTypeGSharedVtInReg: { switch (ainfo2->storage) { case RegTypeFP: { callee_fregs [ainfo2->reg / 2] = *(double*)caller [ainfo->reg]; break; } default: break; } break; } case RegTypeGSharedVtOnStack: { switch (ainfo2->storage) { case RegTypeFP: { int sslot = ainfo->offset / 4; callee_fregs [ainfo2->reg / 2] = *(double*)caller [sslot + 4]; break; } default: break; } break; } default: break; } } } if (info->vcall_offset != -1) { MonoObject *this_obj = (MonoObject*)caller [0]; if (G_UNLIKELY (!this_obj)) return NULL; if (info->vcall_offset == MONO_GSHAREDVT_DEL_INVOKE_VT_OFFSET) /* delegate invoke */ return ((MonoDelegate*)this_obj)->invoke_impl; else return *(gpointer*)((char*)this_obj->vtable + info->vcall_offset); } else if (info->calli) { /* The address to call is passed in the mrgctx reg */ return mrgctx_reg; } else { return info->addr; } }
static void __get_pairs_by_component(GQueue *out, GTree *t, unsigned int component) { g_tree_find_all(out, t, __component_find, GUINT_TO_POINTER(component)); }
void nm_connection_editor_inter_page_set_value (NMConnectionEditor *editor, InterPageChangeType type, gpointer value) { g_hash_table_insert (editor->inter_page_hash, GUINT_TO_POINTER (type), value); }
static GnmValue * callback_function_collect (GnmEvalPos const *ep, GnmValue const *value, void *closure) { gnm_float x = 0; collect_floats_t *cl = closure; gboolean ignore = FALSE; switch (value ? value->v_any.type : VALUE_EMPTY) { case VALUE_EMPTY: if (cl->flags & COLLECT_IGNORE_BLANKS) ignore = TRUE; else if (cl->flags & COLLECT_ZERO_BLANKS) x = 0; else return value_new_error_VALUE (ep); break; case VALUE_BOOLEAN: if (cl->flags & COLLECT_IGNORE_BOOLS) ignore = TRUE; else if (cl->flags & COLLECT_ZEROONE_BOOLS) x = value_get_as_float (value); else return value_new_error_VALUE (ep); break; case VALUE_CELLRANGE : case VALUE_ARRAY : /* Ranges and arrays are not singleton values treat as errors */ case VALUE_ERROR: if (cl->flags & COLLECT_IGNORE_ERRORS) ignore = TRUE; else if (cl->flags & COLLECT_ZERO_ERRORS) x = 0; else return value_new_error_VALUE (ep); break; case VALUE_FLOAT: x = value_get_as_float (value); break; case VALUE_STRING: if (cl->flags & COLLECT_COERCE_STRINGS) { GnmValue *vc = format_match_number (value_peek_string (value), NULL, cl->date_conv); gboolean bad = !vc || VALUE_IS_BOOLEAN (vc); if (vc) { x = value_get_as_float (vc); value_release (vc); } else x = 0; if (bad) return value_new_error_VALUE (ep); } else if (cl->flags & COLLECT_IGNORE_STRINGS) ignore = TRUE; else if (cl->flags & COLLECT_ZERO_STRINGS) x = 0; else return value_new_error_VALUE (ep); break; default: g_warning ("Trouble in callback_function_collect. (%d)", value->v_any.type); ignore = TRUE; } if (ignore) { if (cl->flags & COLLECT_INFO) cl->info = g_slist_prepend (cl->info, GUINT_TO_POINTER (cl->count)); else { return NULL; } } if (cl->count == cl->alloc_count) { cl->alloc_count = cl->alloc_count * 2 + 20; cl->data = g_renew (gnm_float, cl->data, cl->alloc_count); } cl->data[cl->count++] = x; return NULL; }
gboolean nm_connection_editor_inter_page_get_value (NMConnectionEditor *editor, InterPageChangeType type, gpointer *value) { return g_hash_table_lookup_extended (editor->inter_page_hash, GUINT_TO_POINTER (type), NULL, value); }
static void preferences_add_id (EmpathyPreferences *preferences, guint id) { preferences->notify_ids = g_list_prepend (preferences->notify_ids, GUINT_TO_POINTER (id)); }
static void preferences_add_id (PreferencesDialog *prefs, guint id){ prefs->notify_ids = g_list_prepend (prefs->notify_ids, GUINT_TO_POINTER (id)); }
int ioctlsocket(guint32 fd, unsigned long command, gpointer arg) { gpointer handle = GUINT_TO_POINTER (fd); int ret; if (_wapi_handle_type (handle) != WAPI_HANDLE_SOCKET) { WSASetLastError (WSAENOTSOCK); return(SOCKET_ERROR); } switch(command){ case FIONBIO: #ifdef O_NONBLOCK /* This works better than ioctl(...FIONBIO...) * on Linux (it causes connect to return * EINPROGRESS, but the ioctl doesn't seem to) */ ret = fcntl(fd, F_GETFL, 0); if (ret != -1) { if (*(gboolean *)arg) { ret |= O_NONBLOCK; } else { ret &= ~O_NONBLOCK; } ret = fcntl(fd, F_SETFL, ret); } break; #endif /* O_NONBLOCK */ /* Unused in Mono */ case SIOCATMARK: ret = ioctl (fd, command, arg); break; case FIONREAD: { #if defined (PLATFORM_MACOSX) // ioctl (fd, FIONREAD, XXX) returns the size of // the UDP header as well on // Darwin. // // Use getsockopt SO_NREAD instead to get the // right values for TCP and UDP. // // ai_canonname can be null in some cases on darwin, where the runtime assumes it will // be the value of the ip buffer. socklen_t optlen = sizeof (int); ret = getsockopt (fd, SOL_SOCKET, SO_NREAD, arg, &optlen); #else ret = ioctl (fd, command, arg); #endif break; } default: WSASetLastError (WSAEINVAL); return(SOCKET_ERROR); } if (ret == -1) { gint errnum = errno; DEBUG ("%s: ioctl error: %s", __func__, strerror (errno)); errnum = errno_to_WSA (errnum, __func__); WSASetLastError (errnum); return(SOCKET_ERROR); } return(0); }
int main (int argc, char **argv) { BonoboWindow *win; BonoboUIComponent *componenta; BonoboUIComponent *componentb; BonoboUIComponent *componentc; BonoboUIContainer *container; Bonobo_UIContainer corba_container; CORBA_Environment real_ev, *ev; GnomeProgram *program; char *txt, *fname; int i; char simplea [] = "<menu>\n" " <submenu name=\"File\" _label=\"_Ga'\">\n" " <menuitem name=\"open\" pos=\"bottom\" _label=\"_Open\" verb=\"FileOpen\" pixtype=\"stock\" pixname=\"Open\" _tip=\"Wibble\"/>\n" " <control name=\"MyControl\"/>\n" " <control name=\"MyControl2\"/>\n" " <control name=\"ThisIsEmpty\"/>\n" " <menuitem name=\"close\" noplace=\"1\" verb=\"FileExit\" _label=\"_CloseA\" _tip=\"hi\"" " pixtype=\"stock\" pixname=\"Close\" accel=\"*Control*q\"/>\n" " </submenu>\n" "</menu>"; char keysa [] = "<keybindings>\n" " <accel name=\"*Control*3\" id=\"MyFoo\"/>\n" "</keybindings>\n"; char simpleb [] = "<submenu name=\"File\" _label=\"_File\">\n" " <menuitem name=\"open\" _label=\"_OpenB\" pixtype=\"stock\" pixname=\"Open\" _tip=\"Open you fool\"/>\n" " <separator/>\n" " <menuitem name=\"toggle\" type=\"toggle\" id=\"MyFoo\" _label=\"_ToggleMe\" _tip=\"a\" accel=\"*Control*t\"/>\n" " <placeholder name=\"Nice\" delimit=\"top\"/>\n" " <menuitem name=\"close\" noplace=\"1\" verb=\"FileExit\" _label=\"_CloseB\" _tip=\"hi\"" " pixtype=\"stock\" pixname=\"Close\" accel=\"*Control*q\"/>\n" "</submenu>\n"; char simplec [] = "<submenu name=\"File\" _label=\"_FileC\" _tip=\"what!\">\n" " <placeholder name=\"Nice\" delimit=\"top\" hidden=\"0\">\n" " <menuitem name=\"fooa\" _label=\"_FooA\" type=\"radio\" group=\"foogroup\" _tip=\"Radio1\"/>\n" " <menuitem name=\"foob\" _label=\"_FooB\" type=\"radio\" group=\"foogroup\" _tip=\"kippers\"/>\n" " <menuitem name=\"wibble\" verb=\"ThisForcesAnError\" _label=\"_Baa\"" " pixtype=\"stock\" pixname=\"Open\" sensitive=\"0\" _tip=\"fish\"/>\n" " <separator/>\n" " </placeholder>\n" "</submenu>\n"; char simpled [] = "<menuitem name=\"save\" _label=\"_SaveD\" pixtype=\"stock\" pixname=\"Save\" _tip=\"tip1\"/>\n"; char simplee [] = "<menuitem name=\"fish\" _label=\"_Inplace\" pixtype=\"stock\" pixname=\"Save\" _tip=\"tip2\"/>\n"; char toola [] = "<dockitem name=\"Toolbar\" homogeneous=\"0\" vlook=\"icon\">\n" " <toolitem type=\"toggle\" name=\"foo2\" id=\"MyFoo\" pixtype=\"stock\" pixname=\"Save\"" " _label=\"TogSave\" _tip=\"My tooltip\" priority=\"1\"/>\n" " <separator/>\n" " <toolitem name=\"baa\" pixtype=\"stock\" pixname=\"Open\" _label=\"baa\" _tip=\"My 2nd tooltip\" verb=\"testme\"/>\n" " <control name=\"AControl\" _tip=\"a tip on a control\" hidden=\"0\" vdisplay=\"button\"\n" " pixtype=\"stock\" pixname=\"gtk-italic\" _label=\"EntryControl\" verb=\"OpenEntry\"/>\n" " <control name=\"BControl\" _tip=\"another tip on a control\" hidden=\"0\"\n" " pixtype=\"stock\" pixname=\"gtk-stop\"/>\n" "</dockitem>"; char toolb [] = "<dockitem name=\"Toolbar\" look=\"icon\" relief=\"none\">\n" " <toolitem name=\"foo1\" _label=\"Insensitive\" sensitive=\"0\" hidden=\"0\" priority=\"1\"/>\n" " <toolitem type=\"toggle\" name=\"foo5\" id=\"MyFoo\" pixtype=\"stock\" pixname=\"Close\"" " _label=\"TogSame\" _tip=\"My tooltip\"/>\n" "</dockitem>"; /* char statusa [] = "<item name=\"main\">Kippers</item>\n";*/ char statusb [] = "<status>\n" " <item name=\"main\"/>\n" " <control name=\"Progress\"/>\n" "</status>"; ev = &real_ev; CORBA_exception_init (ev); free (malloc (8)); program = gnome_program_init ("test-ui", VERSION, LIBBONOBOUI_MODULE, argc, argv, NULL); textdomain (GETTEXT_PACKAGE); bonobo_activate (); dump_prefs (); win = BONOBO_WINDOW (bonobo_window_new ("Win", "My Test Application")); container = bonobo_window_get_ui_container (win); bonobo_ui_engine_config_set_path (bonobo_window_get_ui_engine (win), "/test-ui/UIConfig/kvps"); corba_container = BONOBO_OBJREF (container); { GtkWidget *box = gtk_vbox_new (FALSE, 0); GtkWidget *button; GtkWidget *path_entry, *state_entry; button = gtk_button_new_with_label ("Press me to test!"); g_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) cb_do_quit, NULL); gtk_widget_show (GTK_WIDGET (button)); gtk_box_pack_start_defaults (GTK_BOX (box), button); button = gtk_button_new_with_label ("Dump Xml tree"); g_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) cb_do_dump, win); gtk_widget_show (GTK_WIDGET (button)); gtk_box_pack_start_defaults (GTK_BOX (box), button); button = gtk_button_new_with_label ("Popup"); g_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) cb_do_popup, win); gtk_widget_show (GTK_WIDGET (button)); gtk_box_pack_start_defaults (GTK_BOX (box), button); button = gtk_button_new_with_label ("Hide toolbar"); g_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) cb_do_hide_toolbar, win); gtk_widget_show (GTK_WIDGET (button)); gtk_box_pack_start_defaults (GTK_BOX (box), button); path_entry = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (path_entry), "/commands/MyFoo"); gtk_widget_show (GTK_WIDGET (path_entry)); gtk_box_pack_start_defaults (GTK_BOX (box), path_entry); state_entry = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (state_entry), "1"); g_signal_connect (GTK_OBJECT (state_entry), "changed", (GtkSignalFunc) cb_set_state, path_entry); gtk_widget_show (GTK_WIDGET (state_entry)); gtk_box_pack_start_defaults (GTK_BOX (box), state_entry); gtk_widget_show (GTK_WIDGET (box)); bonobo_window_set_contents (win, box); } g_signal_connect (GTK_OBJECT (win), "size_request", G_CALLBACK (slow_size_request), NULL); componenta = bonobo_ui_component_new ("A"); bonobo_object_unref (BONOBO_OBJECT (componenta)); componenta = bonobo_ui_component_new ("A"); componentb = bonobo_ui_component_new ("B"); componentc = bonobo_ui_component_new ("C"); bonobo_ui_component_set_container (componenta, corba_container, NULL); bonobo_ui_component_set_container (componentb, corba_container, NULL); bonobo_ui_component_set_container (componentc, corba_container, NULL); global_component = componenta; fname = bonobo_ui_util_get_ui_fname (NULL, "../doc/std-ui.xml"); if (fname && g_file_test (fname, G_FILE_TEST_EXISTS)) { fprintf (stderr, "\n\n--- Add std-ui.xml ---\n\n\n"); bonobo_ui_util_set_ui (componenta, NULL, "../doc/std-ui.xml", "gdm", NULL); /* bonobo_ui_component_set_prop ( componenta, "/menu/Preferences", "pixname", "/demo/a.xpm", NULL);*/ gtk_widget_show (GTK_WIDGET (win)); bonobo_main (); } else { g_warning ("Can't find ../doc/std-ui.xml"); gtk_widget_show (GTK_WIDGET (win)); } g_free (fname); bonobo_ui_component_freeze (componenta, NULL); fprintf (stderr, "\n\n--- Remove A ---\n\n\n"); bonobo_ui_component_rm (componenta, "/", ev); g_assert (!BONOBO_EX (ev)); /* bonobo_ui_component_set_translate (componentb, "/status", statusa, ev); g_assert (!BONOBO_EX (ev));*/ bonobo_ui_component_set_translate (componenta, "/", simplea, ev); g_assert (!BONOBO_EX (ev)); bonobo_ui_component_set_translate (componentb, "/", "<popups> <popup name=\"MyStuff\"/> </popups>", ev); g_assert (!BONOBO_EX (ev)); bonobo_ui_component_set_translate (componenta, "/popups/MyStuff", simpleb, ev); g_assert (!BONOBO_EX (ev)); bonobo_ui_component_set_translate (componenta, "/", keysa, ev); g_assert (!BONOBO_EX (ev)); bonobo_ui_component_set_translate (componentb, "/", toola, ev); g_assert (!BONOBO_EX (ev)); { GtkWidget *widget = gtk_button_new_with_label ("My Label"); BonoboControl *control = bonobo_control_new (widget); BonoboUIComponent *componentp; g_signal_connect (GTK_OBJECT (widget), "button_press_event", G_CALLBACK (do_sane_popup), control); componentp = bonobo_control_get_popup_ui_component (control); #if 1 bonobo_ui_component_set (componentp, "/", "<popups>" "<popup name=\"button3\"/></popups>", ev); g_assert (!BONOBO_EX (ev)); bonobo_ui_component_set_translate ( componentp, "/popups/button3", simpleb, ev); g_assert (!BONOBO_EX (ev)); #endif gtk_widget_show (widget); bonobo_ui_component_object_set (componenta, "/menu/File/MyControl", BONOBO_OBJREF (control), ev); bonobo_object_unref (BONOBO_OBJECT (control)); g_assert (!BONOBO_EX (ev)); widget = gtk_menu_item_new_with_mnemonic ("_Foo item"); gtk_widget_show (widget); bonobo_ui_component_widget_set (componenta, "/menu/File/MyControl2", widget, ev); } { GtkWidget *widget = gtk_entry_new (); gtk_entry_set_text (GTK_ENTRY (widget), "Example text"); gtk_widget_show (widget); bonobo_ui_component_widget_set (componenta, "/Toolbar/AControl", widget, ev); g_assert (!BONOBO_EX (ev)); } { GtkWidget *widget; GdkPixbuf *pixbuf = gdk_pixbuf_new_from_xpm_data (tame_xpm); widget = bonobo_ui_toolbar_button_item_new (pixbuf, "Test Control"); gtk_widget_show (widget); bonobo_ui_component_widget_set (componenta, "/Toolbar/BControl", widget, ev); g_assert (!BONOBO_EX (ev)); } bonobo_ui_component_add_listener (componentb, "MyFoo", toggled_cb, ev); g_assert (!BONOBO_EX (ev)); bonobo_ui_component_set_translate (componentb, "/", statusb, ev); g_assert (!BONOBO_EX (ev)); /* Duplicate set */ bonobo_ui_component_set_translate (componenta, "/", simplea, ev); g_assert (!BONOBO_EX (ev)); bonobo_ui_component_add_verb_list_with_data ( componenta, verbs, GUINT_TO_POINTER (15)); bonobo_ui_component_thaw (componenta, ev); g_assert (!BONOBO_EX (ev)); bonobo_ui_component_set_status (componenta, "WhatA1", ev); g_assert (!BONOBO_EX (ev)); bonobo_ui_component_set_status (componenta, "WhatA1", ev); g_assert (!BONOBO_EX (ev)); bonobo_ui_component_set_status (componentb, "WhatB2", ev); g_assert (!BONOBO_EX (ev)); bonobo_ui_component_set_status (componenta, "WhatA3", ev); g_assert (!BONOBO_EX (ev)); bonobo_ui_component_rm (componenta, "/status", ev); g_assert (!BONOBO_EX (ev)); bonobo_ui_component_set_status (componentb, "WhatB4", ev); g_assert (!BONOBO_EX (ev)); bonobo_ui_component_set_status (componenta, "WhatA5", ev); g_assert (!BONOBO_EX (ev)); bonobo_ui_component_set_status (componenta, "WhatA6>", ev); g_assert (!BONOBO_EX (ev)); bonobo_ui_component_set_status (componentb, "WhatB7", ev); g_assert (!BONOBO_EX (ev)); bonobo_ui_component_set_status (componentb, "", ev); g_assert (!BONOBO_EX (ev)); g_assert (bonobo_ui_component_get_prop ( componentb, "/status/main", "non-existant", ev) == NULL); g_assert (!strcmp (BONOBO_EX_REPOID (ev), ex_Bonobo_UIContainer_NonExistentAttr)); CORBA_exception_free (ev); { const char *good = "<item name=\"main\">WhatA6></item>\n"; txt = bonobo_ui_component_get (componenta, "/status/main", TRUE, NULL); if (!txt || strcmp (txt, good)) { g_warning ("Broken merging code '%s' should be '%s'", txt, good); bonobo_window_dump (win, "on fatal error"); g_assert_not_reached (); } CORBA_free (txt); } bonobo_main (); bonobo_ui_component_freeze (componenta, ev); g_assert (!BONOBO_EX (ev)); bonobo_ui_component_set_translate (componentb, "/menu", simpleb, ev); g_assert (!BONOBO_EX (ev)); bonobo_ui_component_set_translate (componenta, "/", toolb, ev); g_assert (!BONOBO_EX (ev)); bonobo_ui_component_set_prop (componenta, "/menu/File", "label", "_Goo-wan>", ev); g_assert (!BONOBO_EX (ev)); /* A 'transparent' node merge */ txt = bonobo_ui_component_get_prop (componenta, "/Toolbar", "look", ev); g_assert (!BONOBO_EX (ev)); printf ("Before merge look '%s'\n", txt); bonobo_ui_component_set_translate (componenta, "/", "<dockitem name=\"Toolbar\"/>", ev); g_assert (!BONOBO_EX (ev)); g_free (txt); txt = bonobo_ui_component_get_prop (componenta, "/Toolbar", "look", ev); g_assert (!BONOBO_EX (ev)); printf ("After merge look '%s'\n", txt); if (txt == NULL || strcmp (txt, "icon")) g_warning ("Serious transparency regression"); g_free (txt); bonobo_ui_component_set_translate (componenta, "/menu/File/Nice", simplee, ev); g_assert (!BONOBO_EX (ev)); { GtkWidget *widget = gtk_progress_bar_new (); BonoboControl *control = bonobo_control_new (widget); guint id; gtk_widget_show (widget); bonobo_ui_component_object_set (componenta, "/status/Progress", BONOBO_OBJREF (control), NULL); id = gtk_timeout_add (100, (GSourceFunc) update_progress, widget); g_signal_connect (GTK_OBJECT (widget), "destroy", G_CALLBACK (disconnect_progress), GUINT_TO_POINTER (id)); bonobo_object_unref (BONOBO_OBJECT (control)); } bonobo_ui_component_set_status (componenta, "This is a very long status message " "that should cause the window to be resized if " "there is in fact a bug in it", ev); g_assert (!BONOBO_EX (ev)); bonobo_ui_component_thaw (componenta, ev); g_assert (!BONOBO_EX (ev)); bonobo_main (); g_warning ("Begginning stress test, this may take some time ..."); for (i = 0; i < 100; i++) { bonobo_ui_component_freeze (componentc, ev); g_assert (!BONOBO_EX (ev)); bonobo_ui_component_set_translate (componentc, "/commands", "<cmd name=\"MyFoo\" sensitive=\"0\"/>", ev); g_assert (!BONOBO_EX (ev)); bonobo_ui_component_set_translate (componentc, "/menu", simplec, ev); g_assert (!BONOBO_EX (ev)); bonobo_ui_component_set_translate (componentc, "/menu/File", simpled, ev); g_assert (!BONOBO_EX (ev)); bonobo_ui_component_thaw (componentc, ev); g_assert (!BONOBO_EX (ev)); } g_warning ("Done stress test"); bonobo_main (); bonobo_ui_component_freeze (componenta, ev); g_assert (!BONOBO_EX (ev)); fprintf (stderr, "\n\n--- Remove 2 ---\n\n\n"); bonobo_ui_component_rm (componentb, "/", ev); g_assert (!BONOBO_EX (ev)); bonobo_ui_component_set_prop (componentc, "/menu/File/save", "label", "SaveC", ev); g_assert (!BONOBO_EX (ev)); bonobo_ui_component_thaw (componenta, ev); g_assert (!BONOBO_EX (ev)); bonobo_main (); bonobo_ui_component_freeze (componenta, ev); g_assert (!BONOBO_EX (ev)); fprintf (stderr, "\n\n--- Remove 3 ---\n\n\n"); bonobo_ui_component_rm (componentc, "/", ev); g_assert (!BONOBO_EX (ev)); bonobo_ui_component_thaw (componenta, ev); g_assert (!BONOBO_EX (ev)); bonobo_main (); bonobo_ui_component_freeze (componenta, ev); g_assert (!BONOBO_EX (ev)); fprintf (stderr, "\n\n--- Remove 1 ---\n\n\n"); bonobo_ui_component_rm (componenta, "/", ev); g_assert (!BONOBO_EX (ev)); bonobo_ui_component_thaw (componenta, ev); g_assert (!BONOBO_EX (ev)); bonobo_main (); bonobo_object_unref (BONOBO_OBJECT (componenta)); bonobo_object_unref (BONOBO_OBJECT (componentb)); bonobo_object_unref (BONOBO_OBJECT (componentc)); gtk_widget_destroy (GTK_WIDGET (win)); CORBA_exception_free (ev); g_object_unref (program); return bonobo_ui_debug_shutdown (); }
int _wapi_connect(guint32 fd, const struct sockaddr *serv_addr, socklen_t addrlen) { gpointer handle = GUINT_TO_POINTER (fd); struct _WapiHandle_socket *socket_handle; gboolean ok; gint errnum; if (_wapi_handle_type (handle) != WAPI_HANDLE_SOCKET) { WSASetLastError (WSAENOTSOCK); return(SOCKET_ERROR); } if (connect (fd, serv_addr, addrlen) == -1) { mono_pollfd fds; int so_error; socklen_t len; errnum = errno; if (errno != EINTR) { DEBUG ("%s: connect error: %s", __func__, strerror (errnum)); errnum = errno_to_WSA (errnum, __func__); if (errnum == WSAEINPROGRESS) errnum = WSAEWOULDBLOCK; /* see bug #73053 */ WSASetLastError (errnum); /* * On solaris x86 getsockopt (SO_ERROR) is not set after * connect () fails so we need to save this error. * * But don't do this for EWOULDBLOCK (bug 317315) */ if (errnum != WSAEWOULDBLOCK) { ok = _wapi_lookup_handle (handle, WAPI_HANDLE_SOCKET, (gpointer *)&socket_handle); if (ok == FALSE) { /* ECONNRESET means the socket was closed by another thread */ /* Async close on mac raises ECONNABORTED. */ if (errnum != WSAECONNRESET && errnum != WSAENETDOWN) g_warning ("%s: error looking up socket handle %p (error %d)", __func__, handle, errnum); } else { socket_handle->saved_error = errnum; } } return(SOCKET_ERROR); } fds.fd = fd; fds.events = MONO_POLLOUT; while (mono_poll (&fds, 1, -1) == -1 && !_wapi_thread_cur_apc_pending ()) { if (errno != EINTR) { errnum = errno_to_WSA (errno, __func__); DEBUG ("%s: connect poll error: %s", __func__, strerror (errno)); WSASetLastError (errnum); return(SOCKET_ERROR); } } len = sizeof(so_error); if (getsockopt (fd, SOL_SOCKET, SO_ERROR, &so_error, &len) == -1) { errnum = errno_to_WSA (errno, __func__); DEBUG ("%s: connect getsockopt error: %s", __func__, strerror (errno)); WSASetLastError (errnum); return(SOCKET_ERROR); } if (so_error != 0) { errnum = errno_to_WSA (so_error, __func__); /* Need to save this socket error */ ok = _wapi_lookup_handle (handle, WAPI_HANDLE_SOCKET, (gpointer *)&socket_handle); if (ok == FALSE) { g_warning ("%s: error looking up socket handle %p", __func__, handle); } else { socket_handle->saved_error = errnum; } DEBUG ("%s: connect getsockopt returned error: %s", __func__, strerror (so_error)); WSASetLastError (errnum); return(SOCKET_ERROR); } } return(0); }
GtkWidget * create_applications_menu (const char *menu_file, const char *menu_path, gboolean always_show_image) { GMenuTree *tree; GtkWidget *menu; guint idle_id; GError *error = NULL; menu = create_empty_menu (); if (always_show_image) g_object_set_data (G_OBJECT (menu), "panel-menu-force-icon-for-categories", GINT_TO_POINTER (TRUE)); tree = gmenu_tree_new (menu_file, GMENU_TREE_FLAGS_SORT_DISPLAY_NAME); if (!gmenu_tree_load_sync (tree, &error)) { g_warning ("Failed to load applications: %s", error->message); g_clear_error (&error); return menu; } g_object_set_data_full (G_OBJECT (menu), "panel-menu-tree", g_object_ref (tree), (GDestroyNotify) g_object_unref); g_object_set_data_full (G_OBJECT (menu), "panel-menu-tree-path", g_strdup (menu_path ? menu_path : "/"), (GDestroyNotify) g_free); g_object_set_data (G_OBJECT (menu), "panel-menu-needs-loading", GUINT_TO_POINTER (TRUE)); g_signal_connect (menu, "show", G_CALLBACK (submenu_to_display), NULL); idle_id = g_idle_add_full (G_PRIORITY_LOW, submenu_to_display_in_idle, menu, NULL); g_object_set_data_full (G_OBJECT (menu), "panel-menu-idle-id", GUINT_TO_POINTER (idle_id), remove_submenu_to_display_idle); g_signal_connect (menu, "button_press_event", G_CALLBACK (menu_dummy_button_press_event), NULL); g_signal_connect (tree, "changed", G_CALLBACK (handle_gmenu_tree_changed), menu); g_signal_connect (menu, "destroy", G_CALLBACK (remove_gmenu_tree_monitor), tree); g_object_unref (tree); return menu; }
int _wapi_setsockopt(guint32 fd, int level, int optname, const void *optval, socklen_t optlen) { gpointer handle = GUINT_TO_POINTER (fd); int ret; const void *tmp_val; #if defined (__linux__) /* This has its address taken so it cannot be moved to the if block which uses it */ int bufsize = 0; #endif struct timeval tv; if (_wapi_handle_type (handle) != WAPI_HANDLE_SOCKET) { WSASetLastError (WSAENOTSOCK); return(SOCKET_ERROR); } tmp_val = optval; if (level == SOL_SOCKET && (optname == SO_RCVTIMEO || optname == SO_SNDTIMEO)) { int ms = *((int *) optval); tv.tv_sec = ms / 1000; tv.tv_usec = (ms % 1000) * 1000; // micro from milli tmp_val = &tv; optlen = sizeof (tv); } #if defined (__linux__) else if (level == SOL_SOCKET && (optname == SO_SNDBUF || optname == SO_RCVBUF)) { /* According to socket(7) the Linux kernel doubles the * buffer sizes "to allow space for bookkeeping * overhead." */ bufsize = *((int *) optval); bufsize /= 2; tmp_val = &bufsize; } #endif ret = setsockopt (fd, level, optname, tmp_val, optlen); if (ret == -1) { gint errnum = errno; DEBUG ("%s: setsockopt error: %s", __func__, strerror (errno)); errnum = errno_to_WSA (errnum, __func__); WSASetLastError (errnum); return(SOCKET_ERROR); } #if defined (SO_REUSEPORT) /* BSD's and MacOS X multicast sockets also need SO_REUSEPORT when SO_REUSEADDR is requested. */ if (level == SOL_SOCKET && optname == SO_REUSEADDR) { int type; socklen_t type_len = sizeof (type); if (!getsockopt (fd, level, SO_TYPE, &type, &type_len)) { if (type == SOCK_DGRAM || type == SOCK_STREAM) setsockopt (fd, level, SO_REUSEPORT, tmp_val, optlen); } } #endif return(ret); }
static void gcal_toolbar_set_overview_mode (GcalToolbar *toolbar) { GcalToolbarPrivate *priv; GtkStyleContext *context; GtkWidget *button; g_return_if_fail (GCAL_IS_TOOLBAR (toolbar)); priv = toolbar->priv; /* add */ if (priv->add_button == NULL) { priv->add_button = gtk_button_new_with_label (_("New Event")); g_object_ref_sink (priv->add_button); gtk_widget_set_size_request (priv->add_button, 100, -1); context = gtk_widget_get_style_context (priv->add_button); gtk_style_context_add_class (context, "suggested-action"); g_signal_connect (priv->add_button, "clicked", G_CALLBACK (gcal_toolbar_add_event), toolbar); } gtk_container_add (GTK_CONTAINER (priv->left_item), priv->add_button); gtk_widget_show_all (priv->add_button); /* views_box */ if (priv->views_box == NULL) { priv->views_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); g_object_ref_sink (priv->views_box); gtk_widget_set_hexpand (priv->views_box, TRUE); context = gtk_widget_get_style_context (priv->views_box); gtk_style_context_add_class (context, "linked"); /* day */ button = gtk_toggle_button_new_with_label (_("Day")); gtk_widget_set_size_request (button, 80, -1); context = gtk_widget_get_style_context (button); gtk_style_context_add_class (context, "raised"); gtk_container_add (GTK_CONTAINER (priv->views_box), button); g_object_set_data (G_OBJECT (button), "view-type", GUINT_TO_POINTER (GCAL_WINDOW_VIEW_DAY)); g_signal_connect (button, "toggled", G_CALLBACK (gcal_toolbar_view_changed), toolbar); /* week */ button = gtk_toggle_button_new_with_label (_("Week")); gtk_widget_set_size_request (button, 80, -1); context = gtk_widget_get_style_context (button); gtk_style_context_add_class (context, "raised"); gtk_container_add (GTK_CONTAINER (priv->views_box), button); g_object_set_data (G_OBJECT (button), "view-type", GUINT_TO_POINTER (GCAL_WINDOW_VIEW_WEEK)); g_signal_connect (button, "toggled", G_CALLBACK (gcal_toolbar_view_changed), toolbar); /* month */ button = gtk_toggle_button_new_with_label (_("Month")); gtk_widget_set_size_request (button, 80, -1); context = gtk_widget_get_style_context (button); gtk_style_context_add_class (context, "raised"); gtk_container_add (GTK_CONTAINER (priv->views_box), button); g_object_set_data (G_OBJECT (button), "view-type", GUINT_TO_POINTER (GCAL_WINDOW_VIEW_MONTH)); g_signal_connect (button, "toggled", G_CALLBACK (gcal_toolbar_view_changed), toolbar); /* year */ button = gtk_toggle_button_new_with_label (_("Year")); gtk_widget_set_size_request (button, 80, -1); context = gtk_widget_get_style_context (button); gtk_style_context_add_class (context, "raised"); gtk_container_add (GTK_CONTAINER (priv->views_box), button); g_object_set_data (G_OBJECT (button), "view-type", GUINT_TO_POINTER (GCAL_WINDOW_VIEW_YEAR)); g_signal_connect (button, "toggled", G_CALLBACK (gcal_toolbar_view_changed), toolbar); /* list */ button = gtk_toggle_button_new_with_label (_("List")); gtk_widget_set_size_request (button, 80, -1); context = gtk_widget_get_style_context (button); gtk_style_context_add_class (context, "raised"); gtk_container_add (GTK_CONTAINER (priv->views_box), button); g_object_set_data (G_OBJECT (button), "view-type", GUINT_TO_POINTER (GCAL_WINDOW_VIEW_LIST)); g_signal_connect (button, "toggled", G_CALLBACK (gcal_toolbar_view_changed), toolbar); } gtk_container_add (GTK_CONTAINER (priv->central_item), priv->views_box); gtk_widget_show_all (priv->views_box); /* right_box */ if (priv->right_box == NULL) { priv->right_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); g_object_ref_sink (priv->right_box); gtk_widget_set_hexpand (priv->right_box, TRUE); gtk_box_set_spacing (GTK_BOX (priv->right_box), 6); /* sources_button */ priv->sources_button = gtk_toggle_button_new (); gtk_container_add ( GTK_CONTAINER (priv->sources_button), gtk_image_new_from_icon_name ("x-office-calendar-symbolic", GTK_ICON_SIZE_MENU)); context = gtk_widget_get_style_context (priv->sources_button); gtk_style_context_add_class (context, "raised"); gtk_container_add (GTK_CONTAINER (priv->right_box), priv->sources_button); g_signal_connect (priv->sources_button, "clicked", G_CALLBACK (gcal_toolbar_sources_shown), toolbar); /* search_button */ priv->search_button = gtk_button_new (); gtk_container_add ( GTK_CONTAINER (priv->search_button), gtk_image_new_from_icon_name ("folder-saved-search-symbolic", GTK_ICON_SIZE_MENU)); context = gtk_widget_get_style_context (priv->search_button); gtk_style_context_add_class (context, "raised"); gtk_container_add (GTK_CONTAINER (priv->right_box), priv->search_button); g_signal_connect (priv->search_button, "clicked", G_CALLBACK (gcal_toolbar_search_events), toolbar); } gtk_container_add (GTK_CONTAINER (priv->right_item), priv->right_box); gtk_widget_show_all (priv->sources_button); }
static int single_writer_single_reader (void) { mono_mutex_t mutex; MonoConcurrentHashTable *h; int res = 0; mono_os_mutex_init (&mutex); h = mono_conc_hashtable_new (NULL, NULL); mono_os_mutex_lock (&mutex); mono_conc_hashtable_insert (h, GUINT_TO_POINTER (10), GUINT_TO_POINTER (20)); mono_os_mutex_unlock (&mutex); mono_os_mutex_lock (&mutex); mono_conc_hashtable_insert (h, GUINT_TO_POINTER (30), GUINT_TO_POINTER (40)); mono_os_mutex_unlock (&mutex); mono_os_mutex_lock (&mutex); mono_conc_hashtable_insert (h, GUINT_TO_POINTER (50), GUINT_TO_POINTER (60)); mono_os_mutex_unlock (&mutex); mono_os_mutex_lock (&mutex); mono_conc_hashtable_insert (h, GUINT_TO_POINTER (2), GUINT_TO_POINTER (3)); mono_os_mutex_unlock (&mutex); if (mono_conc_hashtable_lookup (h, GUINT_TO_POINTER (30)) != GUINT_TO_POINTER (40)) res = 1; if (mono_conc_hashtable_lookup (h, GUINT_TO_POINTER (10)) != GUINT_TO_POINTER (20)) res = 2; if (mono_conc_hashtable_lookup (h, GUINT_TO_POINTER (2)) != GUINT_TO_POINTER (3)) res = 3; if (mono_conc_hashtable_lookup (h, GUINT_TO_POINTER (50)) != GUINT_TO_POINTER (60)) res = 4; mono_conc_hashtable_destroy (h); mono_os_mutex_destroy (&mutex); if (res) printf ("SERIAL TEST FAILED %d\n", res); return res; }
static struct ice_candidate_pair *__get_pair_by_component(GTree *t, unsigned int component) { return g_tree_find_first(t, __component_find, GUINT_TO_POINTER(component)); }
void client_manager_idle_add(unsigned flags) { assert(flags != 0); client_list_foreach(client_idle_callback, GUINT_TO_POINTER(flags)); }
static void train_word_pair(HashofUnigram hash_of_unigram, KMixtureModelSingleGram * single_gram, phrase_token_t token2, guint32 count){ KMixtureModelArrayItem array_item; bool exists = single_gram->get_array_item(token2, array_item); if ( exists ) { guint32 maximum_occurs_allowed = std_lite::max ((guint32)g_maximum_occurs, (guint32)ceil(array_item.m_Mr * g_maximum_increase_rates)); /* Exceeds the maximum occurs allowed of the word or phrase, * in a single document. */ if ( count > maximum_occurs_allowed ){ gpointer value = NULL; assert( g_hash_table_lookup_extended (hash_of_unigram, GUINT_TO_POINTER(token2), NULL, &value) ); guint32 freq = GPOINTER_TO_UINT(value); freq -= count; if ( freq > 0 ) { g_hash_table_insert(hash_of_unigram, GUINT_TO_POINTER(token2), GUINT_TO_POINTER(freq)); } else if ( freq == 0 ) { assert(g_hash_table_steal(hash_of_unigram, GUINT_TO_POINTER(token2))); } else { assert(false); } return; } array_item.m_WC += count; /* array_item.m_T += count; the same as m_WC. */ array_item.m_N_n_0 ++; if ( 1 == count ) array_item.m_n_1 ++; array_item.m_Mr = std_lite::max(array_item.m_Mr, count); assert(single_gram->set_array_item(token2, array_item)); } else { /* item doesn't exist. */ /* the same as above. */ if ( count > g_maximum_occurs ){ gpointer value = NULL; assert( g_hash_table_lookup_extended (hash_of_unigram, GUINT_TO_POINTER(token2), NULL, &value) ); guint32 freq = GPOINTER_TO_UINT(value); freq -= count; if ( freq > 0 ) { g_hash_table_insert(hash_of_unigram, GUINT_TO_POINTER(token2), GUINT_TO_POINTER(freq)); } else if ( freq == 0 ) { assert(g_hash_table_steal(hash_of_unigram, GUINT_TO_POINTER(token2))); } else { assert(false); } return; } memset(&array_item, 0, sizeof(KMixtureModelArrayItem)); array_item.m_WC = count; /* array_item.m_T = count; the same as m_WC. */ array_item.m_N_n_0 = 1; if ( 1 == count ) array_item.m_n_1 = 1; array_item.m_Mr = count; assert(single_gram->insert_array_item(token2, array_item)); } /* save delta in the array header. */ KMixtureModelArrayHeader array_header; single_gram->get_array_header(array_header); array_header.m_WC += count; single_gram->set_array_header(array_header); }