GQuark _EscalateSubprocessErrorQuark() {
  return g_quark_from_string("escalate-subprocess-error-quark");
}
Esempio n. 2
0
/***************************
 *                         *
 * Encodings dialog window *
 *                         *
 **************************/
void
gxi_edit_encodings_clicked_cb (GtkButton *button, GncXmlImportData *data)
{
    GtkBuilder *builder;
    GtkWidget *dialog;
    GtkListStore *list_store;
    GtkTreeStore *tree_store;
    GtkTreeIter iter, parent, *parent_ptr;
    GList *encodings_bak, *enc_iter;
    const gchar *encoding;
    system_encoding_type *system_enc;
    gpointer enc_ptr;
    gint i, j;

    builder = gtk_builder_new();
    gnc_builder_add_from_file (builder, "assistant-xml-encoding.glade", "Encodings Dialog");
    dialog = GTK_WIDGET(gtk_builder_get_object (builder, "Encodings Dialog"));
    data->encodings_dialog = dialog;

    gtk_builder_connect_signals_full (builder, gnc_builder_connect_full_func, data);

    gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (data->assistant));

    data->available_encs_view = GTK_TREE_VIEW (gtk_builder_get_object (builder, "available_encs_view"));

    data->custom_enc_entry = GTK_WIDGET(gtk_builder_get_object (builder, "custom_enc_entry"));

    /* set up selected encodings list */
    data->selected_encs_view = GTK_TREE_VIEW (gtk_builder_get_object (builder, "selected_encs_view"));
    list_store = gtk_list_store_new (ENC_NUM_COLS, G_TYPE_STRING, G_TYPE_POINTER);
    for (enc_iter = data->encodings; enc_iter; enc_iter = enc_iter->next)
    {
        encoding = g_quark_to_string (GPOINTER_TO_UINT (enc_iter->data));
        gtk_list_store_append (list_store, &iter);
        gtk_list_store_set (list_store, &iter, ENC_COL_STRING, encoding,
                            ENC_COL_QUARK, enc_iter->data, -1);
    }
    gtk_tree_view_insert_column_with_attributes (
        data->selected_encs_view, -1, NULL,
        gtk_cell_renderer_text_new (), "text", ENC_COL_STRING, NULL);
    gtk_tree_view_set_model (data->selected_encs_view,
                             GTK_TREE_MODEL (list_store));
    g_object_unref (list_store);

    /* set up system encodings list */
    data->available_encs_view = GTK_TREE_VIEW (gtk_builder_get_object (builder, "available_encs_view"));
    tree_store = gtk_tree_store_new (ENC_NUM_COLS, G_TYPE_STRING, G_TYPE_POINTER);
    for (i = 0, system_enc = system_encodings;
            i < n_system_encodings;
            i++, system_enc++)
    {
        if (i == 0)
        {
            /* first system encoding */
            parent_ptr = NULL;
        }
        else
        {
            parent_ptr = &iter;
            for (j = 0; j < system_enc->parent; j++)
                if (gtk_tree_model_iter_parent (GTK_TREE_MODEL (tree_store),
                                                &parent, &iter))
                {
                    /* go up one level */
                    iter = parent;
                }
                else
                {
                    /* no parent to toplevel element */
                    parent_ptr = NULL;
                }
        }
        if (system_enc->encoding)
            enc_ptr = GUINT_TO_POINTER (g_quark_from_string (system_enc->encoding));
        else
            enc_ptr = NULL;

        gtk_tree_store_append (tree_store, &iter, parent_ptr);
        gtk_tree_store_set (tree_store, &iter, ENC_COL_STRING,
                            gettext (system_enc->text), ENC_COL_QUARK, enc_ptr, -1);
    }
    gtk_tree_view_insert_column_with_attributes (
        data->available_encs_view, -1, NULL,
        gtk_cell_renderer_text_new (), "text", ENC_COL_STRING, NULL);
    gtk_tree_view_set_model (data->available_encs_view,
                             GTK_TREE_MODEL (tree_store));
    g_object_unref (tree_store);

    /* run the dialog */
    encodings_bak = g_list_copy (data->encodings);
    if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK)
    {
        g_list_free (encodings_bak);
        if (!g_list_find (data->encodings,
                          GUINT_TO_POINTER (data->default_encoding)))
        {
            /* choose top level encoding then */
            data->default_encoding = GPOINTER_TO_UINT (data->encodings->data);
        }

        /* update whole page */
        gxi_check_file (data);
        gxi_update_default_enc_combo (data);
        gxi_update_string_box (data);
        gxi_update_conversion_forward (data);
    }
    else
    {
        g_list_free (data->encodings);
        data->encodings = encodings_bak;
    }
    g_object_unref(G_OBJECT(builder));

    gtk_widget_destroy (dialog);
    data->encodings_dialog = NULL;
}
Esempio n. 3
0
static gboolean
gwy_si_unit_parse(GwySIUnit *siunit,
                  const gchar *string)
{
    GwySimpleUnit unit;
    gdouble q;
    const gchar *end;
    gchar *p, *e;
    gint n, i, pfpower;
    GString *buf;
    gboolean dividing = FALSE;

    g_array_set_size(siunit->units, 0);
    siunit->power10 = 0;

    if (!string || !*string)
        return TRUE;

    /* give up when it looks too wild */
    end = strpbrk(string,
                  "\177\001\002\003\004\005\006\007"
                  "\010\011\012\013\014\015\016\017"
                  "\020\021\022\023\024\025\026\027"
                  "\030\031\032\033\034\035\036\037"
                  "!#$&()*,:;[email protected]\\[]_`|{}");
    if (end) {
        g_warning("Invalid character 0x%02x", *end);
        return FALSE;
    }

    /* may start with a multiplier, but it must be a power of 10 */
    q = g_ascii_strtod(string, (gchar**)&end);
    if (end != string) {
        string = end;
        siunit->power10 = ROUND(log10(q));
        if (q <= 0 || fabs(log(q/pow10(siunit->power10))) > 1e-14) {
            g_warning("Bad multiplier %g", q);
            siunit->power10 = 0;
        }
        else if (g_str_has_prefix(string, "<sup>")) {
            string += strlen("<sup>");
            n = strtol(string, (gchar**)&end, 10);
            if (end == string)
                g_warning("Bad exponent %s", string);
            else if (!g_str_has_prefix(end, "</sup>"))
                g_warning("Expected </sup> after exponent");
            else
                siunit->power10 *= n;
            string = end;
        }
        else if (string[0] == '^') {
            string++;
            n = strtol(string, (gchar**)&end, 10);
            if (end == string)
                g_warning("Bad exponent %s", string);
            else
                siunit->power10 *= n;
            string = end;
        }
    }
    while (g_ascii_isspace(*string))
        string++;

    buf = g_string_new("");

    /* the rest are units */
    while (*string) {
        /* units are separated with whitespace and maybe a division sign */
        end = string;
        do {
            end = strpbrk(end, " /");
            if (!end || end == string || *end != '/' || *(end-1) != '<')
                break;
            end++;
        } while (TRUE);
        if (!end)
            end = string + strlen(string);

        g_string_set_size(buf, 0);
        g_string_append_len(buf, string, end - string);

        /* fix sloppy notations */
        if (buf->str[0] == '\272') {
            if (!buf->str[1])
                g_string_assign(buf, "deg");
            else {
                g_string_erase(buf, 0, 1);
                g_string_prepend(buf, "°");
            }
        }
        else if (gwy_strequal(buf->str, "°"))
            g_string_assign(buf, "deg");
        else if (buf->str[0] == '\305' && !buf->str[1])
            g_string_assign(buf, "Å");
        else if (gwy_strequal(buf->str, "Å"))
            g_string_assign(buf, "Å");
        else if (gwy_strequal(buf->str, "AA"))
            g_string_assign(buf, "Å");

        /* get prefix, but be careful not to split mol to mili-ol */
        pfpower = 0;
        for (i = 0; i < G_N_ELEMENTS(known_units); i++) {
            if (g_str_has_prefix(buf->str, known_units[i])
                && !g_ascii_isalpha(buf->str[strlen(known_units[i])]))
                break;
        }
        if (i == G_N_ELEMENTS(known_units) && strlen(buf->str) > 1) {
            for (i = 0; i < G_N_ELEMENTS(SI_prefixes); i++) {
                const gchar *pfx = SI_prefixes[i].prefix;

                if (g_str_has_prefix(buf->str, pfx)
                    && g_ascii_isalpha(buf->str[strlen(pfx)])) {
                    pfpower = SI_prefixes[i].power10;
                    g_string_erase(buf, 0, strlen(pfx));
                    break;
                }
            }
        }

        /* get unit power */
        unit.power = 1;
        if ((p = strstr(buf->str + 1, "<sup>"))) {
            unit.power = strtol(p + strlen("<sup>"), &e, 10);
            if (e == p + strlen("<sup>")
                || !g_str_has_prefix(e, "</sup>")) {
                g_warning("Bad power %s", p);
                unit.power = 1;
            }
            else if (!unit.power || abs(unit.power) > 12) {
                g_warning("Bad power %d", unit.power);
                unit.power = 1;
            }
            g_string_truncate(buf, p - buf->str);
        }
        else if ((p = strchr(buf->str + 1, '^'))) {
            unit.power = strtol(p + 1, &e, 10);
            if (e == p + 1 || *e) {
                g_warning("Bad power %s", p);
                unit.power = 1;
            }
            else if (!unit.power || abs(unit.power) > 12) {
                g_warning("Bad power %d", unit.power);
                unit.power = 1;
            }
            g_string_truncate(buf, p - buf->str);
        }
        else if (buf->len) {
            /* Are we really desperate?  Yes, we are! */
            i = buf->len;
            while (i && (g_ascii_isdigit(buf->str[i-1])
                         || buf->str[i-1] == '-'))
                i--;
            if (i != buf->len) {
                unit.power = strtol(buf->str + i, NULL, 10);
                if (!unit.power || abs(unit.power) > 12) {
                    g_warning("Bad power %d", unit.power);
                    unit.power = 1;
                }
                g_string_truncate(buf, i);
            }
        }

        /* handle some ugly, but quite common units */
        if (gwy_strequal(buf->str, "Å")) {
            pfpower -= 10;
            g_string_assign(buf, "m");
        }
        else if (gwy_strequal(buf->str, "%")) {
            pfpower -= 2;
            g_string_assign(buf, "");
        }

        /* elementary sanity */
        if (!g_utf8_validate(buf->str, -1, (const gchar**)&p)) {
            g_warning("Unit string is not valid UTF-8");
            g_string_truncate(buf, p - buf->str);
        }
        if (!buf->len) {
            /* maybe it's just percentage.  cross fingers and proceed. */
            if (dividing)
                unit.power = -unit.power;
            siunit->power10 += unit.power * pfpower;
        }
        else if (!g_ascii_isalpha(buf->str[0]) && (guchar)buf->str[0] < 128)
            g_warning("Invalid base unit: %s", buf->str);
        else {
            /* append it */
            unit.unit = g_quark_from_string(buf->str);
            if (dividing)
                unit.power = -unit.power;
            gwy_debug("<%s:%u> %d\n", buf->str, unit.unit, unit.power);
            siunit->power10 += unit.power * pfpower;
            g_array_append_val(siunit->units, unit);
        }

        /* TODO: scan known obscure units */
        unit.traits = 0;

        /* get to the next token, looking for division */
        while (g_ascii_isspace(*end))
            end++;
        if (*end == '/') {
            if (dividing)
                g_warning("Cannot group multiple divisions");
            dividing = TRUE;
            end++;
            while (g_ascii_isspace(*end))
                end++;
        }
        string = end;
    }

    gwy_si_unit_canonicalize(siunit);

    return TRUE;
}
Esempio n. 4
0
static guint
dawati_rc_style_parse (GtkRcStyle  *rc_style,
                       GtkSettings *settings,
                       GScanner    *scanner)
{
    GTokenType token;
    static GQuark scope_id;
    guint old_scope;
    int i;
    DawatiRcStyle *mb_style = DAWATI_RC_STYLE (rc_style);

    if (!scope_id)
        scope_id = g_quark_from_string ("dawati-gtk-engine");

    /* set the new scope and store the old scope id */
    old_scope = g_scanner_set_scope (scanner, scope_id);

    /* register the symbols if we haven't already done so */
    if (!g_scanner_lookup_symbol (scanner, dawati_rc_symbols[0].name))
    {
        for (i = 0; dawati_rc_symbols[i].name; i++)
        {
            g_scanner_scope_add_symbol (scanner,
                                        scope_id,
                                        dawati_rc_symbols[i].name,
                                        GINT_TO_POINTER (dawati_rc_symbols[i].
                                                token));
        }
    }

    token = g_scanner_peek_next_token (scanner);
    while (token != G_TOKEN_RIGHT_CURLY)
    {
        switch (token)
        {
        case TOKEN_BORDER_COLOR:
            token = dawati_parse_border_color (scanner, mb_style);
            break;

        case TOKEN_RADIUS:
            g_scanner_get_next_token (scanner);

            token = dawati_get_token (scanner, G_TOKEN_EQUAL_SIGN);
            if (token != G_TOKEN_NONE)
                break;

            token = dawati_get_token (scanner, G_TOKEN_INT);
            if (token != G_TOKEN_NONE)
                break;

            mb_style->radius = scanner->value.v_int;
            break;

        case TOKEN_SHADOW:
            g_scanner_get_next_token (scanner);

            token = dawati_get_token (scanner, G_TOKEN_EQUAL_SIGN);
            if (token != G_TOKEN_NONE)
                break;

            token = dawati_get_token (scanner, G_TOKEN_FLOAT);
            if (token != G_TOKEN_NONE)
                break;

            mb_style->shadow = scanner->value.v_float;
            mb_style->shadow_set = TRUE;
            break;

        default:
            g_scanner_get_next_token (scanner);
            token = G_TOKEN_RIGHT_CURLY;
            break;

        }

        if (token != G_TOKEN_NONE)
        {
            return token;
        }

        token = g_scanner_peek_next_token (scanner);
    }

    g_scanner_get_next_token (scanner);
    g_scanner_set_scope (scanner, old_scope);
    return G_TOKEN_NONE;
}
Esempio n. 5
0
OlAppInfo *
ol_app_info_new (const char *cmdline,
                 const char *name,
                 const char *icon_name,
                 enum OlAppInfoFlags flags,
                 GError **error)
{
  if (cmdline == NULL)
  {
    if (error)
      *error = g_error_new (g_quark_from_string ("OSD Lyrics"),
                            0,
                            "cmdline cannot be NULL");
    return NULL;
  }
  int cmd_index = 0;
  if (flags & OL_APP_INFO_SECOND_IS_EXEC)
    cmd_index = 1;
  gchar **argv = NULL;
  gint argc = 0;
  GError *parse_error = NULL;
  if (!g_shell_parse_argv (cmdline, &argc, &argv, &parse_error))
  {
    if (error)
      *error = g_error_new (g_quark_from_string ("OSD Lyrics"),
                            0,
                            "Cannot parse cmdline: %s", parse_error->message);
    g_error_free (parse_error);
    return NULL;
  }
  if (argc <= cmd_index)
  {
    if (error)
      *error = g_error_new (g_quark_from_string ("OSD Lyrics"),
                            0,
                            "Command name is required in cmdline");
    g_strfreev (argv);
    return NULL;
  }
  OlAppInfo *info = g_object_new (OL_TYPE_APP_INFO, NULL);
  info->binfile = _find_binfile (argv[cmd_index],
                                 (flags & OL_APP_INFO_WITH_PREFIX) != 0);
  if (info->binfile == NULL)
  {
    info->binfile = g_strdup (argv[cmd_index]);
    info->cmdline = g_strdup (cmdline);
    info->should_show = FALSE;
  }
  else
  {
    info->should_show = TRUE;
    _strv_replace (argv, cmd_index, info->binfile);
    info->cmdline = _str_join_argv (argv);
  }
  if (!name)
    name = info->binfile;
  if (!icon_name)
    icon_name = info->binfile;
  info->icon = _icon_new_from_name (icon_name);
  info->name = g_strdup (name);
  if (flags & OL_APP_INFO_PREFER_DESKTOP_FILE)
    _app_info_set_from_desktop_file (info, flags);
  return info;
}
Esempio n. 6
0
static GObject*
hippo_image_cache_parse(HippoObjectCache      *cache,
                        const char            *url,
                        const char            *content_type,
                        GString               *content,
                        GError               **error_p)
{
    cairo_surface_t *csurface;
    HippoSurface *surface;

    g_debug("image cache parse '%s'", url);
    
    if (has_prefix(content, PNG_MAGIC_PREFIX)) {
        GStringReader reader;
        
        reader.str = content;
        reader.already_read = 0;
        
        csurface =
            cairo_image_surface_create_from_png_stream(gstring_read_func,
                                                       &reader);
        
        if (csurface != NULL && cairo_surface_status(csurface) == CAIRO_STATUS_SUCCESS) {
            surface = hippo_surface_new(csurface);
            cairo_surface_destroy(csurface);
        } else {
            const char *msg;
            
            if (csurface) {
                msg = cairo_status_to_string(cairo_surface_status(csurface));
                cairo_surface_destroy(csurface);
            } else {
                msg = _("Corrupt image");
            }
            
            surface = NULL;
            g_set_error(error_p,
                        g_quark_from_string("cairo-surface-error"),
                        0, msg);                    
            goto failed;
        }
    } else if (has_prefix(content, JPEG_MAGIC_PREFIX)) {
        csurface = hippo_parse_jpeg(content->str, content->len, error_p);
        if (csurface == NULL) {
            g_debug("JPEG parse failed for '%s'", url);
            goto failed;
        }
        surface = hippo_surface_new(csurface);
        cairo_surface_destroy(csurface);
    } else {
        g_debug("Unknown image format for '%s'", url);
        g_set_error(error_p, HIPPO_ERROR, HIPPO_ERROR_FAILED, _("Unknown image format"));
        goto failed;
    }

    return G_OBJECT(surface);
    
  failed:
    g_debug("Image parse failed for '%s'", url);
    
    g_assert(error_p == NULL || *error_p != NULL);
    
    return NULL;
}
Esempio n. 7
0
RygelHTTPItemURI* rygel_http_item_uri_construct_from_string (GType object_type, const char* uri, RygelHTTPServer* http_server, GError** error) {
#line 233 "rygel-http-item-uri.c"
	GError * _inner_error_;
	RygelHTTPItemURI * self;
	char* _tmp0_;
	RygelHTTPServer* _tmp1_;
	char* request_uri;
	char** _tmp3_;
	gint _parts_size_;
	gint parts_length1;
	char** _tmp2_;
	char** parts;
	gboolean _tmp4_ = FALSE;
#line 45 "rygel-http-item-uri.vala"
	g_return_val_if_fail (uri != NULL, NULL);
#line 45 "rygel-http-item-uri.vala"
	g_return_val_if_fail (http_server != NULL, NULL);
#line 249 "rygel-http-item-uri.c"
	_inner_error_ = NULL;
#line 45 "rygel-http-item-uri.vala"
	self = (RygelHTTPItemURI*) g_object_new (object_type, NULL);
#line 49 "rygel-http-item-uri.vala"
	self->thumbnail_index = -1;
#line 50 "rygel-http-item-uri.vala"
	self->subtitle_index = -1;
#line 51 "rygel-http-item-uri.vala"
	self->transcode_target = (_tmp0_ = NULL, _g_free0 (self->transcode_target), _tmp0_);
#line 52 "rygel-http-item-uri.vala"
	self->http_server = (_tmp1_ = _g_object_ref0 (http_server), _g_object_unref0 (self->http_server), _tmp1_);
#line 54 "rygel-http-item-uri.vala"
	request_uri = string_replace (uri, rygel_http_server_get_path_root (http_server), "");
#line 263 "rygel-http-item-uri.c"
	parts = (_tmp3_ = _tmp2_ = g_strsplit (request_uri, "/", 0), parts_length1 = _vala_array_length (_tmp2_), _parts_size_ = parts_length1, _tmp3_);
#line 57 "rygel-http-item-uri.vala"
	if (parts_length1 < 2) {
#line 57 "rygel-http-item-uri.vala"
		_tmp4_ = TRUE;
#line 269 "rygel-http-item-uri.c"
	} else {
#line 57 "rygel-http-item-uri.vala"
		_tmp4_ = (parts_length1 % 2) == 0;
#line 273 "rygel-http-item-uri.c"
	}
#line 57 "rygel-http-item-uri.vala"
	if (_tmp4_) {
#line 277 "rygel-http-item-uri.c"
		_inner_error_ = g_error_new (RYGEL_HTTP_REQUEST_ERROR, RYGEL_HTTP_REQUEST_ERROR_BAD_REQUEST, _ ("Invalid URI '%s'"), request_uri);
		{
			if (_inner_error_->domain == RYGEL_HTTP_REQUEST_ERROR) {
				g_propagate_error (error, _inner_error_);
				_g_free0 (request_uri);
				parts = (_vala_array_free (parts, parts_length1, (GDestroyNotify) g_free), NULL);
				g_object_unref (self);
				return NULL;
			} else {
				_g_free0 (request_uri);
				parts = (_vala_array_free (parts, parts_length1, (GDestroyNotify) g_free), NULL);
				g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
				g_clear_error (&_inner_error_);
				return NULL;
			}
		}
	}
	{
		gint i;
#line 62 "rygel-http-item-uri.vala"
		i = 1;
#line 299 "rygel-http-item-uri.c"
		{
			gboolean _tmp5_;
#line 62 "rygel-http-item-uri.vala"
			_tmp5_ = TRUE;
#line 62 "rygel-http-item-uri.vala"
			while (TRUE) {
#line 306 "rygel-http-item-uri.c"
				GQuark _tmp13_;
				const char* _tmp12_;
				static GQuark _tmp13__label0 = 0;
				static GQuark _tmp13__label1 = 0;
				static GQuark _tmp13__label2 = 0;
				static GQuark _tmp13__label3 = 0;
#line 62 "rygel-http-item-uri.vala"
				if (!_tmp5_) {
#line 62 "rygel-http-item-uri.vala"
					i = i + 2;
#line 317 "rygel-http-item-uri.c"
				}
#line 62 "rygel-http-item-uri.vala"
				_tmp5_ = FALSE;
#line 62 "rygel-http-item-uri.vala"
				if (!(i < (parts_length1 - 1))) {
#line 62 "rygel-http-item-uri.vala"
					break;
#line 325 "rygel-http-item-uri.c"
				}
				_tmp12_ = parts[i];
				_tmp13_ = (NULL == _tmp12_) ? 0 : g_quark_from_string (_tmp12_);
				if (_tmp13_ == ((0 != _tmp13__label0) ? _tmp13__label0 : (_tmp13__label0 = g_quark_from_static_string ("item"))))
				switch (0) {
					default:
					{
						guchar* _tmp9_;
						gint _data_size_;
						gint data_length1;
						size_t _tmp7_;
						char* _tmp6_;
						guchar* _tmp8_;
						guchar* data;
						GString* builder;
						char* _tmp10_;
						data = (_tmp9_ = (_tmp8_ = g_base64_decode (_tmp6_ = soup_uri_decode (parts[i + 1]), &_tmp7_), _g_free0 (_tmp6_), _tmp8_), data_length1 = _tmp7_, _data_size_ = data_length1, _tmp9_);
#line 66 "rygel-http-item-uri.vala"
						builder = g_string_new ("");
#line 67 "rygel-http-item-uri.vala"
						g_string_append (builder, (const char*) data);
#line 68 "rygel-http-item-uri.vala"
						self->item_id = (_tmp10_ = g_strdup (builder->str), _g_free0 (self->item_id), _tmp10_);
#line 349 "rygel-http-item-uri.c"
						data = (g_free (data), NULL);
						_g_string_free0 (builder);
#line 70 "rygel-http-item-uri.vala"
						break;
#line 354 "rygel-http-item-uri.c"
					}
				} else if (_tmp13_ == ((0 != _tmp13__label1) ? _tmp13__label1 : (_tmp13__label1 = g_quark_from_static_string ("transcoded"))))
				switch (0) {
					default:
					{
						char* _tmp11_;
#line 72 "rygel-http-item-uri.vala"
						self->transcode_target = (_tmp11_ = soup_uri_decode (parts[i + 1]), _g_free0 (self->transcode_target), _tmp11_);
#line 74 "rygel-http-item-uri.vala"
						break;
#line 365 "rygel-http-item-uri.c"
					}
				} else if (_tmp13_ == ((0 != _tmp13__label2) ? _tmp13__label2 : (_tmp13__label2 = g_quark_from_static_string ("thumbnail"))))
				switch (0) {
					default:
					{
#line 76 "rygel-http-item-uri.vala"
						self->thumbnail_index = atoi (parts[i + 1]);
#line 78 "rygel-http-item-uri.vala"
						break;
#line 375 "rygel-http-item-uri.c"
					}
				} else if (_tmp13_ == ((0 != _tmp13__label3) ? _tmp13__label3 : (_tmp13__label3 = g_quark_from_static_string ("subtitle"))))
				switch (0) {
					default:
					{
#line 80 "rygel-http-item-uri.vala"
						self->subtitle_index = atoi (parts[i + 1]);
#line 82 "rygel-http-item-uri.vala"
						break;
#line 385 "rygel-http-item-uri.c"
					}
				} else
				switch (0) {
					default:
					{
#line 84 "rygel-http-item-uri.vala"
						break;
#line 393 "rygel-http-item-uri.c"
					}
				}
			}
		}
	}
#line 88 "rygel-http-item-uri.vala"
	if (self->item_id == NULL) {
#line 401 "rygel-http-item-uri.c"
		_inner_error_ = g_error_new_literal (RYGEL_HTTP_REQUEST_ERROR, RYGEL_HTTP_REQUEST_ERROR_NOT_FOUND, _ ("Not Found"));
		{
			if (_inner_error_->domain == RYGEL_HTTP_REQUEST_ERROR) {
				g_propagate_error (error, _inner_error_);
				_g_free0 (request_uri);
				parts = (_vala_array_free (parts, parts_length1, (GDestroyNotify) g_free), NULL);
				g_object_unref (self);
				return NULL;
			} else {
				_g_free0 (request_uri);
				parts = (_vala_array_free (parts, parts_length1, (GDestroyNotify) g_free), NULL);
				g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
				g_clear_error (&_inner_error_);
				return NULL;
			}
		}
	}
	_g_free0 (request_uri);
	parts = (_vala_array_free (parts, parts_length1, (GDestroyNotify) g_free), NULL);
	return self;
}
Esempio n. 8
0
/* A window was closed */
static void _xfdashboard_application_tracker_on_window_closed(XfdashboardApplicationTracker *self,
																XfdashboardWindowTrackerWindow *inWindow,
																gpointer inUserData)
{
	XfdashboardApplicationTrackerPrivate	*priv;
	XfdashboardApplicationTrackerItem		*item;

	g_return_if_fail(XFDASHBOARD_IS_APPLICATION_TRACKER(self));
	g_return_if_fail(XFDASHBOARD_IS_WINDOW_TRACKER_WINDOW(inWindow));

	priv=self->priv;

	/* Find application tracker item in list of known running applications
	 * matching the window just closed.
	 */
	item= _xfdashboard_application_tracker_find_item_by_window(self, inWindow);
	if(!item)
	{
		g_debug("Could not find running application for window '%s'",
					xfdashboard_window_tracker_window_get_title(inWindow));

		return;
	}

	g_debug("Closing window '%s' for desktop ID '%s'",
				xfdashboard_window_tracker_window_get_title(inWindow),
				item->desktopID);

	/* Remove window from found application tracker item */
	_xfdashboard_application_tracker_item_remove_window(item, inWindow);

	/* If it was the last window then application is not running anymore
	 * because it has no window.
	 */
	if(!item->windows ||
		g_list_length(item->windows)==0)
	{
		gchar								*desktopID;

		g_debug("Closing window '%s' for desktop ID '%s' closed last window so remove application from list of running ones",
					xfdashboard_window_tracker_window_get_title(inWindow),
					item->desktopID);

		/* Create a copy of desktop ID for signal emission because the
		 * application tracker item will be removed and freed before.
		 */
		desktopID=g_strdup(item->desktopID);

		/* Remove application tracker item from list of running applications
		 * and free it.
		 */
		priv->runningApps=g_list_remove(priv->runningApps, item);
		_xfdashboard_application_tracker_item_free(item);

		/* Emit signal as this application is not running anymore */
		g_debug("Emitting signal 'state-changed' to stopped for desktop ID '%s'", desktopID);
		g_signal_emit(self, XfdashboardApplicationTrackerSignals[SIGNAL_STATE_CHANGED], g_quark_from_string(desktopID), desktopID, FALSE);

		/* Release allocated resources */
		g_free(desktopID);
	}
}
static int mfw_gst_vpuenc_init_encoder(GstPad *pad, enum v4l2_memory memory)
{
	GstVPU_Enc *vpu_enc = MFW_GST_VPU_ENC(GST_PAD_PARENT(pad));
	gchar *mime = "undef";
	gint ret;
	GstCaps *caps = NULL;
	struct v4l2_format fmt;
	int retval, i;

	if (!vpu_enc->codecTypeProvided) {
		GST_ERROR("Incomplete command line.\n");
		GError *error = NULL;
		GQuark domain = g_quark_from_string("mfw_vpuencoder");
		error = g_error_new(domain, 10, "fatal error");
		gst_element_post_message(GST_ELEMENT(vpu_enc),
					 gst_message_new_error
					 (GST_OBJECT(vpu_enc), error,
					  "Incomplete command line - codec type was not provided."));
		return GST_FLOW_ERROR;
	}

	fmt.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
	fmt.fmt.pix.width = vpu_enc->width;
	fmt.fmt.pix.height = vpu_enc->height;
	fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YVU420;

	retval = ioctl(vpu_enc->vpu_fd, VIDIOC_S_FMT, &fmt);
	if (retval) {
		printf("VIDIOC_S_FMT failed: %s\n", strerror(errno));
		return GST_FLOW_ERROR;
	}

	reqs.memory = memory;
	retval = ioctl(vpu_enc->vpu_fd, VIDIOC_REQBUFS, &reqs);
	if (retval) {
		perror("VIDIOC_REQBUFS");
		return GST_FLOW_ERROR;
	}

	retval = ioctl(vpu_enc->vpu_fd, VPU_IOC_CODEC, vpu_enc->codec);
	if (retval) {
		perror("VPU_IOC_CODEC");
		return GST_FLOW_ERROR;
	}

	retval = ioctl(vpu_enc->vpu_fd, VPU_IOC_MJPEG_QUALITY, vpu_enc->mjpeg_quality);
	if (retval) {
		perror("VPU_IOC_MJPEG_QUALITY");
		return GST_FLOW_ERROR;
	}

	for (i = 0; i < NUM_BUFFERS; i++) {
		struct v4l2_buffer *buf = &vpu_enc->buf_v4l2[i];
		buf->type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
		buf->memory = memory;
		buf->index = i;

		if (memory == V4L2_MEMORY_MMAP) {
			retval = ioctl(vpu_enc->vpu_fd, VIDIOC_QUERYBUF, buf);
			if (retval) {
				GST_ERROR("VIDIOC_QUERYBUF failed: %s\n", strerror(errno));
				return GST_FLOW_ERROR;
			}
			vpu_enc->buf_size[i] = buf->length;
			vpu_enc->buf_data[i] = mmap(NULL, buf->length,
					   PROT_READ | PROT_WRITE, MAP_SHARED,
					   vpu_enc->vpu_fd, vpu_enc->buf_v4l2[i].m.offset);
		}
	}

	switch (vpu_enc->codec) {
	case  STD_MPEG4:
		mime = "video/mpeg";
		break;
	case STD_AVC:
		mime = "video/x-h264";
		break;
	case STD_H263:
		mime = "video/x-h263";
		break;
	case STD_MJPG:
		mime = "image/jpeg";
		break;
	default:
		return GST_FLOW_ERROR;
	}

	caps = gst_caps_new_simple(mime,
			   "mpegversion", G_TYPE_INT, 4,
			   "systemstream", G_TYPE_BOOLEAN, FALSE,
			   "height", G_TYPE_INT, vpu_enc->height,
			   "width", G_TYPE_INT, vpu_enc->width,
			   "framerate", GST_TYPE_FRACTION, (gint32) (vpu_enc->framerate * 1000),
			   1000, NULL);

	gst_pad_set_caps(vpu_enc->srcpad, caps);

	vpu_enc->init = TRUE;

	return GST_FLOW_OK;
}
Esempio n. 10
0
/* if simulate==TRUE, return whether accel_path can be changed to
 * accel_key && accel_mods. otherwise, return whether accel_path
 * was actually changed.
 */
static gboolean
internal_change_entry (const gchar    *accel_path,
		       guint           accel_key,
		       GdkModifierType accel_mods,
		       gboolean        replace,
		       gboolean	       simulate)
{
  GSList *node, *slist, *win_list, *group_list, *replace_list = NULL;
  GHashTable *group_hm, *window_hm;
  gboolean change_accel, removable, can_change = TRUE, seen_accel = FALSE;
  GQuark entry_quark;
  AccelEntry *entry = accel_path_lookup (accel_path);

  /* not much todo if there's no entry yet */
  if (!entry)
    {
      if (!simulate)
	{
	  gtk_accel_map_add_entry (accel_path, 0, 0);
	  entry = accel_path_lookup (accel_path);
	  entry->accel_key = accel_key;
	  entry->accel_mods = accel_mods;
	  entry->changed = TRUE;

	  do_accel_map_changed (entry);
	}
      return TRUE;
    }

  /* if there's nothing to change, not much todo either */
  if (entry->accel_key == accel_key && entry->accel_mods == accel_mods)
    {
      if (!simulate)
	entry->changed = TRUE;
      return simulate ? TRUE : FALSE;
    }

  /* The no-change case has already been handled, so 
   * simulate doesn't make a difference here.
   */
  if (entry->lock_count > 0)
    return FALSE;

  /* nobody's interested, easy going */
  if (!entry->groups)
    {
      if (!simulate)
	{
	  entry->accel_key = accel_key;
	  entry->accel_mods = accel_mods;
	  entry->changed = TRUE;

	  do_accel_map_changed (entry);
	}
      return TRUE;
    }

  /* 1) fetch all accel groups affected by this entry */
  entry_quark = g_quark_try_string (entry->accel_path);
  group_hm = g_hash_table_new (NULL, NULL);
  window_hm = g_hash_table_new (NULL, NULL);
  for (slist = entry->groups; slist; slist = slist->next)
    g_hash_table_insert (group_hm, slist->data, slist->data);

  /* 2) collect acceleratables affected */
  group_list = g_hash_table_slist_values (group_hm);
  for (slist = group_list; slist; slist = slist->next)
    {
      GtkAccelGroup *group = slist->data;

      for (node = _gtk_accel_group_get_accelerables (group); node; node = node->next)
	g_hash_table_insert (window_hm, node->data, node->data);
    }
  g_slist_free (group_list);

  /* 3) include all accel groups used by acceleratables */
  win_list = g_hash_table_slist_values (window_hm);
  g_hash_table_destroy (window_hm);
  for (slist = win_list; slist; slist = slist->next)
    for (node = gtk_accel_groups_from_object (slist->data); node; node = node->next)
      g_hash_table_insert (group_hm, node->data, node->data);
  group_list = g_hash_table_slist_values (group_hm);
  g_hash_table_destroy (group_hm);
  
  /* 4) walk the acceleratables and figure whether they occupy accel_key&accel_mods */
  if (accel_key)
    for (slist = win_list; slist; slist = slist->next)
      if (GTK_IS_WINDOW (slist->data))	/* bad kludge in lack of a GtkAcceleratable */
	if (_gtk_window_query_nonaccels (slist->data, accel_key, accel_mods))
	  {
	    seen_accel = TRUE;
	    break;
	  }
  removable = !seen_accel;
  
  /* 5) walk all accel groups and search for locks */
  if (removable)
    for (slist = group_list; slist; slist = slist->next)
      {
	GtkAccelGroup *group = slist->data;
	GtkAccelGroupEntry *ag_entry;
	guint i, n;
	
	n = 0;
	ag_entry = entry->accel_key ? gtk_accel_group_query (group, entry->accel_key, entry->accel_mods, &n) : NULL;
	for (i = 0; i < n; i++)
	  if (ag_entry[i].accel_path_quark == entry_quark)
	    {
	      can_change = !(ag_entry[i].key.accel_flags & GTK_ACCEL_LOCKED);
	      if (!can_change)
		goto break_loop_step5;
	    }
	
	n = 0;
	ag_entry = accel_key ? gtk_accel_group_query (group, accel_key, accel_mods, &n) : NULL;
	for (i = 0; i < n; i++)
	  {
	    seen_accel = TRUE;
	    removable = !gtk_accel_group_get_is_locked (group) && !(ag_entry[i].key.accel_flags & GTK_ACCEL_LOCKED);
	    if (!removable)
	      goto break_loop_step5;
	    if (ag_entry[i].accel_path_quark)
	      replace_list = g_slist_prepend (replace_list, GUINT_TO_POINTER (ag_entry[i].accel_path_quark));
	  }
      }
 break_loop_step5:
  
  /* 6) check whether we can remove existing accelerators */
  if (removable && can_change)
    for (slist = replace_list; slist; slist = slist->next)
      if (!internal_change_entry (g_quark_to_string (GPOINTER_TO_UINT (slist->data)), 0, 0, FALSE, TRUE))
	{
	  removable = FALSE;
	  break;
	}
  
  /* 7) check conditions and proceed if possible */
  change_accel = can_change && (!seen_accel || (removable && replace));
  
  if (change_accel && !simulate)
    {
      /* ref accel groups */
      for (slist = group_list; slist; slist = slist->next)
	g_object_ref (slist->data);

      /* 8) remove existing accelerators */
      for (slist = replace_list; slist; slist = slist->next)
	internal_change_entry (g_quark_to_string (GPOINTER_TO_UINT (slist->data)), 0, 0, FALSE, FALSE);

      /* 9) install new accelerator */
      entry->accel_key = accel_key;
      entry->accel_mods = accel_mods;
      entry->changed = TRUE;

      for (slist = group_list; slist; slist = slist->next)
	_gtk_accel_group_reconnect (slist->data, g_quark_from_string (entry->accel_path));

      /* unref accel groups */
      for (slist = group_list; slist; slist = slist->next)
	g_object_unref (slist->data);

      do_accel_map_changed (entry);
    }
  g_slist_free (replace_list);
  g_slist_free (group_list);
  g_slist_free (win_list);

  return change_accel;
}
Esempio n. 11
0
JSBool
gjs_define_error_class(JSContext    *context,
                       JSObject     *in_object,
                       GIEnumInfo   *info,
                       JSObject    **constructor_p,
                       JSObject    **prototype_p)
{
    const char *constructor_name;
    GIBoxedInfo *glib_error_info;
    JSObject *prototype, *parent_proto;
    JSObject *constructor;
    jsval value;
    Error *priv;

    /* See the comment in gjs_define_boxed_class() for an
     * explanation of how this all works; Error is pretty much the
     * same as Boxed (except that we inherit from GLib.Error).
     */

    constructor_name = g_base_info_get_name( (GIBaseInfo*) info);

    if (gjs_object_get_property(context, in_object, constructor_name, &value)) {
        JSObject *constructor;

        if (!JSVAL_IS_OBJECT(value)) {
            gjs_throw(context, "Existing property '%s' does not look like a constructor",
                         constructor_name);
            return JS_FALSE;
        }

        constructor = JSVAL_TO_OBJECT(value);

        gjs_object_get_property(context, constructor, "prototype", &value);
        if (!JSVAL_IS_OBJECT(value)) {
            gjs_throw(context, "error %s prototype property does not appear to exist or has wrong type", constructor_name);
            return JS_FALSE;
        } else {
            if (prototype_p)
                *prototype_p = JSVAL_TO_OBJECT(value);
            if (constructor_p)
                *constructor_p = constructor;

            return JS_TRUE;
        }
    }

    g_irepository_require(NULL, "GLib", "2.0", 0, NULL);
    glib_error_info = (GIBoxedInfo*) g_irepository_find_by_name(NULL, "GLib", "Error");
    parent_proto = gjs_lookup_boxed_prototype(context, glib_error_info);
    g_base_info_unref((GIBaseInfo*)glib_error_info);

    if (!gjs_init_class_dynamic(context, in_object,
                                parent_proto,
                                g_base_info_get_namespace( (GIBaseInfo*) info),
                                constructor_name,
                                &gjs_error_class,
                                gjs_error_constructor, 1,
                                /* props of prototype */
                                &gjs_error_proto_props[0],
                                /* funcs of prototype */
                                &gjs_error_proto_funcs[0],
                                /* props of constructor, MyConstructor.myprop */
                                NULL,
                                /* funcs of constructor, MyConstructor.myfunc() */
                                &gjs_error_constructor_funcs[0],
                                &prototype,
                                &constructor)) {
        gjs_log_exception(context, NULL);
        gjs_fatal("Can't init class %s", constructor_name);
    }

    GJS_INC_COUNTER(gerror);
    priv = g_slice_new0(Error);
    priv->info = info;
    g_base_info_ref( (GIBaseInfo*) priv->info);
    priv->domain = g_quark_from_string (g_enum_info_get_error_domain(priv->info));

    JS_SetPrivate(context, prototype, priv);

    gjs_debug(GJS_DEBUG_GBOXED, "Defined class %s prototype is %p class %p in object %p",
              constructor_name, prototype, JS_GET_CLASS(context, prototype), in_object);

    gjs_define_enum_values(context, constructor, priv->info);

    if (constructor_p)
        *constructor_p = constructor;

    if (prototype_p)
        *prototype_p = prototype;

    return JS_TRUE;
}
Esempio n. 12
0
File: io.c Progetto: kyoushuu/gwaei
//!
//! @brief Callback function to read data in from a file and send it to a stream
//! @param data A pointer to a LwIoProcessFdData object
//! @returns Returns if there was an error
//!
gpointer _stdin_func (gpointer data)
{
    //Sanity checks
    g_return_val_if_fail (data != NULL, NULL);

    //Declarations
    const int MAX_CHUNK = 128;
    char buffer[MAX_CHUNK];
    size_t chunk;
    size_t curpos;
    size_t end;
    double fraction;
    FILE *file;
    FILE *stream;
    LwIoProcessFdData* in;
    const char *message;
    GQuark domain;
    GCancellable *cancellable;
    gboolean is_cancelled;

    //Initalizations
    in = data;
    chunk = 0;
    curpos = 0;
    end = lw_io_get_filesize (in->uri);
    fraction = 0.0;
    file = fopen(in->uri, "rb");
    stream = fdopen(in->fd, "ab");
    cancellable = in->cancellable;

    while (file != NULL && ferror(file) == 0 && feof(file) == 0)
    {
      is_cancelled = (cancellable != NULL && g_cancellable_is_cancelled (cancellable));
      if (is_cancelled) break;

      fraction = ((double) curpos / (double) end);
      if (in->cb != NULL) in->cb (fraction, in->data);

      chunk = fread(buffer, sizeof(char), MAX_CHUNK, file);
      curpos += chunk;
      chunk = fwrite(buffer, sizeof(char), chunk, stream);
      fflush(stream);
    }
    fraction = 1.0;
    if (in->cb != NULL) in->cb (fraction, in->data);

    if (ferror(file) != 0)
    {
      domain = g_quark_from_string (LW_IO_ERROR);
      message = gettext("Unable to read data from the input file.");
      in->error = g_error_new (domain, LW_IO_READ_ERROR, "%s", message);
    }
    else if(ferror(stream) != 0)
    {
      domain = g_quark_from_string (LW_IO_ERROR);
      message = gettext("Unable to write to the external program's input stream.");
      in->error = g_error_new (domain, LW_IO_WRITE_ERROR, "%s", message);
    }

    //Cleanup
    fclose(file);
    fclose(stream);

    return (in->error);
}
Esempio n. 13
0
File: io.c Progetto: kyoushuu/gwaei
//!
//! @brief Downloads a file using libcurl
//! @param source_path String of the source url
//! @param target_path String of the path to save the file locally
//! @param cb A LwIoProgressCallback to use to give progress feedback or NULL
//! @param data gpointer to data to pass to the function pointer
//! @param error Error handling
//!
gboolean 
lw_io_download (const gchar           *SOURCE_PATH, 
                const gchar           *TARGET_PATH, 
                LwIoProgressCallback   cb,
                gpointer               data, 
                GCancellable          *cancellable,
                GError               **error)
{
    if (error != NULL && *error != NULL) return FALSE;

  curl_global_init (CURL_GLOBAL_ALL);

    //Declarations
    GQuark quark;
    CURL *curl;
    CURLcode res;
    FILE *outfile;
    const gchar *message;
    LwIoProgressCallbackWithData cbwdata;
    gboolean is_cancelled;

    //Initializations
    curl = curl_easy_init ();
    outfile = fopen(TARGET_PATH, "wb");
    cbwdata.cb = cb;
    cbwdata.data = data;
    cbwdata.cancellable = cancellable;
    res = 0;

    if (curl != NULL || outfile != NULL)
    {
      curl_easy_setopt(curl, CURLOPT_URL, SOURCE_PATH);
      curl_easy_setopt(curl, CURLOPT_WRITEDATA, outfile);
      curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, _libcurl_write_func);
      curl_easy_setopt(curl, CURLOPT_READFUNCTION, _libcurl_read_func);

      if (cb != NULL)
      {
        curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0L);
        curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, _libcurl_update_progress);
        curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, &cbwdata);
      }

      res = curl_easy_perform(curl);
    }
     
    fclose(outfile);
    curl_easy_cleanup(curl);

    is_cancelled = (cancellable != NULL && g_cancellable_is_cancelled (cancellable));
    if (is_cancelled) return 1;

    if (res != 0 && is_cancelled == FALSE)
    {
      g_remove (TARGET_PATH);

      if (error != NULL) {
        message = gettext(curl_easy_strerror(res));
        quark = g_quark_from_string (LW_IO_ERROR);
        *error = g_error_new_literal (quark, LW_IO_DOWNLOAD_ERROR, message);
      }
    }

  curl_global_cleanup ();

    return (res == 0);
}
static guint
clearlooks_rc_style_parse (GtkRcStyle *rc_style,
                           GtkSettings  *settings,
                           GScanner   *scanner)
{
	static GQuark scope_id = 0;
	ClearlooksRcStyle *clearlooks_style = CLEARLOOKS_RC_STYLE (rc_style);

	guint old_scope;
	guint token;

	/* Set up a new scope in this scanner. */

	if (!scope_id)
	   scope_id = g_quark_from_string("clearlooks_theme_engine");

	/* If we bail out due to errors, we *don't* reset the scope, so the
	* error messaging code can make sense of our tokens.
	*/
	old_scope = g_scanner_set_scope(scanner, scope_id);

	/* Now check if we already added our symbols to this scope
	* (in some previous call to clearlooks_rc_style_parse for the
	* same scanner.
	*/
	if (!g_scanner_lookup_symbol(scanner, clearlooks_rc_symbols)) {
		gchar *current_symbol = clearlooks_rc_symbols;
		gint i = G_TOKEN_LAST + 1;

		/* Add our symbols */
		while ((current_symbol[0] != '\0') && (i < TOKEN_LAST)) {
			g_scanner_scope_add_symbol(scanner, scope_id, current_symbol, GINT_TO_POINTER (i));

			current_symbol += strlen(current_symbol) + 1;
			i++;
		}
		g_assert (i == TOKEN_LAST && current_symbol[0] == '\0');
	}

	/* We're ready to go, now parse the top level */

	token = g_scanner_peek_next_token(scanner);
	while (token != G_TOKEN_RIGHT_CURLY)
	{
		switch (token)
		{
			case TOKEN_FOCUSCOLOR:
				token = clearlooks_gtk2_rc_parse_color (settings, scanner, rc_style, &clearlooks_style->focus_color);
				clearlooks_style->flags |= CL_FLAG_FOCUS_COLOR;
				break;
			case TOKEN_SCROLLBARCOLOR:
				token = clearlooks_gtk2_rc_parse_color (settings, scanner, rc_style, &clearlooks_style->scrollbar_color);
				clearlooks_style->flags |= CL_FLAG_SCROLLBAR_COLOR;
				break;
			case TOKEN_COLORIZESCROLLBAR:
				token = clearlooks_gtk2_rc_parse_boolean (settings, scanner, &clearlooks_style->colorize_scrollbar);
				clearlooks_style->flags |= CL_FLAG_COLORIZE_SCROLLBAR;
				break;
			case TOKEN_CONTRAST:
				token = clearlooks_gtk2_rc_parse_double (settings, scanner, &clearlooks_style->contrast);
				clearlooks_style->flags |= CL_FLAG_CONTRAST;
				break;
			case TOKEN_RELIEFSTYLE:
				token = clearlooks_gtk2_rc_parse_int (settings, scanner, &clearlooks_style->reliefstyle);
				clearlooks_style->flags |= CL_FLAG_RELIEFSTYLE;
				break;
			case TOKEN_MENUBARSTYLE:
				token = clearlooks_gtk2_rc_parse_int (settings, scanner, &clearlooks_style->menubarstyle);
				clearlooks_style->flags |= CL_FLAG_MENUBARSTYLE;
				break;
			case TOKEN_TOOLBARSTYLE:
				token = clearlooks_gtk2_rc_parse_int (settings, scanner, &clearlooks_style->toolbarstyle);
				clearlooks_style->flags |= CL_FLAG_TOOLBARSTYLE;
				break;
			case TOKEN_ANIMATION:
				token = clearlooks_gtk2_rc_parse_boolean (settings, scanner, &clearlooks_style->animation);
				clearlooks_style->flags |= CL_FLAG_ANIMATION;
				break;
			case TOKEN_STYLE:
				token = clearlooks_gtk2_rc_parse_style (settings, scanner, &clearlooks_style->style);
				clearlooks_style->flags |= CL_FLAG_STYLE;
				break;
			case TOKEN_RADIUS:
				token = clearlooks_gtk2_rc_parse_double (settings, scanner, &clearlooks_style->radius);
				clearlooks_style->flags |= CL_FLAG_RADIUS;
				break;
			case TOKEN_HINT:
				token = ge_rc_parse_hint (scanner, &clearlooks_style->hint);
				clearlooks_style->flags |= CL_FLAG_HINT;
				break;
			case TOKEN_DISABLE_FOCUS:
				token = clearlooks_gtk2_rc_parse_boolean (settings, scanner, &clearlooks_style->disable_focus);
				clearlooks_style->flags |= CL_FLAG_DISABLE_FOCUS;
				break;

			/* stuff to ignore */
			case TOKEN_SUNKENMENU:
				token = clearlooks_gtk2_rc_parse_dummy (settings, scanner, "sunkenmenu");
				break;
			case TOKEN_PROGRESSBARSTYLE:
				token = clearlooks_gtk2_rc_parse_dummy (settings, scanner, "progressbarstyle");
				break;
			case TOKEN_MENUITEMSTYLE:
				token = clearlooks_gtk2_rc_parse_dummy (settings, scanner, "menuitemstyle");
				break;
			case TOKEN_LISTVIEWITEMSTYLE:
				token = clearlooks_gtk2_rc_parse_dummy (settings, scanner, "listviewitemstyle");
				break;

			default:
				g_scanner_get_next_token(scanner);
				token = G_TOKEN_RIGHT_CURLY;
				break;
		}

		if (token != G_TOKEN_NONE)
			return token;

		token = g_scanner_peek_next_token(scanner);
	}

	g_scanner_get_next_token(scanner);

	g_scanner_set_scope(scanner, old_scope);

	return G_TOKEN_NONE;
}
Esempio n. 15
0
static void
accel_edited_callback (GtkCellRendererAccel *cell,
                       gchar                *path_string,
                       guint                 keyval,
                       GdkModifierType       mask,
                       guint                 hardware_keycode,
                       GtkTreeView          *view)
{
	GtkTreeModel *model;
	GtkTreePath *path;
	GtkTreeIter iter;
	KeyEntry *ke;
	GtkAccelGroupEntry *entries;
	guint n_entries;
	char *str;

	model = gtk_tree_view_get_model (view);

	path = gtk_tree_path_new_from_string (path_string);
	if (!path)
		return;

	if (!gtk_tree_model_get_iter (model, &iter, path))
	{
		gtk_tree_path_free (path);
		return;
	}
	gtk_tree_path_free (path);

	gtk_tree_model_get (model, &iter, KEYVAL_COLUMN, &ke, -1);

	/* sanity check */
	if (ke == NULL)
		return;

	/* Check if we already have an entry using this accel */
	entries = gtk_accel_group_query (notification_group, keyval, mask, &n_entries);
	if (n_entries > 0)
	{
		if (entries[0].accel_path_quark != g_quark_from_string (ke->accel_path))
		{
			GtkWidget *dialog;
			char *name;
			KeyEntry *other_key;

			name = gtk_accelerator_get_label (keyval, mask);
			other_key = entries[0].closure->data;
			g_assert (other_key);

			dialog =
			    gtk_message_dialog_new (GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (view))),
			                            GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL,
			                            GTK_MESSAGE_WARNING,
			                            GTK_BUTTONS_OK,
			                            _("The shortcut key “%s” is already bound to the “%s” action"),
			                            name,

other_key->user_visible_name ? _(other_key->user_visible_name) : other_key->gsettings_key);
			g_free (name);

			g_signal_connect (dialog, "response", G_CALLBACK (gtk_widget_destroy), NULL);
			gtk_window_present (GTK_WINDOW (dialog));
		}

		return;
	}

	str = binding_name (keyval, mask);

	_terminal_debug_print (TERMINAL_DEBUG_ACCELS,
	                       "Edited path %s keyval %s, setting GSettings to %s\n",
	                       ke->accel_path,
	                       gdk_keyval_name (keyval) ? gdk_keyval_name (keyval) : "null",
	                       str);
#ifdef MATE_ENABLE_DEBUG
	_TERMINAL_DEBUG_IF (TERMINAL_DEBUG_ACCELS)
	{
		GtkAccelKey old_key;

		if (gtk_accel_map_lookup_entry (ke->accel_path, &old_key))
		{
			_terminal_debug_print (TERMINAL_DEBUG_ACCELS,
			                       "  Old entry of path %s is keyval %s mask %x\n",
			                       ke->accel_path, gdk_keyval_name (old_key.accel_key), old_key.accel_mods);
		}
		else
		{
			_terminal_debug_print (TERMINAL_DEBUG_ACCELS,
			                       "  Failed to look up the old entry of path %s\n",
			                       ke->accel_path);
		}
	}
#endif

	g_settings_set_string (settings_keybindings,
	                       ke->gsettings_key,
	                       str);
	g_free (str);
}
Esempio n. 16
0
static gboolean
_g_dbus_error_decode_gerror (const gchar *dbus_name,
                             GQuark      *out_error_domain,
                             gint        *out_error_code)
{
  gboolean ret;
  guint n;
  GString *s;
  gchar *domain_quark_string;

  ret = FALSE;
  s = NULL;

  if (g_str_has_prefix (dbus_name, "org.gtk.GDBus.UnmappedGError.Quark._"))
    {
      s = g_string_new (NULL);

      for (n = sizeof "org.gtk.GDBus.UnmappedGError.Quark._" - 1;
           dbus_name[n] != '.' && dbus_name[n] != '\0';
           n++)
        {
          if (g_ascii_isalnum (dbus_name[n]))
            {
              g_string_append_c (s, dbus_name[n]);
            }
          else if (dbus_name[n] == '_')
            {
              guint nibble_top;
              guint nibble_bottom;

              n++;

              nibble_top = dbus_name[n];
              if (nibble_top >= '0' && nibble_top <= '9')
                nibble_top -= '0';
              else if (nibble_top >= 'a' && nibble_top <= 'f')
                nibble_top -= ('a' - 10);
              else
                goto not_mapped;

              n++;

              nibble_bottom = dbus_name[n];
              if (nibble_bottom >= '0' && nibble_bottom <= '9')
                nibble_bottom -= '0';
              else if (nibble_bottom >= 'a' && nibble_bottom <= 'f')
                nibble_bottom -= ('a' - 10);
              else
                goto not_mapped;

              g_string_append_c (s, (nibble_top<<4) | nibble_bottom);
            }
          else
            {
              goto not_mapped;
            }
        }

      if (!g_str_has_prefix (dbus_name + n, ".Code"))
        goto not_mapped;

      domain_quark_string = g_string_free (s, FALSE);
      s = NULL;

      if (out_error_domain != NULL)
        *out_error_domain = g_quark_from_string (domain_quark_string);
      g_free (domain_quark_string);

      if (out_error_code != NULL)
        *out_error_code = atoi (dbus_name + n + sizeof ".Code" - 1);

      ret = TRUE;
    }

 not_mapped:

  if (s != NULL)
    g_string_free (s, TRUE);

  return ret;
}
Esempio n. 17
0
static guint
dwerg_rc_style_parse(GtkRcStyle *rc_style,
  GtkSettings *settings,
  GScanner* scanner)
{
    static GQuark scope_id = 0;
    DwergRcStyle *theme_data = DWERG_RC_STYLE(rc_style);
    theme_data->shadow_color_from = malloc(sizeof(GdkColor));
    theme_data->shadow_color_to = malloc(sizeof(GdkColor));

    guint old_scope;
    guint token;
    guint i;

    /* setup scope, safe old_scope for crash, define tokens */
    if (!scope_id) 
        scope_id = g_quark_from_string("dwerg_theme_engine");
    old_scope = g_scanner_set_scope(scanner, scope_id);
    if (!g_scanner_lookup_symbol(scanner, theme_symbols[0].name))
    {
        g_scanner_freeze_symbol_table(scanner);
        for (i = 0; i < G_N_ELEMENTS(theme_symbols); i++)
            g_scanner_scope_add_symbol(scanner, scope_id,
              theme_symbols[i].name,
              GINT_TO_POINTER(theme_symbols[i].token));
        g_scanner_thaw_symbol_table(scanner);
    }

    token = g_scanner_peek_next_token(scanner);
    while (token != G_TOKEN_RIGHT_CURLY)
    {
        switch(token)
        {
            case TOKEN_SHADOW_COLOR_FROM:
                g_print("vla\n");
                token = g_scanner_get_next_token(scanner); 
                if (token != TOKEN_SHADOW_COLOR_FROM)
                    return token;
                token = g_scanner_get_next_token(scanner); 
                if (token != G_TOKEN_EQUAL_SIGN)
                    return token;
                token = gtk_rc_parse_color(scanner,
                    theme_data->shadow_color_from);
                g_print("ja lekker\n");
                break;
            case TOKEN_SHADOW_COLOR_TO:
                token = g_scanner_get_next_token(scanner);
                if (token != TOKEN_SHADOW_COLOR_TO)
                    return token;
                token = g_scanner_get_next_token(scanner);
                if (token != G_TOKEN_EQUAL_SIGN)
                    return token;
                token = gtk_rc_parse_color(scanner,
                    theme_data->shadow_color_to);
                break;
            default:
                g_scanner_get_next_token(scanner);
                token = G_TOKEN_RIGHT_CURLY;
                break;
        }
        if (token != G_TOKEN_NONE) {
            g_free(theme_data);
            return token;
        }
        token = g_scanner_peek_next_token(scanner);
    }
    /* on no error reset the scope */
    g_scanner_get_next_token(scanner);
    g_scanner_set_scope(scanner, old_scope);
    return G_TOKEN_NONE;
}
Esempio n. 18
0
GQuark _EscalateUtilErrorQuark() {
  return g_quark_from_string("escalate-util-error-quark");
}
Esempio n. 19
0
gboolean
dates_import_calendar_data_from_file (ECal *cal, gchar *filename, GError **error)
{
  GError *tmp_error = NULL;
  GIOChannel *channel = NULL;
  gchar *line;
  gsize length;
  gint num_comp_imported = 0;

  channel = g_io_channel_new_file (filename, "r", &tmp_error);

  if (tmp_error != NULL)
  {
    g_warning ("Error when opening file: %s", tmp_error->message);
    g_propagate_error (error, tmp_error);
    return FALSE;
  } else {
    GIOStatus status;
    icalparser *parser = icalparser_new ();

    /* set the channel as binary mode and let icalparser_add_line
     * handle encoding */
    g_io_channel_set_encoding (channel, NULL, &tmp_error);
    if (tmp_error != NULL)
    {
      g_warning ("Error when set encoding: %s", tmp_error->message);
      g_propagate_error (error, tmp_error);
      g_io_channel_unref (channel);
      return FALSE;
    }

    /* Read the from the file line by line and until EOF */
    while ((status = g_io_channel_read_line (channel, &line, &length, NULL, &tmp_error))
        == G_IO_STATUS_NORMAL)
    {
      icalcomponent *icomp = NULL;

      /* The parser returns an icalcomponent when it has one */
      icomp = icalparser_add_line (parser, line);
      g_free (line);

    if (icomp)
      {
        gchar *uid = NULL;
        icalcompiter iter;
        icalcomponent *subcomp;

        /* The component is a top-level one and e_cal_create_object only
         * accepts VEVENTs. Iterate through the VEVENTS. */
        iter = icalcomponent_begin_component (icomp, ICAL_VEVENT_COMPONENT);

        while ((subcomp = icalcompiter_deref (&iter)) != NULL) 
        {
          if (!e_cal_create_object (cal, subcomp, &uid, &tmp_error))
          {
            g_warning ("Creation of imported event failed: %s", tmp_error->message);
            g_propagate_error (error, tmp_error);

            if (parser)
              icalparser_free (parser);

            if (icomp)
              icalcomponent_free (icomp);

            if (channel)
              g_io_channel_unref (channel);

            g_free (uid);
            return FALSE;
          }
					
          num_comp_imported ++;
          
          icalcompiter_next (&iter);
          g_free (uid);
        }

        icalcomponent_free (icomp);
      }
    }

    if (parser)
      icalparser_free (parser);

    if (tmp_error != NULL)
    {
      g_warning ("Error when reading from file: %s", tmp_error->message);
      g_propagate_error (error, tmp_error);

      g_io_channel_unref (channel);
      return FALSE;
    }
  }

  if (channel)
    g_io_channel_unref (channel);
  
  if (num_comp_imported > 0)
  {
    return TRUE;
  }
  else 
  {
    *error = g_error_new_literal
      (g_quark_from_string ("Dates"), 1, _("No calendar events found."));
    return FALSE;
  }
}
Esempio n. 20
0
static void
lsq_archive_command_init(LSQArchiveCommand *archive_command)
{
	archive_command->domain = g_quark_from_string("Command");
}
Esempio n. 21
0
static DesktopEntryResultCode
desktop_entry_load (DesktopEntry *entry)
{
  if (strstr (entry->path, "/menu-xdg/"))
    return DESKTOP_ENTRY_LOAD_FAIL_OTHER;
  if (entry->type == DESKTOP_ENTRY_DESKTOP)
    {
      GKeyFile *key_file = NULL;
      DesktopEntryDesktop *entry_desktop = (DesktopEntryDesktop*)entry;
      const char *categories_str;

      entry_desktop->appinfo = g_desktop_app_info_new_from_filename (entry->path);
      if (!G_IS_DESKTOP_APP_INFO (((DesktopEntryDesktop*)entry)->appinfo))
        {
          menu_verbose ("Failed to load \"%s\"\n", entry->path);
          return DESKTOP_ENTRY_LOAD_FAIL_APPINFO;
        }

      categories_str = g_desktop_app_info_get_categories (entry_desktop->appinfo);
      if (categories_str)
        {
          char **categories;
          int i;

          categories = g_strsplit (categories_str, ";", -1);
          entry_desktop->categories = g_new0 (GQuark, g_strv_length (categories) + 1);

          for (i = 0; categories[i]; i++)
            entry_desktop->categories[i] = g_quark_from_string (categories[i]);

          g_strfreev (categories);
        }

      key_file = g_key_file_new ();

      if (!g_key_file_load_from_file (key_file, entry->path, 0, NULL))
        entry_desktop->showin = TRUE;
      else
        entry_desktop->showin = key_file_get_show_in (key_file);

      g_key_file_free (key_file);

      return DESKTOP_ENTRY_LOAD_SUCCESS;
    }
  else if (entry->type == DESKTOP_ENTRY_DIRECTORY)
    {
      GKeyFile *key_file = NULL;
      GError   *error = NULL;
      DesktopEntryResultCode rescode = DESKTOP_ENTRY_LOAD_SUCCESS;

      key_file = g_key_file_new ();

      if (!g_key_file_load_from_file (key_file, entry->path, 0, &error))
        {
          rescode = DESKTOP_ENTRY_LOAD_FAIL_OTHER;
          goto out;
        }

      if (!desktop_entry_load_directory (entry, key_file, &error))
        {
          rescode = DESKTOP_ENTRY_LOAD_FAIL_OTHER;
          goto out;
        }

      rescode = DESKTOP_ENTRY_LOAD_SUCCESS;

    out:
      g_key_file_free (key_file);

      if (rescode == DESKTOP_ENTRY_LOAD_FAIL_OTHER)
        {
          if (error)
            {
              menu_verbose ("Failed to load \"%s\": %s\n", entry->path, error->message);
              g_error_free (error);
            }
          else
            menu_verbose ("Failed to load \"%s\"\n", entry->path);
        }

      return rescode;
    }
  else
    g_assert_not_reached ();

  return DESKTOP_ENTRY_LOAD_FAIL_OTHER;
}
Esempio n. 22
0
static void init() {

  LttvAttributeValue value;
  gboolean retval;
 
  // Global attributes only used for interaction with main() here.
  LttvIAttribute *attributes = LTTV_IATTRIBUTE(lttv_global_attributes());
  
  LTTV_TRACES = g_quark_from_string("traces");
  LTTV_COMPUTATION = g_quark_from_string("computation");
  LTTV_VIEWER_CONSTRUCTORS = g_quark_from_string("viewer_constructors");
  LTTV_REQUESTS_QUEUE = g_quark_from_string("requests_queue");
  LTTV_REQUESTS_CURRENT = g_quark_from_string("requests_current");
  LTTV_NOTIFY_QUEUE = g_quark_from_string("notify_queue");
  LTTV_NOTIFY_CURRENT = g_quark_from_string("notify_current");
  LTTV_COMPUTATION_TRACESET = g_quark_from_string("computation_traceset");
  LTTV_COMPUTATION_TRACESET_CONTEXT =
                        g_quark_from_string("computation_traceset_context");
  LTTV_COMPUTATION_SYNC_POSITION =
                        g_quark_from_string("computation_sync_position");
  LTTV_BEFORE_CHUNK_TRACESET = g_quark_from_string("before_chunk_traceset");
  LTTV_BEFORE_CHUNK_TRACE = g_quark_from_string("before_chunk_trace");
  LTTV_BEFORE_CHUNK_TRACEFILE = g_quark_from_string("before_chunk_tracefile");
  LTTV_AFTER_CHUNK_TRACESET = g_quark_from_string("after_chunk_traceset");
  LTTV_AFTER_CHUNK_TRACE = g_quark_from_string("after_chunk_trace");
  LTTV_AFTER_CHUNK_TRACEFILE = g_quark_from_string("after_chunk_tracefile");
  LTTV_BEFORE_REQUEST = g_quark_from_string("before_request");
  LTTV_AFTER_REQUEST = g_quark_from_string("after_request");
  LTTV_EVENT_HOOK = g_quark_from_string("event_hook");
  LTTV_EVENT_HOOK_BY_ID_CHANNEL = g_quark_from_string("event_hook_by_id_channel");
  LTTV_HOOK_ADDER = g_quark_from_string("hook_adder");
  LTTV_HOOK_REMOVER = g_quark_from_string("hook_remover");
  LTTV_IN_PROGRESS = g_quark_from_string("in_progress");
  LTTV_READY = g_quark_from_string("ready");
  LTTV_LOCK = g_quark_from_string("lock");

  g_debug("GUI init()");

  lttv_option_add("trace", 't', 
      "add a trace to the trace set to analyse", 
      "pathname of the directory containing the trace", 
      LTTV_OPT_STRING, &a_trace, lttv_trace_option, NULL);

  a_live = FALSE;
  lttv_option_add("live", 0,
      "define if the traceset is receiving live informations",
      "",
      LTTV_OPT_NONE, &a_live, NULL, NULL);

  retval= lttv_iattribute_find_by_path(attributes, "hooks/main/before",
    LTTV_POINTER, &value);
  g_assert(retval);
  g_assert((main_hooks = *(value.v_pointer)) != NULL);

  lttv_hooks_add(main_hooks, window_creation_hook, NULL, LTTV_PRIO_DEFAULT);
#ifdef BABEL_CLEANUP
  {
    /* Register state calculator */
    LttvHooks *hook_adder = lttv_hooks_new();
    lttv_hooks_add(hook_adder, lttv_state_save_hook_add_event_hooks, NULL,
                   LTTV_PRIO_DEFAULT);
    lttv_hooks_add(hook_adder, lttv_state_hook_add_event_hooks, NULL,
                   LTTV_PRIO_DEFAULT);
    LttvHooks *hook_remover = lttv_hooks_new();
    lttv_hooks_add(hook_remover, lttv_state_save_hook_remove_event_hooks,
                                    NULL, LTTV_PRIO_DEFAULT);
    lttv_hooks_add(hook_remover, lttv_state_hook_remove_event_hooks,
                                    NULL, LTTV_PRIO_DEFAULT);
    /* Add state computation background hook adder to attributes */
    lttvwindowtraces_register_computation_hooks(g_quark_from_string("state"),
        NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
        hook_adder, hook_remover);
  }

  {
    /* Register statistics calculator */
    LttvHooks *hook_adder = lttv_hooks_new();
    lttv_hooks_add(hook_adder, lttv_stats_hook_add_event_hooks, NULL,
                   LTTV_PRIO_DEFAULT);
    lttv_hooks_add(hook_adder, lttv_state_hook_add_event_hooks, NULL,
                   LTTV_PRIO_DEFAULT);
    LttvHooks *hook_remover = lttv_hooks_new();
    lttv_hooks_add(hook_remover, lttv_stats_hook_remove_event_hooks,
                                    NULL, LTTV_PRIO_DEFAULT);
    lttv_hooks_add(hook_remover, lttv_state_hook_remove_event_hooks,
                                    NULL, LTTV_PRIO_DEFAULT);
    LttvHooks *after_request = lttv_hooks_new();
    lttv_hooks_add(after_request, lttv_stats_sum_traceset_hook, NULL,
        LTTV_PRIO_DEFAULT);
    /* Add state computation background hook adder to attributes */
    lttvwindowtraces_register_computation_hooks(g_quark_from_string("stats"),
        NULL, NULL, NULL, NULL, NULL, NULL, NULL, 
        after_request, NULL, NULL,
        hook_adder, hook_remover);
  }
#endif /* BABEL_CLEANUP */
}
Esempio n. 23
0
static void
gwy_app_file_chooser_add_type_list(GwyAppFileChooser *chooser)
{
    GtkWidget *vbox, *scwin;
    GtkTreeView *treeview;
    GtkFileChooserAction action;
    GtkRequisition req;
    GtkTreeSelection *selection;
    GtkTreeViewColumn *column;
    GtkCellRenderer *renderer;
    GtkListStore *store;
    GtkTreeIter iter;
    gboolean expanded = FALSE;
    gboolean filter = FALSE;
    gchar *key;

    g_object_get(chooser, "action", &action, NULL);

    key = g_strconcat(chooser->prefix, "/type", NULL);
    chooser->type_key = g_quark_from_string(key);
    g_free(key);

    store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING);
    gtk_list_store_append(store, &iter);
    switch (action) {
    case GTK_FILE_CHOOSER_ACTION_SAVE:
        gtk_list_store_set(store, &iter,
                           COLUMN_FILETYPE, "",
                           COLUMN_LABEL, _("Automatic by extension"),
                           -1);
        gwy_app_file_chooser_add_types(store, GWY_FILE_OPERATION_SAVE, FALSE);
        gwy_app_file_chooser_add_types(store, GWY_FILE_OPERATION_EXPORT, FALSE);
        break;

    case GTK_FILE_CHOOSER_ACTION_OPEN:
        gtk_list_store_set(store, &iter,
                           COLUMN_FILETYPE, "",
                           COLUMN_LABEL, _("Automatically detected"),
                           -1);
        gwy_app_file_chooser_add_types(store, GWY_FILE_OPERATION_LOAD, TRUE);
        break;

    default:
        g_assert_not_reached();
        break;
    }

    chooser->expander = gtk_expander_new(NULL);
    gtk_expander_set_use_underline(GTK_EXPANDER(chooser->expander), TRUE);
    gtk_file_chooser_set_extra_widget(GTK_FILE_CHOOSER(chooser),
                                      chooser->expander);
    key = g_strconcat(chooser->prefix, "/expanded", NULL);
    gwy_container_gis_boolean_by_name(gwy_app_settings_get(), key, &expanded);
    g_free(key);
    gtk_expander_set_expanded(GTK_EXPANDER(chooser->expander), expanded);
    g_signal_connect_swapped(chooser->expander, "notify::expanded",
                             G_CALLBACK(gwy_app_file_chooser_expanded),
                             chooser);

    vbox = gtk_vbox_new(FALSE, 4);
    gtk_container_add(GTK_CONTAINER(chooser->expander), vbox);

    scwin = gtk_scrolled_window_new(NULL, NULL);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scwin),
                                   GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
    gtk_box_pack_start(GTK_BOX(vbox), scwin, TRUE, TRUE, 0);

    chooser->type_list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store));
    treeview = GTK_TREE_VIEW(chooser->type_list);
    g_object_unref(store);
    gtk_tree_view_set_headers_visible(treeview, FALSE);
    gtk_container_add(GTK_CONTAINER(scwin), chooser->type_list);

    column = gtk_tree_view_column_new();
    gtk_tree_view_append_column(treeview, column);
    renderer = gtk_cell_renderer_text_new();
    gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(column), renderer, TRUE);
    gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(column), renderer,
                                  "text", COLUMN_LABEL);

    selection = gtk_tree_view_get_selection(treeview);
    gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
    g_signal_connect_swapped(selection, "changed",
                             G_CALLBACK(gwy_app_file_chooser_type_changed),
                             chooser);

    if (action == GTK_FILE_CHOOSER_ACTION_OPEN) {
        chooser->filter_enable
            = gtk_check_button_new_with_mnemonic(_("Show only loadable files"));
        key = g_strconcat(chooser->prefix, "/filter", NULL);
        gwy_container_gis_boolean_by_name(gwy_app_settings_get(), key, &filter);
        g_free(key);
        gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(chooser->filter_enable),
                                     filter);
        gtk_box_pack_start(GTK_BOX(vbox), chooser->filter_enable,
                           FALSE, FALSE, 0);
        g_signal_connect_swapped(chooser->filter_enable, "toggled",
                                 G_CALLBACK(gwy_app_file_chooser_filter_toggled),
                                 chooser);
        gwy_app_file_chooser_filter_toggled(chooser,
                                            GTK_TOGGLE_BUTTON(chooser->filter_enable));
    }

    /* Give it some reasonable size. FIXME: hack. */
    gtk_widget_show_all(vbox);
    gtk_widget_size_request(scwin, &req);
    gtk_widget_set_size_request(scwin, -1, req.height + 100);

    gwy_app_file_chooser_select_type(chooser);
    gwy_app_file_chooser_type_changed(chooser, selection);
}
Esempio n. 24
0
/* Returns a structure with information we will use to rendering given the
 * #PangoFont. This is computed once per font and cached for later retrieval.
 */
static ThaiFontInfo *
thai_x_get_font_info (PangoFont *font)
{
  static const char *charsets[] = {
    "tis620-2",
    "tis620-1",
    "tis620-0",
    "xtis620.2529-1",
    "xtis-0",
    "tis620.2533-1",
    "tis620.2529-1",
    "iso8859-11",
    "iso10646-1",
  };

  static const int charset_types[] = {
    THAI_FONT_TIS_WIN,
    THAI_FONT_TIS_MAC,
    THAI_FONT_TIS,
    THAI_FONT_XTIS,
    THAI_FONT_XTIS,
    THAI_FONT_TIS,
    THAI_FONT_TIS,
    THAI_FONT_TIS,
    THAI_FONT_ISO10646
  };
  
  ThaiFontInfo *font_info;
  GQuark info_id = g_quark_from_string ("thai-font-info");
  
  font_info = g_object_get_qdata (G_OBJECT (font), info_id);

  if (!font_info)
    {
      /* No cached information not found, so we need to compute it
       * from scratch
       */
      PangoXSubfont *subfont_ids;
      gint *subfont_charsets;
      gint n_subfonts, i;

      font_info = g_new (ThaiFontInfo, 1);
      font_info->font = font;
      font_info->font_set = THAI_FONT_NONE;
      
      g_object_set_qdata_full (G_OBJECT (font), info_id, font_info, (GDestroyNotify)g_free);
      
      n_subfonts = pango_x_list_subfonts (font, (char **)charsets, G_N_ELEMENTS (charsets),
					  &subfont_ids, &subfont_charsets);

      for (i=0; i < n_subfonts; i++)
	{
	  ThaiFontSet font_set = charset_types[subfont_charsets[i]];
	  
	  if (font_set != THAI_FONT_ISO10646 ||
	      pango_x_has_glyph (font, PANGO_X_MAKE_GLYPH (subfont_ids[i], 0xe01)))
	    {
	      font_info->font_set = font_set;
	      font_info->subfont = subfont_ids[i];

	      break;
	    }
	}

      g_free (subfont_ids);
      g_free (subfont_charsets);

      font_info->make_glyph = thai_x_make_glyph;
      font_info->make_unknown_glyph = thai_x_make_unknown_glyph;
      font_info->has_glyph = thai_x_has_glyph;
    }

  return font_info;
}
Esempio n. 25
0
static guint
mgicchikn_rc_style_parse (GtkRcStyle * rc_style,
						  GtkSettings * settings,
						  GScanner * scanner)
{
	MgicChiknRcStyle *style;
	static GQuark scope = 0;
	GQuark old_scope;
	guint token;
	gint i;

	g_return_val_if_fail (rc_style != NULL, G_TOKEN_NONE);
	g_return_val_if_fail (MGICCHIKN_IS_RC_STYLE (rc_style), G_TOKEN_NONE);
	style = MGICCHIKN_RC_STYLE (rc_style);
	if (!scope)
		scope = g_quark_from_string ("theme_engine");
	old_scope = g_scanner_set_scope (scanner, scope);
	/* If we don't have the symbol table inside scanner, put it in there */
	if (!g_scanner_lookup_symbol (scanner, symbols[0].name))
	{
		for (i = 0; i < G_N_ELEMENTS (symbols); i++)
		{
			g_scanner_scope_add_symbol (scanner, scope,
										symbols[i].name,
										GUINT_TO_POINTER (symbols[i].token));
		}
	}

	token = g_scanner_peek_next_token (scanner);
	while (token != G_TOKEN_RIGHT_CURLY)
	{
		switch (token)
		{
		case MGICCHIKN_TOKEN_STOCK_IMAGE_TRANSPARENCY:
			token = mgicchikn_rc_parse_stock_image_transparency (style, scanner);
			break;
		case MGICCHIKN_TOKEN_STOCK_IMAGE_SATURATION:
			token = mgicchikn_rc_parse_stock_image_saturation (style, scanner);
			break;
		case MGICCHIKN_TOKEN_STOCK_IMAGE_BRIGHTNESS:
			token = mgicchikn_rc_parse_stock_image_brightness (style, scanner);
			break;
		case MGICCHIKN_TOKEN_SHADOW:
			token = mgicchikn_rc_parse_shadow (style, scanner);
			break;
		case MGICCHIKN_TOKEN_SHADOW_WIDTH:
			token = mgicchikn_rc_parse_shadow_width (style, scanner);
			break;
		case MGICCHIKN_TOKEN_GRIPPY_STYLE:
			token = mgicchikn_rc_parse_grippy_style (style, scanner);
			break;
		case MGICCHIKN_TOKEN_FONT_SHADOW:
			token = mgicchikn_rc_parse_font_shadow (style, scanner);
			break;
		case MGICCHIKN_TOKEN_FONT_UNDERLINE:
			token = mgicchikn_rc_parse_font_underline (style, scanner);
			break;
		case MGICCHIKN_TOKEN_CHECK_IMAGE:
			token = mgicchikn_rc_parse_check_image (style, settings, scanner);
			break;
		case MGICCHIKN_TOKEN_RADIO_IMAGE:
			token = mgicchikn_rc_parse_radio_image (style, settings, scanner);
			break;
		default:
			break;
		}

		if (token != G_TOKEN_NONE)
			return token;
		token = g_scanner_peek_next_token (scanner);
	}

	g_scanner_get_next_token (scanner);
	g_scanner_set_scope (scanner, old_scope);
	return G_TOKEN_NONE;
}
void
ags_test_init(int *argc, char ***argv,
	      gchar *conf_str)
{
  AgsConfig *config;

  gchar *filename;

  gboolean single_thread_enabled;
  gboolean builtin_theme_disabled;
  guint i;

#ifdef AGS_WITH_RT
  struct sched_param param;
  struct rlimit rl;
#endif
  struct passwd *pw;

  gchar *wdir, *config_file;
  gchar *rc_filename;
  gchar *base_dir;
  gchar *str, *data_dir;
  gchar path[PATH_MAX];

  uint32_t size = sizeof(path);
  uid_t uid;
  int result;

  const rlim_t kStackSize = 64L * 1024L * 1024L;   // min stack size = 64 Mb

  base_dir = strdup(SRCDIR);
  printf("base dir %s\n", base_dir);
  
  /* set some environment variables */
  sprintf(path, "%s/gsequencer.share/styles",
	  base_dir);
  data_dir = realpath(path,
		      NULL);
  str = malloc(PATH_MAX * sizeof(gchar));
  sprintf(str,
	  "AGS_RC_FILENAME=%s/ags.rc",
	  data_dir);
  putenv(str);

  sprintf(path, "%s/gsequencer.share/images",
	  base_dir);
  data_dir = realpath(path,
		      NULL);
  str = malloc(PATH_MAX * sizeof(gchar));
  sprintf(str,
	  "AGS_ANIMATION_FILENAME=%s/ags_supermoon-800x450.png",
	  data_dir);
  putenv(str);

  sprintf(path, "%s/gsequencer.share/images",
	  base_dir);
  data_dir = realpath(path,
		      NULL);
  str = malloc(PATH_MAX * sizeof(gchar));
  sprintf(str,
	  "AGS_LOGO_FILENAME=%s/ags.png",
	  data_dir);
  putenv(str);

  sprintf(path, "%s",
	  base_dir);
  data_dir = realpath(path,
		      NULL);
  str = malloc(PATH_MAX * sizeof(gchar));
  sprintf(str,
	  "AGS_LICENSE_FILENAME=%s/COPYING",
	  data_dir);
  putenv(str);

  /* gettext */
  setlocale(LC_ALL, "");
  bindtextdomain(PACKAGE, LOCALEDIR);
  textdomain(PACKAGE);

  /* parameters */
  single_thread_enabled = FALSE;
  builtin_theme_disabled = FALSE;
  
  //  g_log_set_fatal_mask("GLib", // "Gtk" , // 
  //		       G_LOG_LEVEL_CRITICAL); // G_LOG_LEVEL_WARNING

#ifdef AGS_WITH_RT
  result = getrlimit(RLIMIT_STACK, &rl);

  /* set stack size 64M */
  if(result == 0){
    if(rl.rlim_cur < kStackSize){
      rl.rlim_cur = kStackSize;
      result = setrlimit(RLIMIT_STACK, &rl);

      if(result != 0){
	//TODO:JK
      }
    }
  }

  param.sched_priority = GSEQUENCER_RT_PRIORITY;
      
  if(sched_setscheduler(0, SCHED_FIFO, &param) == -1) {
    perror("sched_setscheduler failed");
  }
#endif

  //#ifdef AGS_WITH_X11
  XInitThreads();
  //#endif
  
  /* parse command line parameter */
  filename = NULL;

  for(i = 0; i < argc[0]; i++){
    if(!strncmp(argv[0][i], "--help", 7)){
      printf("GSequencer is an audio sequencer and notation editor\n\n");

      printf("Usage:\n\t%s\n\t%s\n\t%s\n\t%s\n\t%s\n\t%s\n\n",
	     "Report bugs to <[email protected]>\n",
	     "--filename file     open file",
	     "--single-thread     run in single thread mode",
	     "--no-builtin-theme  disable built-in theme",
	     "--help              display this help and exit",
	     "--version           output version information and exit");
      
      exit(0);
    }else if(!strncmp(argv[0][i], "--version", 10)){
      printf("GSequencer %s\n\n", AGS_VERSION);
      
      printf("%s\n%s\n%s\n\n",
	     "Copyright (C) 2005-2017 Joël Krähemann",
	     "This is free software; see the source for copying conditions.  There is NO",
	     "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.");
      
      printf("Written by Joël Krähemann\n");

      exit(0);
    }else if(!strncmp(argv[0][i], "--single-thread", 16)){
      single_thread_enabled = TRUE;
    }else if(!strncmp(argv[0][i], "--no-builtin-theme", 19)){
      builtin_theme_disabled = TRUE;
    }else if(!strncmp(argv[0][i], "--filename", 11)){
      filename = *argv[i + 1];
      i++;
    }
  }

  uid = getuid();
  pw = getpwuid(uid);
    
  /* parse rc file */
  if(!builtin_theme_disabled){
    rc_filename = g_strdup_printf("%s/%s/ags.rc",
				  pw->pw_dir,
				  AGS_DEFAULT_DIRECTORY);

    if(!g_file_test(rc_filename,
		    G_FILE_TEST_IS_REGULAR)){
      g_free(rc_filename);

#ifdef AGS_RC_FILENAME
      rc_filename = g_strdup(AGS_RC_FILENAME);
#else
      if((rc_filename = getenv("AGS_RC_FILENAME")) == NULL){
	rc_filename = g_strdup_printf("%s%s",
				      DESTDIR,
				      "/gsequencer/styles/ags.rc");
      }else{
	rc_filename = g_strdup(rc_filename);
      }
#endif
    }
  
    gtk_rc_parse(rc_filename);
    g_free(rc_filename);
  }
  
  /**/
  LIBXML_TEST_VERSION;

  ags_gui_init(argc, argv);
  
  gtk_init(argc, argv);

  if(!builtin_theme_disabled){
    g_object_set(gtk_settings_get_default(),
		 "gtk-theme-name", "Raleigh",
		 NULL);
    g_signal_handlers_block_matched(gtk_settings_get_default(),
				    G_SIGNAL_MATCH_DETAIL,
				    g_signal_lookup("set-property",
						    GTK_TYPE_SETTINGS),
				    g_quark_from_string("gtk-theme-name"),
				    NULL,
				    NULL,
				    NULL);
  }
  
#ifdef AGS_WITH_LIBINSTPATCH
  ipatch_init();
#endif
  
  /* setup */
  wdir = g_strdup_printf("%s/%s",
			 pw->pw_dir,
			 AGS_DEFAULT_DIRECTORY);

  config_file = g_strdup_printf("%s/%s",
				wdir,
				AGS_DEFAULT_CONFIG);

  config = ags_config_get_instance();

  if(conf_str != NULL){
    ags_config_load_from_data(config,
			      conf_str,
			      strlen(conf_str));
  }else{
    ags_config_load_from_file(config,
			      config_file);
  }
  
  g_free(wdir);
  g_free(config_file);  
}
Esempio n. 27
0
static void
gxi_check_file (GncXmlImportData *data)
{
    if (!data->encodings)
    {
        gboolean is_utf8;
        const gchar *locale_enc;
        gchar *enc_string, **enc_array, **enc_cursor;
        gpointer enc_ptr;
        GIConv iconv;

        /* first locale encoding */
        is_utf8 = g_get_charset (&locale_enc);
        enc_string = g_ascii_strup (locale_enc, -1);
        enc_ptr = GUINT_TO_POINTER (g_quark_from_string (enc_string));
        g_free (enc_string);
        data->encodings = g_list_append (NULL, enc_ptr);

        /* add utf-8 */
        if (!is_utf8)
        {
            enc_ptr = GUINT_TO_POINTER (g_quark_from_string ("UTF-8"));
            data->encodings = g_list_append (data->encodings, enc_ptr);
        }

        /* Translators: Please insert encodings here that are typically used in your
         * locale, separated by spaces. No need for ASCII or UTF-8, check `locale -m`
         * for assistance with spelling. */
        enc_array = g_strsplit (_("ISO-8859-1 KOI8-U"), " ", 0);

        /* loop through typical encodings */
        for (enc_cursor = enc_array; *enc_cursor; enc_cursor++)
        {
            if (!**enc_cursor) continue;
            enc_string = g_ascii_strup (*enc_cursor, -1);
            enc_ptr = GUINT_TO_POINTER (g_quark_from_string (enc_string));

            if (!g_list_find (data->encodings, enc_ptr))
            {
                /* test whether we like this encoding */
                iconv = g_iconv_open ("UTF-8", enc_string);
                if (iconv != (GIConv) - 1)
                    /* we like it */
                    data->encodings = g_list_append (data->encodings, enc_ptr);
                g_iconv_close (iconv);
            }
            g_free (enc_string);
        }
        g_strfreev (enc_array);
    }

    if (!data->default_encoding)
    {
        /* choose top one */
        data->default_encoding = GPOINTER_TO_UINT (data->encodings->data);
    }

    if (!data->choices)
    {
        data->choices = g_hash_table_new_full (g_str_hash, g_str_equal,
                                               g_free, (GDestroyNotify) conv_free);
    }

    gxi_ambiguous_info_destroy (data);

    /* analyze file */
    data->n_impossible = gnc_xml2_find_ambiguous (
                             data->filename, data->encodings, &data->unique, &data->ambiguous_ht, NULL);

    if (data->n_impossible != -1)
    {
        /* sort ambiguous words */
        g_hash_table_foreach (data->ambiguous_ht, (GHFunc)ambiguous_list_insert,
                              data);
        gxi_sort_ambiguous_list (data);
    }
}
/**
 * _rb_player_emit_event:
 * @player: a #RBPlayer implementation
 * @stream_data: data associated with the stream
 * @name: event name
 * @data: event data
 *
 * Emits the 'event' signal for a stream.
 * To be used by implementations only.
 */
void
_rb_player_emit_event (RBPlayer *player, gpointer stream_data, const char *name, gpointer data)
{
	g_signal_emit (player, signals[EVENT], g_quark_from_string (name), stream_data, data);
}
Esempio n. 29
0
/**
 * {@inheritDoc}
 */
static void plank_items_dock_item_preferences_real_verify (PlankServicesPreferences* base, const gchar* prop) {
	PlankItemsDockItemPreferences * self;
	const gchar* _tmp0_ = NULL;
	const gchar* _tmp1_ = NULL;
	GQuark _tmp3_ = 0U;
	static GQuark _tmp2_label0 = 0;
	GError * _inner_error_ = NULL;
	self = (PlankItemsDockItemPreferences*) base;
	g_return_if_fail (prop != NULL);
	_tmp0_ = prop;
	_tmp1_ = _tmp0_;
	_tmp3_ = (NULL == _tmp1_) ? 0 : g_quark_from_string (_tmp1_);
	if (_tmp3_ == ((0 != _tmp2_label0) ? _tmp2_label0 : (_tmp2_label0 = g_quark_from_static_string ("Launcher")))) {
		switch (0) {
			default:
			{
				const gchar* _tmp4_ = NULL;
				gboolean _tmp5_ = FALSE;
				_tmp4_ = self->priv->_Launcher;
				_tmp5_ = g_str_has_prefix (_tmp4_, "/");
				if (_tmp5_) {
					{
						gchar* _tmp6_ = NULL;
						const gchar* _tmp7_ = NULL;
						gchar* _tmp8_ = NULL;
						_tmp7_ = self->priv->_Launcher;
						_tmp8_ = g_filename_to_uri (_tmp7_, NULL, &_inner_error_);
						_tmp6_ = _tmp8_;
						if (_inner_error_ != NULL) {
							if (_inner_error_->domain == G_CONVERT_ERROR) {
								goto __catch28_g_convert_error;
							}
							g_critical ("file %s: line %d: unexpected error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
							g_clear_error (&_inner_error_);
							return;
						}
						plank_items_dock_item_preferences_set_Launcher (self, _tmp6_);
						_g_free0 (_tmp6_);
					}
					goto __finally28;
					__catch28_g_convert_error:
					{
						GError* e = NULL;
						GError* _tmp9_ = NULL;
						const gchar* _tmp10_ = NULL;
						e = _inner_error_;
						_inner_error_ = NULL;
						_tmp9_ = e;
						_tmp10_ = _tmp9_->message;
						g_warning ("DockItemPreferences.vala:74: %s", _tmp10_);
						_g_error_free0 (e);
					}
					__finally28:
					if (_inner_error_ != NULL) {
						g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
						g_clear_error (&_inner_error_);
						return;
					}
				}
				break;
			}
		}
	}
}
Esempio n. 30
0
static void
nautilus_column_set_property (GObject      *object,
                              guint         param_id,
                              const GValue *value,
                              GParamSpec   *pspec)
{
    NautilusColumn *column;

    column = NAUTILUS_COLUMN (object);

    switch (param_id)
    {
        case PROP_NAME:
        {
            g_free (column->name);
            column->name = g_strdup (g_value_get_string (value));
            g_object_notify (object, "name");
        }
        break;

        case PROP_ATTRIBUTE:
        {
            column->attribute = g_quark_from_string (g_value_get_string (value));
            g_object_notify (object, "attribute");
            g_object_notify (object, "attribute_q");
        }
        break;

        case PROP_LABEL:
        {
            g_free (column->label);
            column->label = g_strdup (g_value_get_string (value));
            g_object_notify (object, "label");
        }
        break;

        case PROP_DESCRIPTION:
        {
            g_free (column->description);
            column->description = g_strdup (g_value_get_string (value));
            g_object_notify (object, "description");
        }
        break;

        case PROP_XALIGN:
        {
            column->xalign = g_value_get_float (value);
            g_object_notify (object, "xalign");
        }
        break;

        case PROP_DEFAULT_SORT_ORDER:
        {
            column->default_sort_order = g_value_get_enum (value);
            g_object_notify (object, "default-sort-order");
        }
        break;

        default:
        {
            G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
        }
        break;
    }
}