Example #1
0
static void
gtkutil_get_number_response (GtkDialog *dialog, gint arg1, gpointer spin)
{
	void (*callback) (int cancel, int value, void *user_data);
	int num;
	void *user_data;

	num = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin));
	callback = g_object_get_data (G_OBJECT (dialog), "cb");
	user_data = g_object_get_data (G_OBJECT (dialog), "ud");

	switch (arg1)
	{
	case GTK_RESPONSE_REJECT:
		callback (TRUE, num, user_data);
		gtk_widget_destroy (GTK_WIDGET (dialog));
		break;
	case GTK_RESPONSE_ACCEPT:
		callback (FALSE, num, user_data);
		gtk_widget_destroy (GTK_WIDGET (dialog));
		break;
	}
}
Example #2
0
//download either pace or cta bus info
void on_btndownloadbus_clicked(GtkWidget *widget) {
	GtkSpinButton *busroute = GTK_SPIN_BUTTON(glade_xml_get_widget(xml, "busroute"));
	gint route = gtk_spin_button_get_value_as_int(busroute);
	/* buffer stores urls, dest stores where we put em */
	gchar buffer[512];
	gchar dest[512];
	gchar buffer2[512];
	gchar dest2[512];

	if(route < 205) {
		g_snprintf(buffer,512,"http://transitchicago.com/maps/Bus/Bus/%d.pdf",route);
		g_snprintf(dest,512,"%s/ctabus/%d.pdf",getProgData(NULL),route);
		downOneFile(buffer,dest);
	} else {
		g_snprintf(buffer,512,"http://pacebus.com/pdf/schedules/%dsched.pdf",route);
		g_snprintf(dest,512,"%s/pacebus/%dsched.pdf",getProgData(NULL),route);
		g_snprintf(buffer2,512,"http://pacebus.com/pdf/maps/%dmap.pdf",route);
		g_snprintf(dest2,512,"%s/pacebus/%dmap.pdf",getProgData(NULL),route);
		downOneFile(buffer,dest);
		downOneFile(buffer2,dest2);
	}
	buses_load(); /* reload em */
}
static void update_workspaces_model(PagerData* pager)
{
	int nr_ws, i;
	WnckWorkspace* workspace;
	GtkTreeIter iter;

	nr_ws = wnck_screen_get_workspace_count(pager->screen);

	if (pager->properties_dialog)
	{
		if (nr_ws != gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(pager->num_workspaces_spin)))
			gtk_spin_button_set_value(GTK_SPIN_BUTTON(pager->num_workspaces_spin), nr_ws);

		gtk_list_store_clear(pager->workspaces_store);

		for (i = 0; i < nr_ws; i++)
		{
			workspace = wnck_screen_get_workspace(pager->screen, i);
			gtk_list_store_append(pager->workspaces_store, &iter);
			gtk_list_store_set(pager->workspaces_store, &iter, 0, wnck_workspace_get_name(workspace), -1);
		}
	}
}
Example #4
0
static void
cb_dialog_row_height_apply_clicked (G_GNUC_UNUSED GtkWidget *button,
                                    RowHeightState *state)
{
    gint value = gtk_spin_button_get_value_as_int (state->spin);
    int size_pixels = (int)(value * state->sheet->last_zoom_factor_used + 0.5);
    gboolean use_default = gtk_toggle_button_get_active
                           (GTK_TOGGLE_BUTTON (state->default_check));

    if (state->set_default_value) {
        double points = value * 72./gnm_app_display_dpi_get (TRUE);
        cmd_colrow_std_size (WORKBOOK_CONTROL (state->wbcg),
                             state->sheet, FALSE, points);
        dialog_row_height_load_value (state);
    } else {
        if (use_default)
            size_pixels = 0;

        workbook_cmd_resize_selected_colrow (WORKBOOK_CONTROL (state->wbcg),
                                             state->sheet, FALSE, size_pixels);
        dialog_row_height_load_value (state);
    }
}
Example #5
0
/** @brief Get the settings from the autonumber text dialog
 *
 * Get the settings from the autonumber text dialog and store it in the
 * <B>AUTONUMBER_TEXT</B> structure.
 *
 * @param autotext Pointer to the state struct.
 */
void autonumber_get_state(AUTONUMBER_TEXT *autotext)
{
  GtkWidget *widget;
  gchar *text;

  /* Scope */

  /* Search text history */
  widget = lookup_widget(autotext->dialog, "scope_text");
  widget = gtk_bin_get_child(GTK_BIN(widget));
  text = g_strdup(gtk_entry_get_text( GTK_ENTRY(widget)));

  autotext->scope_text=autonumber_history_add(autotext->scope_text, text);

  widget = lookup_widget(autotext->dialog, "scope_skip");
  autotext->scope_skip = gtk_combo_box_get_active( GTK_COMBO_BOX(widget) );

  widget = lookup_widget(autotext->dialog, "scope_number");
  autotext->scope_number = gtk_combo_box_get_active(GTK_COMBO_BOX(widget) );

  widget = lookup_widget(autotext->dialog, "scope_overwrite");
  autotext->scope_overwrite = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));

  /* Sort order */
  widget = lookup_widget(autotext->dialog, "sort_order");
  autotext->order= gtk_combo_box_get_active(GTK_COMBO_BOX(widget));

  /* Options */
  widget = lookup_widget(autotext->dialog, "opt_startnum");
  autotext->startnum=gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widget));

  widget = lookup_widget(autotext->dialog, "opt_removenum");
  autotext->removenum = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));

  widget = lookup_widget(autotext->dialog, "opt_slotting");
  autotext->slotting = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
}
Example #6
0
void
year_info_cb (GtkWidget *widget, gpointer user_data)
{
guint month, year, w_days;
gchar tmpbuf[BUFFER_SIZE];

	GUI *appGUI = (GUI *) user_data;

	year = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (appGUI->cal->fy_spinbutton));
	w_days = 0;

	for (month = G_DATE_JANUARY; month <= G_DATE_DECEMBER; month++) {
		w_days += get_weekend_days (month, year);
	}

	g_snprintf (tmpbuf, BUFFER_SIZE, "%s: %d\n%s: %s\n\n%s: %s\n\n%s: %d\n%s: %d\n%s: %d (%.1f%%)",
	            _("Year"), year, _("Leap year"), g_date_is_leap_year (year) ? _("Yes"):_("No"),
	            _("Chinese year animal"), get_chinese_year_name (year),
	            _("Number of days"), get_days_per_year (year),
	            _("Number of weeks"), weeks_in_year (year),
	            _("Number of weekend days"), w_days, (double) w_days / get_days_per_year (year) * 100.0);

	gui_create_dialog (GTK_MESSAGE_INFO, tmpbuf, GTK_WINDOW (appGUI->cal->fullyear_window));
}
static void
modify_passes (GtkWidget * data, gpointer value)
{
	grg_prefs_wipe_passes =
		gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (data));
}
static void
ui_to_setting (CEPageBond *self)
{
	CEPageBondPrivate *priv = CE_PAGE_BOND_GET_PRIVATE (self);
	NMConnection *connection = CE_PAGE (self)->connection;
	const char *mode;
	const char *frequency;
	const char *updelay;
	const char *downdelay;
	const char *primary = NULL;
	char *targets;
	guint32 mtu;

	/* Mode */
	switch (gtk_combo_box_get_active (priv->mode)) {
	case MODE_BALANCE_RR:
		mode = "balance-rr";
		break;
	case MODE_ACTIVE_BACKUP:
		mode = "active-backup";
		primary = gtk_entry_get_text (priv->primary);
		break;
	case MODE_BALANCE_XOR:
		mode = "balance-xor";
		break;
	case MODE_BROADCAST:
		mode = "broadcast";
		break;
	case MODE_802_3AD:
		mode = "802.3ad";
		break;
	case MODE_BALANCE_TLB:
		mode = "balance-tlb";
		break;
	case MODE_BALANCE_ALB:
		mode = "balance-alb";
		break;
	default:
		g_assert_not_reached ();
		break;
	}

	/* Set bond mode and primary */
	nm_setting_bond_add_option (priv->setting, NM_SETTING_BOND_OPTION_MODE, mode);

	if (primary && *primary)
		nm_setting_bond_add_option (priv->setting, NM_SETTING_BOND_OPTION_PRIMARY, primary);
	else
		nm_setting_bond_remove_option (priv->setting, NM_SETTING_BOND_OPTION_PRIMARY);

	/* Monitoring mode/frequency */
	frequency = gtk_entry_get_text (GTK_ENTRY (priv->frequency));
	updelay = gtk_entry_get_text (GTK_ENTRY (priv->updelay));
	downdelay = gtk_entry_get_text (GTK_ENTRY (priv->downdelay));
	targets = uglify_targets (gtk_entry_get_text (priv->arp_targets));

	switch (gtk_combo_box_get_active (priv->monitoring)) {
	case MONITORING_MII:
		nm_setting_bond_add_option (priv->setting, NM_SETTING_BOND_OPTION_MIIMON, frequency);
		nm_setting_bond_add_option (priv->setting, NM_SETTING_BOND_OPTION_UPDELAY, updelay);
		nm_setting_bond_add_option (priv->setting, NM_SETTING_BOND_OPTION_DOWNDELAY, downdelay);
		nm_setting_bond_remove_option (priv->setting, NM_SETTING_BOND_OPTION_ARP_INTERVAL);
		nm_setting_bond_remove_option (priv->setting, NM_SETTING_BOND_OPTION_ARP_IP_TARGET);
		break;
	case MONITORING_ARP:
		nm_setting_bond_add_option (priv->setting, NM_SETTING_BOND_OPTION_ARP_INTERVAL, frequency);
		if (targets)
			nm_setting_bond_add_option (priv->setting, NM_SETTING_BOND_OPTION_ARP_IP_TARGET, targets);
		else
			nm_setting_bond_remove_option (priv->setting, NM_SETTING_BOND_OPTION_ARP_IP_TARGET);
		nm_setting_bond_remove_option (priv->setting, NM_SETTING_BOND_OPTION_MIIMON);
		nm_setting_bond_remove_option (priv->setting, NM_SETTING_BOND_OPTION_UPDELAY);
		nm_setting_bond_remove_option (priv->setting, NM_SETTING_BOND_OPTION_DOWNDELAY);
		break;
	default:
		g_assert_not_reached ();
		break;
	}

	g_free (targets);

	mtu = gtk_spin_button_get_value_as_int (priv->mtu);
	if (mtu && !priv->wired) {
		priv->wired = NM_SETTING_WIRED (nm_setting_wired_new ());
		nm_connection_add_setting (connection, NM_SETTING (priv->wired));
	}
	if (priv->wired)
		g_object_set (priv->wired, NM_SETTING_WIRED_MTU, mtu, NULL);
}
Example #9
0
extern void change_refresh_popup(GtkAction *action, gpointer user_data)
{
	GtkWidget *table = gtk_table_new(1, 2, FALSE);
	GtkWidget *label = NULL;
	GtkObject *adjustment = gtk_adjustment_new(
		working_sview_config.refresh_delay,
		1, 10000,
		5, 60,
		0);
	GtkWidget *spin_button =
		gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 1, 0);
	GtkWidget *popup = gtk_dialog_new_with_buttons(
		"Refresh Interval",
		GTK_WINDOW (user_data),
		GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
		NULL);
	GError *error = NULL;
	int response = 0;
	char *temp = NULL;

	label = gtk_dialog_add_button(GTK_DIALOG(popup),
				      GTK_STOCK_OK, GTK_RESPONSE_OK);
	gtk_window_set_default(GTK_WINDOW(popup), label);
	gtk_dialog_add_button(GTK_DIALOG(popup),
			      GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);

	label = gtk_label_new("Interval in Seconds ");

	gtk_container_set_border_width(GTK_CONTAINER(table), 10);

	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox),
			   table, FALSE, FALSE, 0);

	gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1);
	gtk_table_attach_defaults(GTK_TABLE(table), spin_button, 1, 2, 0, 1);

	gtk_widget_show_all(popup);
	response = gtk_dialog_run (GTK_DIALOG(popup));

	if (response == GTK_RESPONSE_OK) {
		working_sview_config.refresh_delay =
			gtk_spin_button_get_value_as_int(
				GTK_SPIN_BUTTON(spin_button));
		temp = g_strdup_printf("Refresh Interval set to %d seconds.",
				       working_sview_config.refresh_delay);
		gtk_statusbar_pop(GTK_STATUSBAR(main_statusbar),
				  STATUS_REFRESH);
		response = gtk_statusbar_push(GTK_STATUSBAR(main_statusbar),
					      STATUS_REFRESH,
					      temp);
		g_free(temp);
		if (!g_thread_create(_refresh_thr, GINT_TO_POINTER(response),
				     FALSE, &error)) {
			g_printerr ("Failed to create refresh thread: %s\n",
				    error->message);
		}
	}

	gtk_widget_destroy(popup);

	return;
}
//updateRule is called by a SPIN_BUTTON which changes the
// base 10 rule number
void updateRule(GtkWidget *adjustor) {
    ca1->setRule(gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(adjustor)));
}
/* Apply changes. Returns TRUE if things are ok, FALSE otherwise */
static gboolean apply_changes(radio_conf_t * conf)
{
    /* name */
    if (conf->name)
        g_free(conf->name);

    conf->name = g_strdup(gtk_entry_get_text(GTK_ENTRY(name)));

    /* host */
    if (conf->host)
        g_free(conf->host);

    conf->host = g_strdup(gtk_entry_get_text(GTK_ENTRY(host)));

    /* port */
    conf->port = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(port));

    /* lo down freq */
    conf->lo = 1000000.0 * gtk_spin_button_get_value(GTK_SPIN_BUTTON(lo));

    /* lo up freq */
    conf->loup = 1000000.0 * gtk_spin_button_get_value(GTK_SPIN_BUTTON(loup));

    /* rig type */
    conf->type = gtk_combo_box_get_active(GTK_COMBO_BOX(type));

    /* ptt */
    conf->ptt = gtk_combo_box_get_active(GTK_COMBO_BOX(ptt));

    /* vfo up/down */
    if (conf->type == RIG_TYPE_DUPLEX)
    {
        switch (gtk_combo_box_get_active(GTK_COMBO_BOX(vfo)))
        {

        case 1:
            conf->vfoUp = VFO_MAIN;
            conf->vfoDown = VFO_SUB;
            break;

        case 2:
            conf->vfoUp = VFO_SUB;
            conf->vfoDown = VFO_MAIN;
            break;

        case 3:
            conf->vfoUp = VFO_A;
            conf->vfoDown = VFO_B;
            break;

        case 4:
            conf->vfoUp = VFO_B;
            conf->vfoDown = VFO_A;
            break;

        default:
            conf->vfoUp = VFO_MAIN;
            conf->vfoDown = VFO_SUB;
            break;
        }
    }

    /* AOS / LOS signalling */
    conf->signal_aos = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(sigaos));
    conf->signal_los = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(siglos));

    return TRUE;
}
Example #12
0
/* Verifies data for New & Properties dialogs.
 * Returns: FALSE if the user needs to change any data. */
static gboolean update_config(const PropertyDialogElements *e, gboolean new_project)
{
	const gchar *name, *file_name, *base_path;
	gchar *locale_filename;
	gsize name_len;
	gint err_code = 0;
	GeanyProject *p;

	g_return_val_if_fail(e != NULL, TRUE);

	name = gtk_entry_get_text(GTK_ENTRY(e->name));
	name_len = strlen(name);
	if (name_len == 0)
	{
		SHOW_ERR(_("The specified project name is too short."));
		gtk_widget_grab_focus(e->name);
		return FALSE;
	}
	else if (name_len > MAX_NAME_LEN)
	{
		SHOW_ERR1(_("The specified project name is too long (max. %d characters)."), MAX_NAME_LEN);
		gtk_widget_grab_focus(e->name);
		return FALSE;
	}

	if (new_project)
		file_name = gtk_entry_get_text(GTK_ENTRY(e->file_name));
	else
		file_name = gtk_label_get_text(GTK_LABEL(e->file_name));

	if (G_UNLIKELY(! NZV(file_name)))
	{
		SHOW_ERR(_("You have specified an invalid project filename."));
		gtk_widget_grab_focus(e->file_name);
		return FALSE;
	}

	locale_filename = utils_get_locale_from_utf8(file_name);
	base_path = gtk_entry_get_text(GTK_ENTRY(e->base_path));
	if (NZV(base_path))
	{	/* check whether the given directory actually exists */
		gchar *locale_path = utils_get_locale_from_utf8(base_path);

		if (! g_path_is_absolute(locale_path))
		{	/* relative base path, so add base dir of project file name */
			gchar *dir = g_path_get_dirname(locale_filename);
			SETPTR(locale_path, g_strconcat(dir, G_DIR_SEPARATOR_S, locale_path, NULL));
			g_free(dir);
		}

		if (! g_file_test(locale_path, G_FILE_TEST_IS_DIR))
		{
			gboolean create_dir;

			create_dir = dialogs_show_question_full(NULL, GTK_STOCK_OK, GTK_STOCK_CANCEL,
				_("Create the project's base path directory?"),
				_("The path \"%s\" does not exist."),
				base_path);

			if (create_dir)
				err_code = utils_mkdir(locale_path, TRUE);

			if (! create_dir || err_code != 0)
			{
				if (err_code != 0)
					SHOW_ERR1(_("Project base directory could not be created (%s)."),
						g_strerror(err_code));
				gtk_widget_grab_focus(e->base_path);
				utils_free_pointers(2, locale_path, locale_filename, NULL);
				return FALSE;
			}
		}
		g_free(locale_path);
	}
	/* finally test whether the given project file can be written */
	if ((err_code = utils_is_file_writable(locale_filename)) != 0 ||
		(err_code = g_file_test(locale_filename, G_FILE_TEST_IS_DIR) ? EISDIR : 0) != 0)
	{
		SHOW_ERR1(_("Project file could not be written (%s)."), g_strerror(err_code));
		gtk_widget_grab_focus(e->file_name);
		g_free(locale_filename);
		return FALSE;
	}
	g_free(locale_filename);

	if (app->project == NULL)
	{
		create_project();
		new_project = TRUE;
	}
	p = app->project;

	SETPTR(p->name, g_strdup(name));
	SETPTR(p->file_name, g_strdup(file_name));
	/* use "." if base_path is empty */
	SETPTR(p->base_path, g_strdup(NZV(base_path) ? base_path : "./"));

	if (! new_project)	/* save properties specific fields */
	{
		GtkTextIter start, end;
		GtkTextBuffer *buffer;
		GeanyDocument *doc = document_get_current();
		GeanyBuildCommand *oldvalue;
		GeanyFiletype *ft = doc ? doc->file_type : NULL;
		GtkWidget *widget;
		gchar *tmp;
		GString *str;
		GSList *node;

		/* get and set the project description */
		buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(e->description));
		gtk_text_buffer_get_start_iter(buffer, &start);
		gtk_text_buffer_get_end_iter(buffer, &end);
		SETPTR(p->description, g_strdup(gtk_text_buffer_get_text(buffer, &start, &end, FALSE)));

		foreach_slist(node, stash_groups)
			stash_group_update(node->data, e->dialog);

		/* read the project build menu */
		oldvalue = ft ? ft->projfilecmds : NULL;
		build_read_project(ft, e->build_properties);

		if (ft != NULL && ft->projfilecmds != oldvalue && ft->project_list_entry < 0)
		{
			if (p->build_filetypes_list == NULL)
				p->build_filetypes_list = g_ptr_array_new();
			ft->project_list_entry = p->build_filetypes_list->len;
			g_ptr_array_add(p->build_filetypes_list, ft);
		}
		build_menu_update(doc);

		widget = ui_lookup_widget(e->dialog, "radio_long_line_disabled_project");
		if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
			p->long_line_behaviour = 0;
		else
		{
			widget = ui_lookup_widget(e->dialog, "radio_long_line_default_project");
			if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)))
				p->long_line_behaviour = 1;
			else
				/* "Custom" radio button must be checked */
				p->long_line_behaviour = 2;
		}

		widget = ui_lookup_widget(e->dialog, "spin_long_line_project");
		p->long_line_column = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widget));
		apply_editor_prefs();

		/* get and set the project file patterns */
		tmp = g_strdup(gtk_entry_get_text(GTK_ENTRY(e->patterns)));
		g_strfreev(p->file_patterns);
		g_strstrip(tmp);
		str = g_string_new(tmp);
		do {} while (utils_string_replace_all(str, "  ", " "));
		p->file_patterns = g_strsplit(str->str, " ", -1);
		g_string_free(str, TRUE);
		g_free(tmp);
	}

	update_ui();

	return TRUE;
}
Example #13
0
/********************************
* AL_Sprite_Add
*
@ sprite_rect: rectangle draw in editor
@ parent: name of sheet.
*/
void AL_Sprite_Add( Spritesheet * spritesheet, GdkRectangle * sprite_rect )
{
	if ( !spritesheet || !mokoiBasePath )
	{
		Meg_Error_Print( __func__, __LINE__, "AL_Sheet_AddSprite: Invalid parent" );
		return;
	}

	GtkWidget * dialog, * text_name, * file_mask, *check_maskauto, * file_entity, * radio_align;
	GtkSpinButton * spin_mask, * spin_x, * spin_y, * spin_w, * spin_h, * spin_frames;

	/* UI */
	GError * error = NULL;
	GtkBuilder * ui = gtk_builder_new();

	if ( !gtk_builder_add_from_string( ui, mokoiUI_SpriteAdd, -1, &error ) )
	{
		Meg_Error_Print( __func__, __LINE__, "UI creation error '%s'.", error->message );
		return;
	}


	dialog = GET_WIDGET( ui, "mokoi_sheet_addchild");
	text_name = GET_WIDGET( ui, "text_name");

	spin_x = GET_SPIN_WIDGET( ui, "spin_x");
	spin_y = GET_SPIN_WIDGET( ui, "spin_y");
	spin_w = GET_SPIN_WIDGET( ui, "spin_w");
	spin_h = GET_SPIN_WIDGET( ui, "spin_h");
	spin_mask = GET_SPIN_WIDGET( ui, "spin_mask");
	spin_frames = GET_SPIN_WIDGET( ui, "spin_frames");

	check_maskauto = GET_WIDGET( ui, "check_maskauto");

	file_mask = GET_WIDGET( ui, "file_mask");
	file_entity = GET_WIDGET( ui, "file_entity");

	radio_align = GET_WIDGET( ui, "radio_align");

	/* Set Default Values */
	gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER(file_mask), mokoiBasePath );
	gtk_file_chooser_set_current_folder( GTK_FILE_CHOOSER(file_entity), mokoiBasePath );

	gtk_spin_button_set_value( spin_x, (gdouble)sprite_rect->x );
	gtk_spin_button_set_value( spin_y, (gdouble)sprite_rect->y );
	gtk_spin_button_set_value( spin_w, (gdouble)sprite_rect->width );
	gtk_spin_button_set_value( spin_h, (gdouble)sprite_rect->height );

	/* Show Dialog */
	gtk_widget_show_all( gtk_dialog_get_content_area( GTK_DIALOG(dialog) ) );
	gtk_window_set_transient_for( GTK_WINDOW(dialog), Meg_Main_GetWindow());
	if ( gtk_dialog_run( GTK_DIALOG(dialog) ) == GTK_RESPONSE_APPLY )
	{
		gboolean bool_horizontal = FALSE;
		const gchar * sprite_name;
		gchar * mask_file, * entity_file;
		gint frame_count = 0;

		sprite_name = gtk_entry_get_text( GTK_ENTRY(text_name) );
		mask_file = gtk_file_chooser_get_filename( GTK_FILE_CHOOSER(file_mask) );
		entity_file = gtk_file_chooser_get_filename( GTK_FILE_CHOOSER(file_entity) );
		frame_count = gtk_spin_button_get_value_as_int( GTK_SPIN_BUTTON(spin_frames) );
		bool_horizontal = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(radio_align) );

		if ( !g_utf8_strlen(sprite_name, -1) )
		{
			Meg_Error_Print( __func__, __LINE__, "AL_Sheet_AddSprite: No name given" );
		}
		else
		{
			SheetObject * sprite = NULL;
			SpriteData * sprite_data = g_new0(SpriteData, 1);

			sprite = SheetObject_New( (gpointer)sprite_data, &SpriteData_FreePointer );

			sprite->parent_sheet = g_strdup( spritesheet->file );
			sprite->display_name = g_strdup( sprite_name );

			sprite->ident_string = g_strdup_printf( "%s:%s", sprite->parent_sheet, sprite->display_name );

			if ( entity_file )
				sprite_data->entity = g_path_get_basename( entity_file );
			else
				sprite_data->entity = NULL;

			sprite->visible = TRUE;
			sprite_data->image_loaded = FALSE;

			sprite->position.x = gtk_spin_button_get_value_as_int( spin_x );
			sprite->position.y = gtk_spin_button_get_value_as_int( spin_y );
			sprite->position.width = gtk_spin_button_get_value_as_int( spin_w );
			sprite->position.height = gtk_spin_button_get_value_as_int( spin_h );

			if ( mask_file && g_utf8_strlen( mask_file, -1 ) )
				sprite_data->mask.name = g_strdup(mask_file);
			else
			{
				sprite_data->mask.value = gtk_spin_button_get_value_as_int( spin_mask );
				sprite_data->mask.autogen = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON(check_maskauto) );
			}

			GdkPixbuf * parent_image = AL_GetImage( sprite->parent_sheet, NULL );
			if ( frame_count > 0 )
			{
				/* Creating Animation */
				gint frame_length = 0;
				if ( bool_horizontal )
				{
					frame_length = sprite->position.width / frame_count;
					sprite->position.width = frame_length;
				}
				else
				{
					frame_length = sprite->position.height / frame_count;
					sprite->position.height = frame_length;
				}
				sprite_data->animation = g_new0(AnimationDetail, 1);


				gint q = 0;
				while ( q < frame_count )
				{
					/* Create the sprite for the frame */
					SheetObject * frame_sprite = NULL;
					SpriteData * frame_sprite_data = g_new0(SpriteData, 1);

					frame_sprite = SheetObject_New( (gpointer)frame_sprite_data, &SpriteData_FreePointer );

					frame_sprite->display_name = g_strdup_printf("%s_%d", sprite->display_name, q);
					frame_sprite->parent_sheet = g_strdup( spritesheet->file );
					frame_sprite->ident_string = g_strdup_printf( "%s:%s", frame_sprite->parent_sheet, frame_sprite->display_name );
					frame_sprite->visible = FALSE;

					frame_sprite_data->mask = sprite_data->mask;
					frame_sprite_data->image_loaded = FALSE;

					if ( bool_horizontal )
					{
						frame_sprite->position.x = sprite_rect->x + (q * frame_length);
						frame_sprite->position.y = sprite_rect->y;
						frame_sprite->position.width = frame_length;
						frame_sprite->position.height = sprite_rect->height;
					}
					else
					{
						frame_sprite->position.x = sprite_rect->x;
						frame_sprite->position.y = sprite_rect->y + (q * frame_length);
						frame_sprite->position.width = sprite_rect->width;
						frame_sprite->position.height = frame_length;
					}

					frame_sprite_data->image = gdk_pixbuf_new( GDK_COLORSPACE_RGB, TRUE, 8, frame_sprite->position.width, frame_sprite->position.height );
					gdk_pixbuf_copy_area( parent_image, frame_sprite->position.x, frame_sprite->position.y, frame_sprite->position.width, frame_sprite->position.height, frame_sprite_data->image, 0, 0);
					frame_sprite_data->image_loaded = TRUE;

					spritesheet->children = g_slist_append( spritesheet->children, frame_sprite);

					/* Create the Frame and append to list */
					AnimationFrame * frame = g_new0( AnimationFrame, 1 );
					frame->sprite = g_strdup( frame_sprite->display_name );
					frame->offset.x = 0;
					frame->offset.y = 0;
					frame->length_ms = 1000;
					frame->f = 0;
					sprite_data->animation->frames = g_slist_append( sprite_data->animation->frames, frame);

					q++;
				}
			}
			else
			{
				/* Create Sprite */
				sprite_data->image = gdk_pixbuf_new( GDK_COLORSPACE_RGB, TRUE, 8, sprite->position.width, sprite->position.height );
				gdk_pixbuf_copy_area( parent_image, sprite->position.x, sprite->position.y, sprite->position.width, sprite->position.height, sprite_data->image, 0, 0 );
				sprite_data->image_loaded = TRUE;
			}
			g_object_unref( parent_image );

			spritesheet->children = g_slist_append( spritesheet->children, sprite );
			Sheet_SaveFile( spritesheet );
		}
	}
	gtk_widget_destroy( dialog );
}
Example #14
0
static VALUE
rg_value_as_int(VALUE self)
{
    return INT2NUM(gtk_spin_button_get_value_as_int(_SELF(self)));
}
Example #15
0
static void 
on_propdialog_response (GtkDialog *dialog,
                        gint response_id,
			gpointer user_data) 
{
	SubscriptionPropDialog *spd = (SubscriptionPropDialog *)user_data;
	
	if(response_id == GTK_RESPONSE_OK) {
		gchar		*newSource;
		const gchar	*newFilter;
		gboolean	needsUpdate = FALSE;
		subscriptionPtr	subscription = spd->priv->subscription;
		nodePtr		node = spd->priv->subscription->node;
		feedPtr		feed = (feedPtr)node->data;
		
		if (SUBSCRIPTION_TYPE(subscription) == feed_get_subscription_type ()) {
			/* "General" */
			node_set_title(node, gtk_entry_get_text(GTK_ENTRY(spd->priv->feedNameEntry)));
		
			/* Source */
			newSource = ui_subscription_dialog_decode_source(spd->priv);

			/* Filter handling */
			newFilter = gtk_entry_get_text(GTK_ENTRY(liferea_dialog_lookup(spd->priv->dialog, "filterEntry")));
			if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(liferea_dialog_lookup(spd->priv->dialog, "filterCheckbox"))) &&
			   strcmp(newFilter,"")) { /* Maybe this should be a test to see if the file exists? */
				if(subscription_get_filter(subscription) == NULL ||
				   strcmp(newFilter, subscription_get_filter(subscription))) {
					subscription_set_filter(subscription, newFilter);
					needsUpdate = TRUE;
				}
			} else {
				if(subscription_get_filter(subscription)) {
					subscription_set_filter(subscription, NULL);
					needsUpdate = TRUE;
				}
			}
		
			/* if URL has changed... */
			if(strcmp(newSource, subscription_get_source(subscription))) {
				subscription_set_source(subscription, newSource);
				needsUpdate = TRUE;
			}
			g_free(newSource);

			/* Update interval handling */
			if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (GTK_WIDGET (dialog), "updateIntervalNever"))))
				subscription_set_update_interval (subscription, -2);
			else if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (GTK_WIDGET (dialog), "updateIntervalDefault"))))
				subscription_set_update_interval (subscription, -1);
			else if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (GTK_WIDGET (dialog), "updateIntervalSpecific")))) {
				gint intervalUnit = gtk_combo_box_get_active (GTK_COMBO_BOX (spd->priv->refreshIntervalUnit));
				gint updateInterval = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spd->priv->refreshInterval));
				if (intervalUnit == 1)
					updateInterval *= 60;	/* hours */
				if (intervalUnit == 2)
					updateInterval *= 1440;	/* days */
			
				subscription_set_update_interval (subscription, updateInterval);
				db_subscription_update (subscription);
			}
		}
			
		/* "Archive" handling */
		if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(liferea_dialog_lookup(GTK_WIDGET(dialog), "feedCacheDefault"))))
			feed->cacheLimit = CACHE_DEFAULT;
		else if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(liferea_dialog_lookup(GTK_WIDGET(dialog), "feedCacheDisable"))))
			feed->cacheLimit = CACHE_DISABLE;
		else if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(liferea_dialog_lookup(GTK_WIDGET(dialog), "feedCacheUnlimited"))))
			feed->cacheLimit = CACHE_UNLIMITED;
		else if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(liferea_dialog_lookup(GTK_WIDGET(dialog), "feedCacheLimited"))))
			feed->cacheLimit = gtk_spin_button_get_value(GTK_SPIN_BUTTON(liferea_dialog_lookup(GTK_WIDGET(dialog), "cacheItemLimit")));

		if (SUBSCRIPTION_TYPE(subscription) == feed_get_subscription_type ()) {
			/* "Download" Options */
			subscription->updateOptions->dontUseProxy = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(liferea_dialog_lookup(GTK_WIDGET(dialog), "dontUseProxyCheck")));
		}

		/* "Advanced" options */
		feed->encAutoDownload = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (GTK_WIDGET (dialog), "enclosureDownloadCheck")));
		node->loadItemLink = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (GTK_WIDGET (dialog), "loadItemLinkCheck")));
		feed->ignoreComments = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (GTK_WIDGET (dialog), "ignoreCommentFeeds")));
		feed->enforcePopup = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (GTK_WIDGET (dialog), "enforcePopupCheck")));
		feed->preventPopup = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (GTK_WIDGET (dialog), "preventPopupCheck")));
		feed->markAsRead = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (liferea_dialog_lookup (GTK_WIDGET (dialog), "markAsReadCheck")));
		
		if (feed->enforcePopup && feed->preventPopup)
			feed->enforcePopup = FALSE;

		ui_node_update (node->id);
		feedlist_schedule_save ();
		db_subscription_update (subscription);
		if (needsUpdate)
			subscription_update (subscription, FEED_REQ_PRIORITY_HIGH);
	}

	g_object_unref(spd);
}
Example #16
0
static void
on_ok_clicked (GtkButton *button, GtkamSave *save)
{
	guint i, count, j = 1;
	int result = -1;
	GtkWidget *s, *dialog;
	unsigned int id = 0;
	GtkamSaveData *data;
	gchar *progname, *command;
	GError *error = NULL;

	if (count_items (save) == 0) {
		if (!save->priv->err_shown) {
			
			dialog = gtkam_error_new (result, NULL,
					GTK_WIDGET (save), _("There is nothing to be saved."));
			gtk_widget_show (dialog);
		}

		return;
	}
			
	store_save_settings(save);
	gtk_widget_hide (GTK_WIDGET (save));

	count = g_slist_length (save->priv->data);
	if (count == 1)
		s = gtkam_cancel_new (_("Downloading file"));
	else
		s = gtkam_cancel_new (_("Downloading %i files"), count);
	gtk_window_set_transient_for (GTK_WINDOW (s), save->priv->main_window);
	gtk_widget_show (s);

	if (count > 1)
		id = gp_context_progress_start (
			GTKAM_CANCEL (s)->context->context, count,
			_("Downloading %i files..."), count);

	if (!save->priv->toggle_filename_camera->active)
		j = gtk_spin_button_get_value_as_int (
				GTK_SPIN_BUTTON (save->priv->spin_entry));
	
	for (i = 0; i < count; i++) {
		data = g_slist_nth_data (save->priv->data, i);

		/* Check for shutdown */
		if (!GTKAM_IS_SAVE (save))
			return;

		if (save->priv->toggle_normal &&
		    save->priv->toggle_normal->active)
			result = get_file (save, data->camera,
				  data->folder, data->name,
				  GP_FILE_TYPE_NORMAL, i + j,
				  GTKAM_CANCEL (s)->context);
		if (save->priv->toggle_preview &&
		    save->priv->toggle_preview->active &&
		    (!result < 0))
			result = get_file (save, data->camera,
				  data->folder, data->name,
				  GP_FILE_TYPE_PREVIEW, i + j,
				  GTKAM_CANCEL (s)->context);
		if (save->priv->toggle_raw &&
		    save->priv->toggle_raw->active &&
		    (!result < 0))
			result = get_file (save, data->camera,
				  data->folder, data->name, GP_FILE_TYPE_RAW,
				  i + j, GTKAM_CANCEL (s)->context);
		if (save->priv->toggle_audio &&
		    save->priv->toggle_audio->active &&
		    (!result < 0))
			result = get_file (save, data->camera,
				  data->folder, data->name, GP_FILE_TYPE_AUDIO,
				  i + j, GTKAM_CANCEL (s)->context);
		if (save->priv->toggle_exif &&
		    save->priv->toggle_exif->active &&
		    (!result < 0))
			result = get_file (save, data->camera,
				  data->folder, data->name, GP_FILE_TYPE_EXIF,
				  i + j, GTKAM_CANCEL (s)->context);

		if (result < 0)
		{
			if (count > 1)
				gp_context_progress_stop (GTKAM_CANCEL (s)->context->context, id);
			if (!save->priv->err_shown) {
				dialog = gtkam_error_new (result, GTKAM_CANCEL (s)->context,
						GTK_WIDGET (save), _("Problem getting '%s' "
						"from folder '%s'."),
						data->name, data->folder);
				gtk_widget_show (dialog);
				save->priv->err_shown = TRUE;
			}
	
			gtk_object_destroy (GTK_OBJECT (s));
			gtk_object_destroy (GTK_OBJECT (save));
			return;
		}
		
		if (count > 1)
			gp_context_progress_update (
				GTKAM_CANCEL (s)->context->context, id, i + 1);
		gp_context_idle (GTKAM_CANCEL (s)->context->context);
		if (gp_context_cancel (GTKAM_CANCEL (s)->context->context) ==
				GP_CONTEXT_FEEDBACK_CANCEL)
			break;
	}
	if (count > 1)
		gp_context_progress_stop (
				GTKAM_CANCEL (s)->context->context, id);
	
	gtk_object_destroy (GTK_OBJECT (s));

	/* If file(s) were saved and a program specified, load the program
   passing the filenames */
	if (result >= 0)
	{
		progname = gtk_entry_get_text (save->priv->program);

		if (progname && progname[0] != '\0') {
			command = g_strdup_printf ("%s%s", progname, save->priv->filelist->str);

			/* FIXME Report any arising errors */
			if (!g_spawn_command_line_async (command, &error)) {
				g_warning ("Error running command\n");
				g_error_free (error);
			}
			
			g_free (command);
			g_string_free (save->priv->filelist, TRUE);
		} 
	}
	
	gtk_object_destroy (GTK_OBJECT (save));
}
Example #17
0
/** \brief User pressed OK. Any changes should be stored in config.
 */
void
sat_pref_refresh_ok     (GKeyFile *cfg)
{
     if (dirty) {

          if (cfg != NULL) {

               g_key_file_set_integer (cfg,
                              MOD_CFG_GLOBAL_SECTION,
                              MOD_CFG_TIMEOUT_KEY,
                              gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (dataspin)));

               g_key_file_set_integer (cfg,
                              MOD_CFG_LIST_SECTION,
                              MOD_CFG_LIST_REFRESH,
                              gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (listspin)));

               g_key_file_set_integer (cfg,
                              MOD_CFG_MAP_SECTION,
                              MOD_CFG_MAP_REFRESH,
                              gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (mapspin)));

               g_key_file_set_integer (cfg,
                              MOD_CFG_POLAR_SECTION,
                              MOD_CFG_POLAR_REFRESH,
                              gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (polarspin)));

               g_key_file_set_integer (cfg,
                              MOD_CFG_SINGLE_SAT_SECTION,
                              MOD_CFG_SINGLE_SAT_REFRESH,
                              gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (singlespin)));

          }
          else {

               sat_cfg_set_int (SAT_CFG_INT_MODULE_TIMEOUT,
                          gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (dataspin)));

               sat_cfg_set_int (SAT_CFG_INT_LIST_REFRESH,
                          gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (listspin)));

               sat_cfg_set_int (SAT_CFG_INT_MAP_REFRESH,
                          gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (mapspin)));

               sat_cfg_set_int (SAT_CFG_INT_POLAR_REFRESH,
                          gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (polarspin)));

               sat_cfg_set_int (SAT_CFG_INT_SINGLE_SAT_REFRESH,
                          gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (singlespin)));

          }

     }
     else if (reset) {
          /* we have to reset the values to global or default settings */
          if (cfg == NULL) {
               /* reset values in sat-cfg */
               sat_cfg_reset_int (SAT_CFG_INT_MODULE_TIMEOUT);
               sat_cfg_reset_int (SAT_CFG_INT_LIST_REFRESH);
               sat_cfg_reset_int (SAT_CFG_INT_MAP_REFRESH);
               sat_cfg_reset_int (SAT_CFG_INT_POLAR_REFRESH);
               sat_cfg_reset_int (SAT_CFG_INT_SINGLE_SAT_REFRESH);
          }
          else {
               /* remove keys */
               g_key_file_remove_key ((GKeyFile *)(cfg),
                                MOD_CFG_GLOBAL_SECTION,
                                MOD_CFG_TIMEOUT_KEY,
                                NULL);
               g_key_file_remove_key ((GKeyFile *)(cfg),
                                MOD_CFG_LIST_SECTION,
                                MOD_CFG_LIST_REFRESH,
                                NULL);
               g_key_file_remove_key ((GKeyFile *)(cfg),
                                MOD_CFG_MAP_SECTION,
                                MOD_CFG_MAP_REFRESH,
                                NULL);
               g_key_file_remove_key ((GKeyFile *)(cfg),
                                MOD_CFG_POLAR_SECTION,
                                MOD_CFG_POLAR_REFRESH,
                                NULL);
               g_key_file_remove_key ((GKeyFile *)(cfg),
                                MOD_CFG_SINGLE_SAT_SECTION,
                                MOD_CFG_SINGLE_SAT_REFRESH,
                                NULL);
          }
     }

     dirty = FALSE;
     reset = FALSE;
}
Example #18
0
void onAddCameraToPlaylist(GtkButton *button, gpointer user_data)
{
    intf_thread_t *p_intf = GtkGetIntf( button );

    GtkSpinButton *entryV4LChannel = NULL;
    GtkSpinButton *entryV4LFrequency = NULL;
    GtkSpinButton *entryV4LSampleRate = NULL;
    GtkSpinButton *entryV4LQuality = NULL;
    GtkSpinButton *entryV4LTuner = NULL;
    gint    i_v4l_channel;
    gint    i_v4l_frequency;
    gint    i_v4l_samplerate;
    gint    i_v4l_quality;
    gint    i_v4l_tuner;

    GtkEntry      *entryV4LVideoDevice = NULL;
    GtkEntry      *entryV4LAudioDevice = NULL;
    GtkEntry      *entryV4LNorm = NULL;
    GtkEntry      *entryV4LSize = NULL;
    GtkEntry      *entryV4LSoundDirection = NULL;
    const gchar   *p_v4l_video_device;
    const gchar   *p_v4l_audio_device;
    const gchar   *p_v4l_norm;
    const gchar   *p_v4l_size;
    const gchar   *p_v4l_sound_direction;

    /* MJPEG only */
    GtkCheckButton *checkV4LMJPEG = NULL;
    GtkSpinButton  *entryV4LDecimation = NULL;
    gboolean        b_v4l_mjpeg;
    gint            i_v4l_decimation;
    /* end MJPEG only */

    GtkCheckButton  *p_check_v4l_transcode = NULL;
    gboolean         b_v4l_transcode;
    
    char **ppsz_options = NULL; /* list of options */
    int  i_options=0;
    char v4l_mrl[6];
    int i_pos;
    int i;

    ppsz_options = (char **) malloc(11 *sizeof(char*));
    if (ppsz_options == NULL)
    {
        msg_Err(p_intf, "No memory to allocate for v4l options.");
        return;
    }
    for (i=0; i<11; i++)
    {
        ppsz_options[i] = (char *) malloc(VLC_MAX_MRL * sizeof(char));
        if (ppsz_options[i] == NULL)
        {
            msg_Err(p_intf, "No memory to allocate for v4l options string %i.", i);
            for (i-=1; i>=0; i--)
                free(ppsz_options[i]);
            free(ppsz_options);
            return;
        }
    }

    i_pos = snprintf( &v4l_mrl[0], 6, "v4l");
    v4l_mrl[5]='\0';

    entryV4LChannel    = (GtkSpinButton*) lookup_widget( GTK_WIDGET(button), "entryV4LChannel" );
    entryV4LFrequency  = (GtkSpinButton*) lookup_widget( GTK_WIDGET(button), "entryV4LFrequency" );
    entryV4LSampleRate = (GtkSpinButton*) lookup_widget( GTK_WIDGET(button), "entryV4LSampleRate" );
    entryV4LQuality    = (GtkSpinButton*) lookup_widget( GTK_WIDGET(button), "entryV4LQuality" );
    entryV4LTuner      = (GtkSpinButton*) lookup_widget( GTK_WIDGET(button), "entryV4LTuner" );

    entryV4LVideoDevice  = (GtkEntry*) lookup_widget( GTK_WIDGET(button), "entryV4LVideoDevice" );
    entryV4LAudioDevice  = (GtkEntry*) lookup_widget( GTK_WIDGET(button), "entryV4LAudioDevice" );
    entryV4LNorm  = (GtkEntry*) lookup_widget( GTK_WIDGET(button), "entryV4LNorm" );
    entryV4LSize  = (GtkEntry*) lookup_widget( GTK_WIDGET(button), "entryV4LSize" );
    entryV4LSoundDirection  = (GtkEntry*) lookup_widget( GTK_WIDGET(button), "entryV4LSoundDirection" );

    i_v4l_channel = gtk_spin_button_get_value_as_int(entryV4LChannel);
    i_v4l_frequency = gtk_spin_button_get_value_as_int(entryV4LFrequency);
    i_v4l_samplerate = gtk_spin_button_get_value_as_int(entryV4LSampleRate);
    i_v4l_quality = gtk_spin_button_get_value_as_int(entryV4LQuality);
    i_v4l_tuner = gtk_spin_button_get_value_as_int(entryV4LTuner);

    p_v4l_video_device = gtk_entry_get_text(GTK_ENTRY(entryV4LVideoDevice));
    p_v4l_audio_device = gtk_entry_get_text(GTK_ENTRY(entryV4LAudioDevice));
    p_v4l_norm = gtk_entry_get_text(GTK_ENTRY(entryV4LNorm));
    p_v4l_size  = gtk_entry_get_text(GTK_ENTRY(entryV4LSize));
    p_v4l_sound_direction = gtk_entry_get_text(GTK_ENTRY(entryV4LSoundDirection));

    i_pos = snprintf( &ppsz_options[i_options++][0], VLC_MAX_MRL, "%s", (char*)p_v4l_video_device );
    if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '\0';
    i_pos = snprintf( &ppsz_options[i_options++][0], VLC_MAX_MRL, "adev=%s", (char*)p_v4l_audio_device );
    if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '\0';
    i_pos = snprintf( &ppsz_options[i_options++][0], VLC_MAX_MRL, "norm=%s", (char*)p_v4l_norm );
    if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '\0';
    i_pos = snprintf( &ppsz_options[i_options++][0], VLC_MAX_MRL, "size=%s", (char*)p_v4l_size );
    if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '\0';
    i_pos = snprintf( &ppsz_options[i_options++][0], VLC_MAX_MRL, "%s", (char*)p_v4l_sound_direction );
    if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '\0';

    i_pos = snprintf( &ppsz_options[i_options++][0], VLC_MAX_MRL, "channel=%d", (int)i_v4l_channel );
    if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '\0';
    i_pos = snprintf( &ppsz_options[i_options++][0], VLC_MAX_MRL, "frequency=%d", (int)i_v4l_frequency );
    if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '\0';
    i_pos = snprintf( &ppsz_options[i_options++][0], VLC_MAX_MRL, "samplerate=%d", (int)i_v4l_samplerate );
    if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '\0';
    i_pos = snprintf( &ppsz_options[i_options++][0], VLC_MAX_MRL, "quality=%d", (int)i_v4l_quality );
    if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '\0';
    i_pos = snprintf( &ppsz_options[i_options++][0], VLC_MAX_MRL, "tuner=%d", (int)i_v4l_tuner );
    if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '\0';

    /* MJPEG only */
    checkV4LMJPEG      = (GtkCheckButton*) lookup_widget( GTK_WIDGET(button), "checkV4LMJPEG" );
    b_v4l_mjpeg = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkV4LMJPEG));
    if (b_v4l_mjpeg)
    {
        entryV4LDecimation = (GtkSpinButton*) lookup_widget( GTK_WIDGET(button), "entryV4LDecimation" );
        i_v4l_decimation = gtk_spin_button_get_value_as_int(entryV4LDecimation);

        i_pos = snprintf( &ppsz_options[i_options++][0], VLC_MAX_MRL, "mjpeg:%d", (int)i_v4l_decimation );
        if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '\0';
    }
    /* end MJPEG only */

    p_check_v4l_transcode = (GtkCheckButton*) lookup_widget(GTK_WIDGET(button), "checkV4LTranscode" );
    b_v4l_transcode = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(p_check_v4l_transcode));
    if (b_v4l_transcode)
    {
        msg_Dbg( p_intf, "Camera transcode option selected." );
        onAddTranscodeToPlaylist(GTK_WIDGET(button), (gchar *)v4l_mrl);
    }
    else
    {
        msg_Dbg( p_intf, "Camera reception option selected." );
        PlaylistAddItem(GTK_WIDGET(button), (gchar*) &v4l_mrl, ppsz_options, i_options);
    }
}
Example #19
0
static void
delay_spin_value_changed_cb (GtkSpinButton *button)
{
  delay = gtk_spin_button_get_value_as_int (button);
}
Example #20
0
void onAddTranscodeToPlaylist(GtkButton *button, gpointer user_data)
{
    intf_thread_t *p_intf = GtkGetIntf( button );

    GtkEntry       *p_entryVideoCodec = NULL;
    GtkSpinButton  *p_entryVideoBitrate = NULL;
    GtkSpinButton  *p_entryVideoBitrateTolerance = NULL;
    GtkSpinButton  *p_entryVideoKeyFrameInterval = NULL;
    GtkCheckButton *p_checkVideoDeinterlace = NULL;
    GtkEntry       *p_entryAudioCodec = NULL;
    GtkSpinButton  *p_entryAudioBitrate = NULL;
    const gchar    *p_video_codec;
    gint            i_video_bitrate;
    gint            i_video_bitrate_tolerance;
    gint            i_video_keyframe_interval;
    gboolean        b_video_deinterlace;
    const gchar    *p_audio_codec;
    gint            i_audio_bitrate;

    GtkEntry       *p_entryStdAccess = NULL;
    GtkEntry       *p_entryStdMuxer = NULL;
    GtkEntry       *p_entryStdURL = NULL;
    GtkEntry       *p_entryStdAnnounce = NULL;
    GtkSpinButton  *p_entryStdTTL = NULL;
    GtkCheckButton *p_checkSAP = NULL;
    GtkCheckButton *p_checkSLP = NULL;
    const gchar    *p_std_announce;
    const gchar    *p_std_access;
    const gchar    *p_std_muxer;
    const gchar    *p_std_url;
    gboolean        b_sap_announce;
    gboolean        b_slp_announce;
    gint            i_std_ttl;

    char **ppsz_options = NULL; /* list of options */
    int  i_options=0;
    int  i;

    gchar mrl[7];
    int   i_pos;

    ppsz_options = (char **) malloc(3 *sizeof(char*));
    if (ppsz_options == NULL)
    {
        msg_Err(p_intf, "No memory to allocate for v4l options.");
        return;
    }
    for (i=0; i<3; i++)
    {
        ppsz_options[i] = (char *) malloc(VLC_MAX_MRL * sizeof(char));
        if (ppsz_options[i] == NULL)
        {
            msg_Err(p_intf, "No memory to allocate for v4l options string %i.", i);
            for (i-=1; i>=0; i--)
                free(ppsz_options[i]);
            free(ppsz_options);
            return;
        }
    }

    /* Update the playlist */
    playlist_t *p_playlist = (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST, FIND_ANYWHERE );
    if( p_playlist == NULL ) return;

    /* Get all the options. */
    i_pos = snprintf( &mrl[0], VLC_MAX_MRL, "sout");
    mrl[6] = '\0';
    /* option 1 */
    i_pos = snprintf( &ppsz_options[i_options][0], VLC_MAX_MRL, "sout='#transcode{");
    if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '\0';

    p_entryVideoCodec   = (GtkEntry*) lookup_widget( GTK_WIDGET(button), "entryVideoCodec" );
    p_entryVideoBitrate = (GtkSpinButton*) lookup_widget( GTK_WIDGET(button), "entryVideoBitrate" );
    p_entryVideoBitrateTolerance = (GtkSpinButton*) lookup_widget( GTK_WIDGET(button), "entryVideoBitrateTolerance" );
    p_entryVideoKeyFrameInterval = (GtkSpinButton*) lookup_widget( GTK_WIDGET(button), "entryVideoKeyFrameInterval" );
    
    p_video_codec = gtk_entry_get_text(GTK_ENTRY(p_entryVideoCodec));
    i_video_bitrate = gtk_spin_button_get_value_as_int(p_entryVideoBitrate);
    i_video_bitrate_tolerance = gtk_spin_button_get_value_as_int(p_entryVideoBitrateTolerance);
    i_video_keyframe_interval = gtk_spin_button_get_value_as_int(p_entryVideoKeyFrameInterval);
    
    i_pos += snprintf( &ppsz_options[i_options][i_pos], VLC_MAX_MRL - i_pos, "vcodec=%s,", (char*)p_video_codec );
    if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '\0';
    i_pos += snprintf( &ppsz_options[i_options][i_pos], VLC_MAX_MRL - i_pos, "vb=%d,", (int)i_video_bitrate );
    if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '\0';
    i_pos += snprintf( &ppsz_options[i_options][i_pos], VLC_MAX_MRL - i_pos, "vt=%d,", (int)i_video_bitrate_tolerance );
    if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '\0';
    i_pos += snprintf( &ppsz_options[i_options][i_pos], VLC_MAX_MRL - i_pos, "keyint=%d,", (int)i_video_keyframe_interval );
    if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '\0';

    p_checkVideoDeinterlace = (GtkCheckButton*) lookup_widget( GTK_WIDGET(button), "checkVideoDeinterlace" );
    b_video_deinterlace = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(p_checkVideoDeinterlace));
    if (b_video_deinterlace)
    {
        i_pos += snprintf( &ppsz_options[i_options][i_pos], VLC_MAX_MRL - i_pos, "deinterlace," );
        if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '\0';
    }
    p_entryAudioCodec   = (GtkEntry*) lookup_widget( GTK_WIDGET(button), "entryAudioCodec" );
    p_entryAudioBitrate = (GtkSpinButton*) lookup_widget( GTK_WIDGET(button), "entryAudioBitrate" );

    p_audio_codec = gtk_entry_get_text(GTK_ENTRY(p_entryAudioCodec));
    i_audio_bitrate = gtk_spin_button_get_value_as_int(p_entryAudioBitrate);

    i_pos += snprintf( &ppsz_options[i_options][i_pos], VLC_MAX_MRL - i_pos, "acodec=%s,", (char*)p_audio_codec );
    if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '\0';
    i_pos += snprintf( &ppsz_options[i_options][i_pos], VLC_MAX_MRL - i_pos, "ab=%d,", (int)i_audio_bitrate );
    if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '\0';
    i_pos += snprintf( &ppsz_options[i_options][i_pos], VLC_MAX_MRL - i_pos, "channels=1}"/*, (int)i_audio_channels*/ );
    if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '\0';

    /* option 2 */
    i_pos = 0;
    i_pos = snprintf( &ppsz_options[i_options++][i_pos], VLC_MAX_MRL - i_pos, "#" );
    if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '\0';

    p_entryStdAccess = (GtkEntry*) lookup_widget( GTK_WIDGET(button), "entryStdAccess" );
    p_entryStdMuxer  = (GtkEntry*) lookup_widget( GTK_WIDGET(button), "entryStdMuxer" );
    p_entryStdURL = (GtkEntry*) lookup_widget( GTK_WIDGET(button), "entryStdURL" );
    p_entryStdAnnounce = (GtkEntry*) lookup_widget( GTK_WIDGET(button), "entryAnnounceChannel" );
    p_entryStdTTL = (GtkSpinButton*) lookup_widget( GTK_WIDGET(button), "entryStdTTL" );

    p_std_access = gtk_entry_get_text(GTK_ENTRY(p_entryStdAccess));
    p_std_muxer = gtk_entry_get_text(GTK_ENTRY(p_entryStdMuxer));
    p_std_url = gtk_entry_get_text(GTK_ENTRY(p_entryStdURL));
    p_std_announce = gtk_entry_get_text(GTK_ENTRY(p_entryStdAnnounce));
    b_sap_announce = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(p_checkSAP));
    b_slp_announce = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(p_checkSLP));

    i_pos += snprintf( &ppsz_options[i_options][i_pos], VLC_MAX_MRL - i_pos, "std{access=%s,", (char*)p_std_access);
    if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '\0';
    i_pos += snprintf( &ppsz_options[i_options][i_pos], VLC_MAX_MRL - i_pos, "mux=%s,", (char*)p_std_muxer);
    if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '\0';
    i_pos += snprintf( &ppsz_options[i_options][i_pos], VLC_MAX_MRL - i_pos, "dst=%s", (char*)p_std_url);
    if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '\0';

    if (strncasecmp( (const char*)p_std_access, "udp", 3)==0)
    {
        if (b_sap_announce)
        {
            i_pos += snprintf( &ppsz_options[i_options][i_pos], VLC_MAX_MRL - i_pos, "sap=%s", (char*)p_std_announce);
            if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '\0';
        }
        if (b_slp_announce)
        {
            i_pos += snprintf( &ppsz_options[i_options][i_pos], VLC_MAX_MRL - i_pos, "slp=%s", (char*)p_std_announce);
            if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '\0';
        }
    }

    i_std_ttl = gtk_spin_button_get_value_as_int(p_entryStdTTL);

    i_pos += snprintf( &ppsz_options[i_options++][i_pos], VLC_MAX_MRL - i_pos, "ttl=%d}", (int)i_std_ttl);
    if (i_pos>=VLC_MAX_MRL) ppsz_options[i_options][VLC_MAX_MRL-1] = '\0';

    if (user_data != NULL)
    {
      msg_Dbg(p_intf, "Adding transcoding options to playlist item." );
    }
    else
    {
      msg_Dbg(p_intf, "Adding --sout to playlist." );
      PlaylistAddItem(GTK_WIDGET(button), (gchar*) &mrl, ppsz_options, i_options);
    }
}
Example #21
0
/* fill_component handler for the alarm page */
static void
dialog_to_alarm (Dialog *dialog)
{
	ECalComponentAlarmTrigger trigger;
	ECalComponentAlarmAction action;

	/* Fill out the alarm */
	memset (&trigger, 0, sizeof (ECalComponentAlarmTrigger));
	trigger.type = e_dialog_combo_box_get (dialog->time_combo, time_map);
	if (e_dialog_combo_box_get (dialog->relative_combo, relative_map) == BEFORE)
		trigger.u.rel_duration.is_neg = 1;
	else
		trigger.u.rel_duration.is_neg = 0;

	switch (e_dialog_combo_box_get (dialog->value_units_combo, value_map)) {
	case MINUTES:
		trigger.u.rel_duration.minutes =
			gtk_spin_button_get_value_as_int (
			GTK_SPIN_BUTTON (dialog->interval_value));
		break;

	case HOURS:
		trigger.u.rel_duration.hours =
			gtk_spin_button_get_value_as_int (
			GTK_SPIN_BUTTON (dialog->interval_value));
		break;

	case DAYS:
		trigger.u.rel_duration.days =
			gtk_spin_button_get_value_as_int (
			GTK_SPIN_BUTTON (dialog->interval_value));
		break;

	default:
		g_return_if_reached ();
	}
	e_cal_component_alarm_set_trigger (dialog->alarm, trigger);

	action = e_dialog_combo_box_get (dialog->action_combo, action_map);
	e_cal_component_alarm_set_action (dialog->alarm, action);

	/* Repeat stuff */
	repeat_widgets_to_alarm (dialog, dialog->alarm);

	/* Options */
	switch (action) {
	case E_CAL_COMPONENT_ALARM_NONE:
		g_return_if_reached ();
		break;

	case E_CAL_COMPONENT_ALARM_AUDIO:
		aalarm_widgets_to_alarm (dialog, dialog->alarm);
		break;

	case E_CAL_COMPONENT_ALARM_DISPLAY:
		dalarm_widgets_to_alarm (dialog, dialog->alarm);
		break;

	case E_CAL_COMPONENT_ALARM_EMAIL:
		malarm_widgets_to_alarm (dialog, dialog->alarm);
		break;

	case E_CAL_COMPONENT_ALARM_PROCEDURE:
		palarm_widgets_to_alarm (dialog, dialog->alarm);
		break;

	case E_CAL_COMPONENT_ALARM_UNKNOWN:
		break;

	default:
		g_return_if_reached ();
	}
}
Example #22
0
void
Tetris::lineFillProbChanged (GtkWidget *spin, gpointer data)
{
	gint value = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin));
	games_conf_set_integer (KEY_OPTIONS_GROUP, KEY_LINE_FILL_PROBABILITY, value);
}
Example #23
0
/*
 * snap_dialog
 *
 * Bring up the GTK dialog for setting snapshot
 * parameters.
 */
static gboolean
snap_dialog (void)
{
  GtkWidget *dialog;
  GtkWidget *vbox;
  GtkWidget *hbox;
  GtkWidget *label;
  GtkObject *adj;
  GSList    *radio_group = NULL;
  gint	     radio_pressed[2];
  gint	     decorations;
  gboolean   run;

  /* Set defaults */
  radio_pressed[0] = (winsnapvals.root == FALSE);
  radio_pressed[1] = (winsnapvals.root == TRUE);
  decorations      = winsnapvals.decor;

  /* Init GTK  */
  gimp_ui_init (PLUG_IN_BINARY, FALSE);

  /* Main Dialog */
  dialog = gimp_dialog_new (PLUG_IN_PRINT_NAME, PLUG_IN_ROLE,
                            NULL, 0,
			    gimp_standard_help_func, PLUG_IN_PROC,

			    GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
                            _("Grab"),        GTK_RESPONSE_OK,

			    NULL);

  gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
                                           GTK_RESPONSE_OK,
                                           GTK_RESPONSE_CANCEL,
                                           -1);

  vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
  gtk_container_set_border_width (GTK_CONTAINER (vbox), 12);
  gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))),
                      vbox, TRUE, TRUE, 0);
  gtk_widget_show (vbox);

  winsnapintf.single_button =
    gtk_radio_button_new_with_label (radio_group,
                                     _("Grab a single window"));
  gtk_box_pack_start (GTK_BOX (vbox), winsnapintf.single_button, FALSE, FALSE, 0);

  g_signal_connect (winsnapintf.single_button, "toggled",
		    G_CALLBACK (snap_toggle_update),
                    &radio_pressed[0]);
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (winsnapintf.single_button),
				radio_pressed[0]);
  gtk_widget_show (winsnapintf.single_button);

  radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (winsnapintf.single_button));

  winsnapintf.root_button =
    gtk_radio_button_new_with_label (radio_group,
                                     _("Grab the whole screen"));
  gtk_box_pack_start (GTK_BOX (vbox), winsnapintf.root_button, FALSE, FALSE, 0);
  g_signal_connect (winsnapintf.root_button, "toggled",
                    G_CALLBACK (snap_toggle_update),
                    &radio_pressed[1]);
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (winsnapintf.root_button),
				radio_pressed[1]);
  gtk_widget_show (winsnapintf.root_button);

  radio_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (winsnapintf.root_button));

  /* with delay */
  hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
  gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
  gtk_widget_show (hbox);

  label = gtk_label_new (_("after"));
  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
  gtk_widget_show (label);

  winsnapintf.delay_spinner = gimp_spin_button_new (&adj,
                                                    winsnapvals.delay,
                                                    0.0, 100.0,
                                                    1.0, 5.0, 0.0, 0, 0);
  gtk_box_pack_start (GTK_BOX (hbox),
                      winsnapintf.delay_spinner, FALSE, FALSE, 0);
  gtk_widget_show (winsnapintf.delay_spinner);

  label = gtk_label_new (_("Seconds delay"));
  gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
  gtk_widget_show (label);

#ifdef CAN_SET_DECOR
  /* With decorations */
  winsnapintf.decor_button =
    gtk_check_button_new_with_label (_("Include decorations"));
  g_signal_connect (winsnapintf.decor_button, "toggled",
                    G_CALLBACK (snap_toggle_update),
                    &decorations);
  gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (winsnapintf.decor_button),
				decorations);
  gtk_box_pack_end (GTK_BOX (vbox), winsnapintf.decor_button, FALSE, FALSE, 0);
  gtk_widget_set_sensitive (winsnapintf.decor_button, radio_pressed[0]);
  gtk_widget_show (winsnapintf.decor_button);
#endif /* CAN_SET_DECOR */

  gtk_widget_show (dialog);

  run = (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK);

  if (run)
    {
      winsnapvals.root  = radio_pressed[1];
      winsnapvals.decor = decorations;
      winsnapvals.delay =
        gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (winsnapintf.delay_spinner));
    }

  gtk_widget_destroy (dialog);

  return run;
}
Example #24
0
void
Tetris::startingLevelChanged (GtkWidget *spin, gpointer data)
{
	gint value = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (spin));
	games_conf_set_integer (KEY_OPTIONS_GROUP, KEY_STARTING_LEVEL, value);
}
Example #25
0
extern void change_grid_popup(GtkAction *action, gpointer user_data)
{
	GtkWidget *table = gtk_table_new(1, 2, FALSE);
	GtkWidget *label;
	GtkObject *adjustment;
	GtkWidget *width_sb, *hori_sb, *vert_sb;
	int width = working_sview_config.grid_x_width,
		hori = working_sview_config.grid_hori,
		vert = working_sview_config.grid_vert;
	GtkWidget *popup = gtk_dialog_new_with_buttons(
		"Grid Properties",
		GTK_WINDOW (user_data),
		GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
		NULL);
	GError *error = NULL;
	int response = 0;
	char *temp = NULL;

	label = gtk_dialog_add_button(GTK_DIALOG(popup),
				      GTK_STOCK_OK, GTK_RESPONSE_OK);
	gtk_window_set_default(GTK_WINDOW(popup), label);
	gtk_dialog_add_button(GTK_DIALOG(popup),
			      GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox),
			   table, FALSE, FALSE, 0);

	label = gtk_label_new("Nodes in row ");
	adjustment = gtk_adjustment_new(working_sview_config.grid_x_width,
					1, 1000, 1, 60, 0);
	width_sb = gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 1, 0);
	gtk_container_set_border_width(GTK_CONTAINER(table), 10);
	gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 0, 1);
	gtk_table_attach_defaults(GTK_TABLE(table), width_sb, 1, 2, 0, 1);

	label = gtk_label_new("Nodes before horizontal break ");
	adjustment = gtk_adjustment_new(working_sview_config.grid_hori,
					1, 1000, 1, 60, 0);
	hori_sb = gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 1, 0);
	gtk_container_set_border_width(GTK_CONTAINER(table), 10);
	gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 1, 2);
	gtk_table_attach_defaults(GTK_TABLE(table), hori_sb, 1, 2, 1, 2);

	label = gtk_label_new("Nodes before vertical break ");
	adjustment = gtk_adjustment_new(working_sview_config.grid_vert,
					1, 1000, 1, 60, 0);
	vert_sb = gtk_spin_button_new(GTK_ADJUSTMENT(adjustment), 1, 0);
	gtk_container_set_border_width(GTK_CONTAINER(table), 10);
	gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 2, 3);
	gtk_table_attach_defaults(GTK_TABLE(table), vert_sb, 1, 2, 2, 3);

	/*TODO
	 * do we care about this?

	 label = gtk_label_new("Topology ordered ");
	 adjustment = gtk_adjustment_new(working_sview_config.grid_topological,
	 1, 1000, 1, 60, 0);
	 GtkWidget *gtbtton =  gtk_check_button_new ();
	 gtk_container_set_border_width(GTK_CONTAINER(table), 10);
	 gtk_table_attach_defaults(GTK_TABLE(table), label, 0, 1, 3, 4);
	 gtk_table_attach_defaults(GTK_TABLE(table), gtbtton, 1, 2, 3, 4);

	 gtk_toggle_button_set_active (&gtbtton,
                                       working_sview_config.grid_topological);
	*/

	gtk_widget_show_all(popup);
	response = gtk_dialog_run (GTK_DIALOG(popup));

	if (response == GTK_RESPONSE_OK) {
		working_sview_config.grid_x_width =
			gtk_spin_button_get_value_as_int(
				GTK_SPIN_BUTTON(width_sb));
		working_sview_config.grid_hori =
			gtk_spin_button_get_value_as_int(
				GTK_SPIN_BUTTON(hori_sb));
		working_sview_config.grid_vert =
			gtk_spin_button_get_value_as_int(
				GTK_SPIN_BUTTON(vert_sb));
		memcpy(&default_sview_config, &working_sview_config,
		       sizeof(sview_config_t));
		if ((width == working_sview_config.grid_x_width)
		    && (hori == working_sview_config.grid_hori)
		    && (vert == working_sview_config.grid_vert)) {
			temp = g_strdup_printf("Grid: Nothing changed.");
		} else if (working_sview_config.grid_topological) {
			temp = g_strdup_printf("Grid: Invalid mode .."
					       " switch to non-topology "
					       "order first.");
		} else {
			bool refresh = 0;
			temp = g_strdup_printf(
				"Grid set to %d nodes breaks "
				"at %d H and %d V.",
				working_sview_config.grid_x_width,
				working_sview_config.grid_hori,
				working_sview_config.grid_vert);
			/* If the old width was wider than the
			 * current we need to remake the list so the
			 * table gets set up correctly, so destroy it
			 * here and it will be remade in get_system_stats(). */
			if ((width > working_sview_config.grid_x_width)
			    && grid_button_list) {
				list_destroy(grid_button_list);
				grid_button_list = NULL;
				refresh = 1;
			}
			get_system_stats(main_grid_table);
			if (refresh)
				refresh_main(NULL, NULL);
		}
		gtk_statusbar_pop(GTK_STATUSBAR(main_statusbar),
				  STATUS_REFRESH);
		response = gtk_statusbar_push(GTK_STATUSBAR(main_statusbar),
					      STATUS_REFRESH,
					      temp);
		g_free(temp);
		if (!g_thread_create(_refresh_thr, GINT_TO_POINTER(response),
				     FALSE, &error)) {
			g_printerr ("Failed to create refresh thread: %s\n",
				    error->message);
		}
	}

	gtk_widget_destroy(popup);

	return;
}
int pgin_read_int(char *name, char *label,
        int def, int min, int max, int inc){
GtkWidget *dialog;
GtkWidget *vbox;
GtkWidget *action;
GtkWidget *lbl;
GtkWidget *spin_button;
GtkWidget *ok_button;
GtkObject *adj;
int i;

    /* Dialog */
    dialog = gtk_dialog_new();
    gtk_window_set_title(GTK_WINDOW(dialog), name);
    gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER);
    gtk_window_set_policy(GTK_WINDOW(dialog), TRUE, TRUE, FALSE);
    gtk_window_set_modal(GTK_WINDOW(dialog), TRUE);
    gtk_signal_connect(GTK_OBJECT(dialog), "delete_event",
            GTK_SIGNAL_FUNC(gtk_iface_grab_end_click), NULL);

    /* Vbox */
    vbox = GTK_DIALOG(dialog)->vbox;
    gtk_container_set_border_width(GTK_CONTAINER(vbox), 4);
    gtk_widget_show(vbox);

    /* Label */
    lbl = gtk_label_new(label);
    gtk_widget_show(lbl);
    gtk_container_add(GTK_CONTAINER(vbox), lbl);

    /* Spin button */
    adj = gtk_adjustment_new(def, min, max, inc, inc, inc);
    spin_button = gtk_spin_button_new(GTK_ADJUSTMENT(adj), 0, 0);
    gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(spin_button), TRUE);
    gtk_widget_show(spin_button);
    gtk_container_add(GTK_CONTAINER(vbox), spin_button);

    /* Action area */
    action = GTK_DIALOG(dialog)->action_area;
    gtk_container_set_border_width(GTK_CONTAINER(vbox), 4);
    gtk_widget_show(action);
    
    /* OK button */
    ok_button = gtk_button_new_with_label("  OK  ");
    gtk_widget_show(ok_button);
    gtk_container_add(GTK_CONTAINER(action), ok_button);
    gtk_signal_connect(GTK_OBJECT(ok_button), "clicked",
            GTK_SIGNAL_FUNC(gtk_iface_grab_end_click), NULL);

    /* Get input */
    gtk_widget_show(dialog);
    gtk_iface_grab_end = 0;

    while (!gtk_iface_grab_end){
        while (gtk_events_pending())
              gtk_main_iteration();
        usleep(10000);
    }

    /* Get value */
    i = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(spin_button));
    
    /* Destroy */
    gtk_widget_destroy(lbl);
    gtk_widget_destroy(spin_button);
    gtk_widget_destroy(ok_button);
    gtk_widget_destroy(vbox);
    gtk_widget_destroy(dialog);
    //gtk_object_destroy(adj);

    return i;
}
static void change_size( GtkSpinButton * sb, CPUGraph *base)
{
	set_size( base, gtk_spin_button_get_value_as_int( sb ) );
}
Example #28
0
VikLayerParamData a_uibuilder_widget_get_value ( GtkWidget *widget, VikLayerParam *param )
{
  VikLayerParamData rv;
  switch ( param->widget_type )
  {
    case VIK_LAYER_WIDGET_COLOR:
      gtk_color_button_get_color ( GTK_COLOR_BUTTON(widget), &(rv.c) );
      break;
    case VIK_LAYER_WIDGET_CHECKBUTTON:
      rv.b = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
      break;
    case VIK_LAYER_WIDGET_COMBOBOX:
      if ( param->type == VIK_LAYER_PARAM_UINT )
      {
        rv.i = gtk_combo_box_get_active ( GTK_COMBO_BOX(widget) );
        if ( rv.i == -1 ) rv.i = 0;
        rv.u = rv.i;
        if ( param->extra_widget_data )
          rv.u = ((guint *)param->extra_widget_data)[rv.u];
      }
      if ( param->type == VIK_LAYER_PARAM_STRING)
      {
        if ( param->extra_widget_data )
        {
          /* Combobox displays labels and we want values from extra */
          int pos = gtk_combo_box_get_active ( GTK_COMBO_BOX(widget) );
          rv.s = ((const char **)param->extra_widget_data)[pos];
        }
        else
        {
          /* Return raw value */
#if GTK_CHECK_VERSION (2, 24, 0)
          rv.s = gtk_entry_get_text (GTK_ENTRY (gtk_bin_get_child (GTK_BIN (widget))));
#else
          rv.s = gtk_combo_box_get_active_text ( GTK_COMBO_BOX(widget) );
#endif
        }
	g_debug("%s: %s", __FUNCTION__, rv.s);
      }
      break;
    case VIK_LAYER_WIDGET_RADIOGROUP:
    case VIK_LAYER_WIDGET_RADIOGROUP_STATIC:
      rv.u = vik_radio_group_get_selected(VIK_RADIO_GROUP(widget));
      if ( param->extra_widget_data )
        rv.u = GPOINTER_TO_UINT ( g_list_nth_data(param->extra_widget_data, rv.u) );
      break;
    case VIK_LAYER_WIDGET_SPINBUTTON:
      if ( param->type == VIK_LAYER_PARAM_UINT )
        rv.u = gtk_spin_button_get_value_as_int ( GTK_SPIN_BUTTON(widget) );
      else if ( param->type == VIK_LAYER_PARAM_INT )
        rv.i = gtk_spin_button_get_value_as_int ( GTK_SPIN_BUTTON(widget) );
      else
        rv.d = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(widget) );
      break;
    case VIK_LAYER_WIDGET_ENTRY:
    case VIK_LAYER_WIDGET_PASSWORD:
      rv.s = gtk_entry_get_text ( GTK_ENTRY(widget) );
      break;
    case VIK_LAYER_WIDGET_FILEENTRY:
    case VIK_LAYER_WIDGET_FOLDERENTRY:
      rv.s = vik_file_entry_get_filename ( VIK_FILE_ENTRY(widget) );
      break;
    case VIK_LAYER_WIDGET_FILELIST:
      rv.sl = vik_file_list_get_files ( VIK_FILE_LIST(widget) );
      break;
    case VIK_LAYER_WIDGET_HSCALE:
      if ( param->type == VIK_LAYER_PARAM_UINT )
        rv.u = (guint32) gtk_range_get_value ( GTK_RANGE(widget) );
      else if ( param->type == VIK_LAYER_PARAM_INT )
        rv.i = (gint32) gtk_range_get_value ( GTK_RANGE(widget) );
      else
        rv.d = gtk_range_get_value ( GTK_RANGE(widget) );
      break;
  }

  // Perform conversion if necessary
  if ( param->convert_to_internal )
    rv = param->convert_to_internal ( rv );

  return rv;
}
Example #29
0
void change_digits(GtkWidget *widget, GtkSpinButton *spin)
{
    gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spinner1), gtk_spin_button_get_value_as_int(spin));
}
Example #30
0
void
jsbeautify_dialog(Tbfwin * bfwin)
{
#if GTK_CHECK_VERSION(3,0,0)
	GtkWidget *dialog, *grid, *hbox, *inselection, *usetabs, *tabsize, *nopreservenewline, *jslinthappy,
		*unescape_encoded_chars;
#else
	GtkWidget *dialog, *table, *inselection, *usetabs, *tabsize, *nopreservenewline, *jslinthappy,
		*unescape_encoded_chars;
#endif
	gint result, begin, end;
	gchar *command;

	dialog = gtk_dialog_new_with_buttons(_("Javascript Beautify"),
										 GTK_WINDOW(bfwin->main_window),
										 GTK_DIALOG_DESTROY_WITH_PARENT,
										 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
										 GTK_STOCK_OK, GTK_RESPONSE_ACCEPT, NULL);

#if GTK_CHECK_VERSION(3,0,0)
	grid = gtk_grid_new();
	gtk_grid_set_column_spacing(GTK_GRID(grid), 12);
	gtk_grid_set_row_spacing(GTK_GRID(grid), 6);
	gtk_container_set_border_width(GTK_CONTAINER(grid), 6);
	gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), grid, FALSE, FALSE, 0);

	hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
	tabsize = dialog_spin_button_labeled(1, 99, 3, _("_Indent size:"), hbox, 12);
	gtk_container_add(GTK_CONTAINER(grid), hbox);

	usetabs = dialog_check_button_new(_("Use _tabs to indent, not spaces"), TRUE);
	gtk_grid_attach_next_to(GTK_GRID(grid), usetabs, hbox, GTK_POS_BOTTOM, 1, 1);

	nopreservenewline = dialog_check_button_new(_("Do not _preserve existing line breaks"), FALSE);
	gtk_grid_attach_next_to(GTK_GRID(grid), nopreservenewline, usetabs, GTK_POS_BOTTOM, 1, 1);
	jslinthappy = dialog_check_button_new(_("More _jslint-compatible output"), FALSE);
	gtk_grid_attach_next_to(GTK_GRID(grid), jslinthappy, nopreservenewline, GTK_POS_BOTTOM, 1, 1);
	unescape_encoded_chars =
		dialog_check_button_new(_("_Decode printable chars encoded in \\\\xNN notation"), FALSE);
	gtk_grid_attach_next_to(GTK_GRID(grid), unescape_encoded_chars, jslinthappy, GTK_POS_BOTTOM, 1, 1);

	/* TODO: Is this a bug? Altering the option doesn't change anything */
	if (doc_get_selection(DOCUMENT(bfwin->current_document), &begin, &end)) {
		inselection = dialog_check_button_new(_("Beautify only in _selection"), TRUE);
		gtk_grid_attach_next_to(GTK_GRID(grid), inselection, unescape_encoded_chars, GTK_POS_BOTTOM, 1, 1);
	} else {
		begin = 0;
		end = -1;
	}
#else
	table = dialog_table_in_vbox_defaults(3, 2, 6, gtk_dialog_get_content_area(GTK_DIALOG(dialog)));
	if (doc_get_selection(DOCUMENT(bfwin->current_document), &begin, &end)) {
		inselection = dialog_check_button_in_table(_("Beautify only in _selection"), TRUE, table, 0, 2, 0, 1);
	} else {
		begin = 0;
		end = -1;
	}
	usetabs = dialog_check_button_in_table(_("Use _tabs to indent, not spaces"), TRUE, table, 0, 2, 1, 2);
	gtk_table_attach_defaults(GTK_TABLE(table), gtk_label_new(_("_Indent size")), 0, 1, 2, 3);
	tabsize = dialog_spin_button_in_table(1, 99, 3, table, 1, 2, 2, 3);

	nopreservenewline =
		dialog_check_button_in_table(_("Do not _preserve existing line breaks"), FALSE, table, 0, 2, 3, 4);
	jslinthappy = dialog_check_button_in_table(_("More _jslint-compatible output"), FALSE, table, 0, 2, 4, 5);
	unescape_encoded_chars =
		dialog_check_button_in_table(_("_Decode printable chars encoded in \\\\xNN notation"), FALSE, table, 0,
									 2, 5, 6);
#endif
	/* in selection or all text
	   -s, --indent-size=NUMBER indentation size. (default 4).
	   -c, --indent-char=CHAR character to indent with. (default space).
	   -t, --indent-with-tabs Indent with tabs, overrides -s and -c
	   -d, --disable-preserve-newlines do not preserve existing line breaks.
	   -j, --jslint-happy more jslint-compatible output
	   -b, --brace-style=collapse brace style (collapse, expand, end-expand)
	   -k, --keep-array-indentation keep array indentation.
	   -o, --outfile=FILE specify a file to output to (default stdout)
	   -f, --keep-function-indentation Do not re-indent function bodies defined in var lines.
	   -x, --unescape-strings Decode printable chars encoded in \\xNN notation. */

	gtk_widget_show_all(dialog);

	result = gtk_dialog_run(GTK_DIALOG(dialog));
	switch (result) {
	case GTK_RESPONSE_ACCEPT:
#ifdef WIN32
		command = g_strdup_printf("|python " PKGDATADIR "/jsbeautify %s -s %d %s %s %s -|",
								  gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(usetabs)) ? "-t" : "",
								  gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(tabsize)),
								  gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(nopreservenewline)) ? "-d" :
								  "",
								  gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(jslinthappy)) ? "-j" : "",
								  gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(unescape_encoded_chars)) ?
								  "-x" : "");
#else
		command = g_strdup_printf("|" PKGDATADIR "/jsbeautify %s -s %d %s %s %s -|",
								  gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(usetabs)) ? "-t" : "",
								  gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(tabsize)),
								  gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(nopreservenewline)) ? "-d" :
								  "",
								  gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(jslinthappy)) ? "-j" : "",
								  gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(unescape_encoded_chars)) ?
								  "-x" : "");
#endif
		filter_command(bfwin, command, begin, end);
		g_free(command);
		break;
	default:
		break;
	}
	gtk_widget_destroy(dialog);
}