void gimp_transform_get_flip_axis (gint x, gint y, gint width, gint height, GimpOrientationType flip_type, gboolean auto_center, gdouble *axis) { g_return_if_fail (axis != NULL); if (auto_center) { switch (flip_type) { case GIMP_ORIENTATION_HORIZONTAL: *axis = ((gdouble) x + (gdouble) width / 2.0); break; case GIMP_ORIENTATION_VERTICAL: *axis = ((gdouble) y + (gdouble) height / 2.0); break; default: g_return_if_reached (); break; } } }
void ot_gpgme_error_to_gio_error (gpgme_error_t gpg_error, GError **error) { GIOErrorEnum errcode; /* XXX This list is incomplete. Add cases as needed. */ switch (gpg_error) { /* special case - shouldn't be here */ case GPG_ERR_NO_ERROR: g_return_if_reached (); /* special case - abort on out-of-memory */ case GPG_ERR_ENOMEM: g_error ("%s: %s", gpgme_strsource (gpg_error), gpgme_strerror (gpg_error)); case GPG_ERR_INV_VALUE: errcode = G_IO_ERROR_INVALID_ARGUMENT; break; default: errcode = G_IO_ERROR_FAILED; break; } g_set_error (error, G_IO_ERROR, errcode, "%s: %s", gpgme_strsource (gpg_error), gpgme_strerror (gpg_error)); }
static void gkm_secret_item_real_set_attribute (GkmObject *base, GkmSession *session, GkmTransaction *transaction, CK_ATTRIBUTE_PTR attr) { GkmSecretItem *self = GKM_SECRET_ITEM (base); const gchar *identifier; GkmSecretData *sdata; GHashTable *fields; gchar *schema_name; GkmSecret *secret; gchar *schema; CK_RV rv; if (!self->collection) { gkm_transaction_fail (transaction, CKR_GENERAL_ERROR); g_return_if_reached (); } /* Check that the object is not locked */ if (!gkm_secret_collection_unlocked_have (self->collection, session)) { gkm_transaction_fail (transaction, CKR_USER_NOT_LOGGED_IN); return; } switch (attr->type) { case CKA_VALUE: sdata = gkm_secret_collection_unlocked_use (self->collection, session); g_return_if_fail (sdata); identifier = gkm_secret_object_get_identifier (GKM_SECRET_OBJECT (self)); secret = gkm_secret_new (attr->pValue, attr->ulValueLen); gkm_secret_data_set_transacted (sdata, transaction, identifier, secret); g_object_unref (secret); g_object_unref (sdata); gkm_secret_object_begin_modified (GKM_SECRET_OBJECT (self), transaction); if (!gkm_transaction_get_failed (transaction)) gkm_transaction_add (transaction, self, complete_set_secret, NULL); return; case CKA_G_FIELDS: rv = gkm_secret_fields_parse (attr, &fields, &schema_name); if (rv != CKR_OK) { gkm_transaction_fail (transaction, rv); } else { begin_set_fields (self, transaction, fields); if (schema_name) begin_set_schema (self, transaction, schema_name); } return; case CKA_G_SCHEMA: rv = gkm_attribute_get_string (attr, &schema); if (rv != CKR_OK) gkm_transaction_fail (transaction, rv); else begin_set_schema (self, transaction, schema); return; } GKM_OBJECT_CLASS (gkm_secret_item_parent_class)->set_attribute (base, session, transaction, attr); }
void gydp_convert_ydp_buffer(const gchar *text, gboolean phonetic, gchar *buffer) { const gchar **convert; gsize size; /* extract current encoding table */ if( phonetic ) { convert = gydp_ydp_encoding_phonetic; size = 128 + G_N_ELEMENTS(gydp_ydp_encoding_phonetic); } else { convert = gydp_ydp_encoding_cp1250; size = 128 + G_N_ELEMENTS(gydp_ydp_encoding_cp1250); } /* convert characters */ while( TRUE ) { const guchar c = *(text++); if( c < 128 || c >= size ) *(buffer++) = c; else { switch( strlen(convert[c - 128]) ) { case 1: *(buffer++) = *convert[c - 128]; break; case 2: memcpy(buffer, convert[c - 128], 2); buffer += 2; break; case 3: memcpy(buffer, convert[c - 128], 3); buffer += 3; break; default: g_return_if_reached(); break; } } /* check for terminator */ if( !c ) break; } }
static void moose_list_model_get_value(GtkTreeModel *tree_model, GtkTreeIter *iter, gint column, GValue *value) { MooseListModel *self = MOOSE_LIST_MODEL(tree_model); g_return_if_fail(MOOSE_IS_LIST_MODEL(tree_model)); g_return_if_fail(iter != NULL); g_return_if_fail(column < self->priv->n_columns); g_value_init(value, MOOSE_LIST_MODEL_GET_PRIVATE(tree_model)->column_types[column]); MooseListModelRecord *record = (MooseListModelRecord *)iter->user_data; g_return_if_fail(record != NULL); if(record->pos >= self->priv->num_rows) { g_return_if_reached(); } switch(column) { case MOOSE_LIST_MODEL_COL_RECORD: g_value_set_pointer(value, record); break; case MOOSE_LIST_MODEL_COL_NAME: g_value_set_string(value, record->name); break; case MOOSE_LIST_MODEL_COL_YEAR_BORN: g_value_set_uint(value, record->year_born); break; } }
static void create_connection (GstDtlsDec * self, gchar * id) { g_return_if_fail (GST_IS_DTLS_DEC (self)); g_return_if_fail (GST_IS_DTLS_AGENT (self->agent)); if (self->connection) { g_object_unref (self->connection); self->connection = NULL; } G_LOCK (connection_table); if (!connection_table) { connection_table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL); } if (g_hash_table_contains (connection_table, id)) { G_UNLOCK (connection_table); g_return_if_reached (); } self->connection = g_object_new (GST_TYPE_DTLS_CONNECTION, "agent", self->agent, NULL); g_object_weak_ref (G_OBJECT (self->connection), (GWeakNotify) connection_weak_ref_notify, g_strdup (id)); g_hash_table_insert (connection_table, g_strdup (id), self->connection); G_UNLOCK (connection_table); }
static void action_task_view_cb (GtkRadioAction *action, GtkRadioAction *current, ETaskShellView *task_shell_view) { ETaskShellContent *task_shell_content; GtkOrientable *orientable; GtkOrientation orientation; task_shell_content = task_shell_view->priv->task_shell_content; orientable = GTK_ORIENTABLE (task_shell_content); switch (gtk_radio_action_get_current_value (action)) { case 0: orientation = GTK_ORIENTATION_VERTICAL; break; case 1: orientation = GTK_ORIENTATION_HORIZONTAL; break; default: g_return_if_reached (); } gtk_orientable_set_orientation (orientable, orientation); }
/** * response: The response value from the dialog * * Sets "prompt""response" of output_data to a string corresponding to * the response value * **/ static void gather_response (gint response) { const gchar *value = NULL; switch (response) { case GTK_RESPONSE_OK: value = "ok"; break; case GTK_RESPONSE_CANCEL: value = "no"; break; case GTK_RESPONSE_DELETE_EVENT: value = ""; break; case GTK_RESPONSE_APPLY: value = "other"; break; default: g_return_if_reached (); break; } g_key_file_set_string (output_data, "prompt", "response", value); }
/** * gwy_interpolation_resolve_coeffs_1d: * @n: Number of points in @data. * @data: An array of data values. It will be rewritten with the coefficients. * @interpolation: Interpolation type to prepare @data for. * * Transforms data values in a one-dimensional array to interpolation * coefficients. * * This function is no-op for interpolation types with finite-support * interpolating function. Therefore you can also omit it and use the data * array directly for these interpolation types. * * Since: 2.2 **/ void gwy_interpolation_resolve_coeffs_1d(gint n, gdouble *data, GwyInterpolationType interpolation) { gdouble *buffer; const gdouble *ab; switch (interpolation) { case GWY_INTERPOLATION_NONE: case GWY_INTERPOLATION_ROUND: case GWY_INTERPOLATION_LINEAR: case GWY_INTERPOLATION_KEY: case GWY_INTERPOLATION_NNA: case GWY_INTERPOLATION_SCHAUM: return; case GWY_INTERPOLATION_BSPLINE: ab = synth_func_values_bspline3; break; case GWY_INTERPOLATION_OMOMS: ab = synth_func_values_omoms3; break; default: g_return_if_reached(); break; } buffer = g_new(gdouble, n); deconvolve3_rows(n, 1, n, data, buffer, ab[0], ab[1]); g_free(buffer); }
static void swfdec_video_decoder_gst_decode (SwfdecVideoDecoder *dec, SwfdecBuffer *buffer) { SwfdecVideoDecoderGst *player = SWFDEC_VIDEO_DECODER_GST (dec); #define SWFDEC_ALIGN(x, n) (((x) + (n) - 1) & (~((n) - 1))) GstBuffer *buf; GstCaps *caps; GstStructure *structure; buf = swfdec_gst_buffer_new (swfdec_buffer_ref (buffer)); if (!swfdec_gst_decoder_push (&player->dec, buf)) { swfdec_video_decoder_error (dec, "failed to push buffer"); return; } buf = swfdec_gst_decoder_pull (&player->dec); if (buf == NULL) { SWFDEC_ERROR ("failed to pull decoded buffer. Broken stream?"); return; } else { if (player->last) gst_buffer_unref (player->last); player->last = buf; } while ((buf = swfdec_gst_decoder_pull (&player->dec))) { SWFDEC_ERROR ("too many output buffers!"); gst_buffer_unref (buf); } caps = gst_buffer_get_caps (player->last); if (caps == NULL) { swfdec_video_decoder_error (dec, "no caps on decoded buffer"); return; } structure = gst_caps_get_structure (caps, 0); if (!gst_structure_get_int (structure, "width", (int *) &dec->width) || !gst_structure_get_int (structure, "height", (int *) &dec->height)) { swfdec_video_decoder_error (dec, "invalid caps on decoded buffer"); return; } buf = player->last; switch (swfdec_video_codec_get_format (dec->codec)) { case SWFDEC_VIDEO_FORMAT_RGBA: dec->plane[0] = buf->data; dec->rowstride[0] = dec->width * 4; break; case SWFDEC_VIDEO_FORMAT_I420: dec->plane[0] = buf->data; dec->rowstride[0] = SWFDEC_ALIGN (dec->width, 4); dec->plane[1] = dec->plane[0] + dec->rowstride[0] * SWFDEC_ALIGN (dec->height, 2); dec->rowstride[1] = SWFDEC_ALIGN (dec->width, 8) / 2; dec->plane[2] = dec->plane[1] + dec->rowstride[1] * SWFDEC_ALIGN (dec->height, 2) / 2; dec->rowstride[2] = dec->rowstride[1]; g_assert (dec->plane[2] + dec->rowstride[2] * SWFDEC_ALIGN (dec->height, 2) / 2 == dec->plane[0] + buf->size); break; default: g_return_if_reached (); } #undef SWFDEC_ALIGN }
static void on_clicked (GtkToolButton *b, TTXWindow *self) { unsigned u; unsigned page, subpage; u = GPOINTER_TO_SIZE(g_object_get_data (G_OBJECT(b), BUTTON_ID)); switch (u) { case BUTTON_PREV: page = self->priv->page - 1; subpage = 1; break; case BUTTON_NEXT: page = self->priv->page + 1; subpage = 1; break; case BUTTON_REFRESH: page = self->priv->page; subpage = self->priv->subpage; break; default: g_return_if_reached (); return; }; if (page >= 100 && page <= 999) ttx_window_request_page (self, NULL, page, subpage); }
static void xed_object_module_get_property (GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) { XedObjectModule *module = XED_OBJECT_MODULE (object); switch (prop_id) { case PROP_MODULE_NAME: g_value_set_string (value, module->priv->module_name); break; case PROP_PATH: g_value_set_string (value, module->priv->path); break; case PROP_TYPE_REGISTRATION: g_value_set_string (value, module->priv->type_registration); break; case PROP_RESIDENT: g_value_set_boolean (value, module->priv->resident); break; default: g_return_if_reached (); } }
void nm_firewall_manager_cancel_call (NMFirewallManagerCallId call) { NMFirewallManager *self; NMFirewallManagerPrivate *priv; CBInfo *info = call; gs_free_error GError *error = NULL; g_return_if_fail (info); g_return_if_fail (NM_IS_FIREWALL_MANAGER (info->self)); self = info->self; priv = NM_FIREWALL_MANAGER_GET_PRIVATE (self); if (!g_hash_table_remove (priv->pending_calls, info)) g_return_if_reached (); nm_utils_error_set_cancelled (&error, FALSE, "NMFirewallManager"); _LOGD (info, "complete: cancel (%s)", error->message); _cb_info_callback (info, error); if (_cb_info_is_idle (info)) { g_source_remove (info->idle.id); _cb_info_free (info); } else { info->mode = CB_INFO_MODE_DBUS_COMPLETED; g_cancellable_cancel (info->dbus.cancellable); g_clear_object (&info->self); } }
static void set_logical_color (GtkWidget *button) { GdkColor color; const gchar *colorname; HeCheckButtonPrivate *priv = HE_CHECK_BUTTON_GET_PRIVATE (button); GtkWidget *label = GTK_WIDGET (priv->value); switch (priv->style) { case HE_CHECK_BUTTON_STYLE_NORMAL: colorname = "SecondaryTextColor"; break; case HE_CHECK_BUTTON_STYLE_PICKER: colorname = "ActiveTextColor"; break; default: g_return_if_reached (); } gtk_widget_ensure_style (label); if (gtk_style_lookup_color (label->style, colorname, &color) == TRUE) { priv->setting_style = TRUE; gtk_widget_modify_fg (label, GTK_STATE_NORMAL, &color); gtk_widget_modify_fg (label, GTK_STATE_PRELIGHT, &color); priv->setting_style = FALSE; } }
/** * infd_acl_account_info_remove_certificate: * @info: A #InfdAclAccountInfo. * @fingerprint: A certificate fingerprint registered with @info. * * Removes the given fingerprint from the list of certificates in @info. * Showing a certificate with the given fingerprint no longer allows to log * into this account. */ void infd_acl_account_info_remove_certificate(InfdAclAccountInfo* info, const gchar* fingerprint) { guint i; g_return_if_fail(info != NULL); g_return_if_fail(fingerprint != NULL); for(i = 0; i < info->n_certificates; ++i) { if(strcmp(info->certificates[i], fingerprint) == 0) { g_free(info->certificates[i]); info->certificates[i] = info->certificates[info->n_certificates - 1]; info->certificates = g_realloc( info->certificates, sizeof(gchar*) * (info->n_certificates - 1) ); --info->n_certificates; return; } } g_return_if_reached(); }
/* Check-button toggled */ static void group_toggled(GtkToggleButton *btn, gpointer data) { TilemKeypadDialog *kpdlg = data; TilemCalcEmulator *emu; int i; gboolean state; if (kpdlg->refreshing) return; g_return_if_fail(kpdlg->dbg != NULL); g_return_if_fail(kpdlg->dbg->emu != NULL); emu = kpdlg->dbg->emu; state = gtk_toggle_button_get_active(btn); for (i = 0; i < NGROUPS; i++) { if (GTK_WIDGET(btn) == kpdlg->output[i]) { tilem_calc_emulator_lock(emu); if (state) emu->calc->keypad.group &= ~(1 << i); else emu->calc->keypad.group |= (1 << i); tilem_calc_emulator_unlock(emu); tilem_keypad_dialog_refresh(kpdlg); return; } } g_return_if_reached(); }
static void handle_response (CcnetProcessor *processor, char *code, char *code_msg, char *content, int clen) { SeafileSendcommitV3Proc *proc = (SeafileSendcommitV3Proc *)processor; TransferTask *task = proc->tx_task; if (task->state != TASK_STATE_NORMAL) { ccnet_processor_done (processor, TRUE); return; } switch (processor->state) { case INIT: if (memcmp (code, SC_OK, 3) == 0) { processor->state = SEND_OBJECT; send_commits (processor, task->head); return; } break; case SEND_OBJECT: if (memcmp (code, SC_ACK, 3) == 0) { send_one_commit (processor); return; } break; default: g_return_if_reached (); } g_warning ("Bad response: %s %s.\n", code, code_msg); if (memcmp (code, SC_ACCESS_DENIED, 3) == 0) transfer_task_set_error (task, TASK_ERR_ACCESS_DENIED); ccnet_processor_done (processor, FALSE); }
/* Key toggled */ static void key_toggled(GtkToggleButton *btn, gpointer data) { TilemKeypadDialog *kpdlg = data; TilemCalcEmulator *emu; int i, j, k; gboolean state; if (kpdlg->refreshing) return; g_return_if_fail(kpdlg->dbg != NULL); g_return_if_fail(kpdlg->dbg->emu != NULL); emu = kpdlg->dbg->emu; state = gtk_toggle_button_get_active(btn); for (i = 0; i < NGROUPS; i++) { for (j = 0; j < NKEYS; j++) { if (GTK_WIDGET(btn) == kpdlg->keys[i][j]) { k = i * 8 + j + 1; if (state) tilem_calc_emulator_press_key(emu, k); else tilem_calc_emulator_release_key(emu, k); return; } } } g_return_if_reached(); }
static void pluma_object_module_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { PlumaObjectModule *module = PLUMA_OBJECT_MODULE (object); switch (prop_id) { case PROP_MODULE_NAME: module->priv->module_name = g_value_dup_string (value); g_type_module_set_name (G_TYPE_MODULE (object), module->priv->module_name); break; case PROP_PATH: module->priv->path = g_value_dup_string (value); break; case PROP_TYPE_REGISTRATION: module->priv->type_registration = g_value_dup_string (value); break; case PROP_RESIDENT: module->priv->resident = g_value_get_boolean (value); break; default: g_return_if_reached (); } }
static void xr_call_serialize_response_json(xr_call* call, char** buf, int* len) { GSList* i; struct json_object *r, *error; if (call->error_set) { r = json_object_new_object(); json_object_object_add(r, "result", NULL); json_object_object_add(r, "error", error = json_object_new_object()); json_object_object_add(r, "id", json_object_new_string("1")); json_object_object_add(error, "code", json_object_new_int(call->errcode)); json_object_object_add(error, "message", json_object_new_string(call->errmsg)); } else if (call->retval) { r = json_object_new_object(); json_object_object_add(r, "result", _xr_value_serialize_json(call->retval)); json_object_object_add(r, "error", NULL); json_object_object_add(r, "id", json_object_new_string("1")); } else g_return_if_reached(); *buf = g_strdup(json_object_to_json_string(r)); *len = strlen(*buf); json_object_put(r); }
static void gimp_drawable_transform_rotate_point (gint x, gint y, GimpRotationType rotate_type, gdouble center_x, gdouble center_y, gint *new_x, gint *new_y) { g_return_if_fail (new_x != NULL); g_return_if_fail (new_y != NULL); switch (rotate_type) { case GIMP_ROTATE_90: *new_x = RINT (center_x - (gdouble) y + center_y); *new_y = RINT (center_y + (gdouble) x - center_x); break; case GIMP_ROTATE_180: *new_x = RINT (center_x - ((gdouble) x - center_x)); *new_y = RINT (center_y - ((gdouble) y - center_y)); break; case GIMP_ROTATE_270: *new_x = RINT (center_x + (gdouble) y - center_y); *new_y = RINT (center_y - (gdouble) x + center_x); break; default: *new_x = x; *new_y = y; g_return_if_reached (); } }
static void print_verdict (VData *vdata, gboolean color) { g_print ("verdict: "); switch (vdata->combined_status) { case MU_MSG_PART_SIG_STATUS_UNSIGNED: g_print ("%s", "no signature found"); break; case MU_MSG_PART_SIG_STATUS_GOOD: color_maybe (MU_COLOR_GREEN); g_print ("%s", "signature(s) verified"); break; case MU_MSG_PART_SIG_STATUS_BAD: color_maybe (MU_COLOR_RED); g_print ("%s", "bad signature"); break; case MU_MSG_PART_SIG_STATUS_ERROR: color_maybe (MU_COLOR_RED); g_print ("%s", "verification failed"); break; case MU_MSG_PART_SIG_STATUS_FAIL: color_maybe(MU_COLOR_RED); g_print ("%s", "error in verification process"); break; default: g_return_if_reached (); } color_maybe (MU_COLOR_DEFAULT); if (vdata->report) g_print ("%s%s\n", (vdata->oneline) ? ";" : "\n", vdata->report); }
/* * port_remove * * < private > * Unsafe, need lock fen_lock. */ void port_remove (node_t *f) { /* g_assert(f->source); */ if (NODE_HAS_STATE(f, NODE_STATE_ASSOCIATED)) { /* Mark unregisted. */ if (port_dissociate(PGPFD(f->source)->fd, PORT_SOURCE_FILE, (uintptr_t)FILE_OBJECT(f)) == 0) { /* * Note, we can run foode_delete if dissociating is failed, * because there may be some pending events (mostly like * FILE_DELETE) in the port_get. If we delete the foode * the fnode may be deleted, then port_get will run on an invalid * address. */ NODE_CLE_STATE(f, NODE_STATE_ASSOCIATED); FK_W ("PORT_DISSOCIATE 0x%p OK\n", f); } else if (errno == ENOENT) { /* The file has been removed from port, after port_get or before * port_get but DELETED event has been generated. * Ignored. */ } else { FK_W ("PORT_DISSOCIATE 0x%p %s\n", f, g_strerror (errno)); g_return_if_reached(); } } }
static void send_end_session_response (DBusConnection *conn) { DBusMessageIter args; DBusMessage *msg; DBusMessage *reply; DBusError derr = { 0 }; const gchar *reason = ""; dbus_bool_t is_ok = TRUE; g_return_if_fail (client_session_path); msg = dbus_message_new_method_call (SERVICE_SESSION_MANAGER, client_session_path, IFACE_SESSION_PRIVATE, "EndSessionResponse"); g_return_if_fail (msg); dbus_message_iter_init_append (msg, &args); if (!dbus_message_iter_append_basic (&args, DBUS_TYPE_BOOLEAN, &is_ok) || !dbus_message_iter_append_basic (&args, DBUS_TYPE_STRING, &reason)) g_return_if_reached (); reply = dbus_connection_send_with_reply_and_block (conn, msg, 1000, &derr); dbus_message_unref (msg); if (!reply) { g_message ("dbus failure responding to ending session: %s", derr.message); return; } dbus_message_unref (reply); }
static void ide_preferences_spin_button_value_changed (IdePreferencesSpinButton *self, GParamSpec *pspec, GtkSpinButton *spin_button) { GVariant *variant = NULL; gdouble value; g_assert (IDE_IS_PREFERENCES_SPIN_BUTTON (self)); g_assert (pspec != NULL); g_assert (GTK_IS_SPIN_BUTTON (spin_button)); value = gtk_spin_button_get_value (spin_button); if (g_variant_type_equal (self->type, G_VARIANT_TYPE_DOUBLE)) variant = g_variant_new_double (value); else if (g_variant_type_equal (self->type, G_VARIANT_TYPE_INT16)) variant = g_variant_new_int16 (value); else if (g_variant_type_equal (self->type, G_VARIANT_TYPE_UINT16)) variant = g_variant_new_uint16 (value); else if (g_variant_type_equal (self->type, G_VARIANT_TYPE_INT32)) variant = g_variant_new_int32 (value); else if (g_variant_type_equal (self->type, G_VARIANT_TYPE_UINT32)) variant = g_variant_new_uint32 (value); else if (g_variant_type_equal (self->type, G_VARIANT_TYPE_INT64)) variant = g_variant_new_int64 (value); else if (g_variant_type_equal (self->type, G_VARIANT_TYPE_UINT64)) variant = g_variant_new_uint64 (value); else g_return_if_reached (); g_variant_ref_sink (variant); g_settings_set_value (self->settings, self->key, variant); g_clear_pointer (&variant, g_variant_unref); }
static void handle_response (CcnetProcessor *processor, char *code, char *code_msg, char *content, int clen) { SeafileSendcommitV2Proc *proc = (SeafileSendcommitV2Proc *)processor; TransferTask *task = proc->tx_task; if (task->state != TASK_STATE_NORMAL) { /* TODO: not tested yet */ ccnet_processor_send_update (processor, SC_SHUTDOWN, SS_SHUTDOWN, NULL, 0); ccnet_processor_done (processor, TRUE); return; } switch (processor->state) { case INIT: if (memcmp (code, SC_OK, 3) == 0) { processor->state = SEND_OBJECT; send_commits (processor, task->head); } else { seaf_warning ("Bad response: %s %s.\n", code, code_msg); ccnet_processor_done (processor, FALSE); } break; case SEND_OBJECT: seaf_warning ("[sendcommit] Bad response in state SEND_OBJECT: %s %s\n", code, code_msg); ccnet_processor_done (processor, FALSE); break; default: g_return_if_reached (); } }
static void _gcr_display_view_dispose (GObject *obj) { GcrDisplayView *self = GCR_DISPLAY_VIEW (obj); GcrRenderer *renderer; GcrDisplayItem *item; while (self->pv->renderers->len) { renderer = g_ptr_array_index (self->pv->renderers, 0); item = g_hash_table_lookup (self->pv->items, renderer); g_return_if_fail (item); g_signal_handler_disconnect (renderer, item->data_changed_id); if (!g_hash_table_remove (self->pv->items, renderer)) g_return_if_reached (); g_ptr_array_remove_index_fast (self->pv->renderers, 0); } if (self->pv->buffer) g_object_unref (self->pv->buffer); self->pv->buffer = NULL; g_assert (g_hash_table_size (self->pv->items) == 0); G_OBJECT_CLASS (_gcr_display_view_parent_class)->dispose (obj); }
void gltk_box_remove_widget(GltkBox* box, GltkWidget* widget) { GList* pChildren = box->children; while (pChildren) { GltkBoxChild* child = (GltkBoxChild*)pChildren->data; if (child->widget == widget) { GList* start = g_list_remove_link(pChildren, pChildren); if (pChildren == box->children) box->children = start; gltk_widget_unparent(child->widget); gltk_widget_set_screen(child->widget, NULL); g_object_unref(G_OBJECT(child->widget)); g_free(child); g_list_free(pChildren); gltk_widget_layout(GLTK_WIDGET(box)); return; } pChildren = pChildren->next; } g_return_if_reached(); }
static void begin_transfer(PurpleXfer *xfer, PurpleInputCondition cond) { PurpleXferType type = purple_xfer_get_type(xfer); PurpleXferUiOps *ui_ops = purple_xfer_get_ui_ops(xfer); if (xfer->start_time != 0) { purple_debug_error("xfer", "Transfer is being started multiple times\n"); g_return_if_reached(); } if (ui_ops == NULL || (ui_ops->ui_read == NULL && ui_ops->ui_write == NULL)) { xfer->dest_fp = g_fopen(purple_xfer_get_local_filename(xfer), type == PURPLE_XFER_RECEIVE ? "wb" : "rb"); if (xfer->dest_fp == NULL) { purple_xfer_show_file_error(xfer, purple_xfer_get_local_filename(xfer)); purple_xfer_cancel_local(xfer); return; } fseek(xfer->dest_fp, xfer->bytes_sent, SEEK_SET); } if (xfer->fd != -1) xfer->watcher = purple_input_add(xfer->fd, cond, transfer_cb, xfer); xfer->start_time = time(NULL); if (xfer->ops.start != NULL) xfer->ops.start(xfer); }
/** * soup_message_headers_set_encoding: * @hdrs: a #SoupMessageHeaders * @encoding: a #SoupEncoding * * Sets the message body encoding that @hdrs will declare. In particular, * you should use this if you are going to send a request or response in * chunked encoding. **/ void soup_message_headers_set_encoding (SoupMessageHeaders *hdrs, SoupEncoding encoding) { if (encoding == hdrs->encoding) return; switch (encoding) { case SOUP_ENCODING_NONE: case SOUP_ENCODING_EOF: soup_message_headers_remove (hdrs, "Transfer-Encoding"); soup_message_headers_remove (hdrs, "Content-Length"); break; case SOUP_ENCODING_CONTENT_LENGTH: soup_message_headers_remove (hdrs, "Transfer-Encoding"); break; case SOUP_ENCODING_CHUNKED: soup_message_headers_remove (hdrs, "Content-Length"); soup_message_headers_replace (hdrs, "Transfer-Encoding", "chunked"); break; default: g_return_if_reached (); } hdrs->encoding = encoding; }