Ejemplo n.º 1
0
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;
        }
    }
}
Ejemplo n.º 2
0
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));
}
Ejemplo n.º 3
0
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;
	}
}
Ejemplo n.º 5
0
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;
    }
}
Ejemplo n.º 6
0
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);
}
Ejemplo n.º 8
0
/**
* 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);
}
Ejemplo n.º 9
0
/**
 * 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);
}
Ejemplo n.º 10
0
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
}
Ejemplo n.º 11
0
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);
}
Ejemplo n.º 12
0
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 ();
	}
}
Ejemplo n.º 13
0
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);
	}
}
Ejemplo n.º 14
0
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;
    }
}
Ejemplo n.º 15
0
/**
 * 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();
}
Ejemplo n.º 16
0
/* 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();
}
Ejemplo n.º 17
0
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);
}
Ejemplo n.º 18
0
/* 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 ();
	}
}
Ejemplo n.º 20
0
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);
}
Ejemplo n.º 21
0
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 ();
    }
}
Ejemplo n.º 22
0
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);
}
Ejemplo n.º 23
0
/*
 * 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);
}
Ejemplo n.º 26
0
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 ();
    }
}
Ejemplo n.º 27
0
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);
}
Ejemplo n.º 28
0
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();
}
Ejemplo n.º 29
0
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;
}