/* Commit changes to the MateConf database. */
static gboolean
config_entry_commit (GtkWidget *entry, GdkEvent *event, gpointer callback_data)
{
  gchar *text;
  const gchar *key;
  MateConfClient *client;
  
  client = g_object_get_data (G_OBJECT (entry), "client");  

  text = gtk_editable_get_chars (GTK_EDITABLE (entry), 0, -1);

  key = g_object_get_data (G_OBJECT (entry), "key");

  /* Unset if the string is zero-length, otherwise set */
  if (*text != '\0')
    mateconf_client_set_string (client, key, text, NULL);
  else
    mateconf_client_unset (client, key, NULL);
  
  g_free (text);

  return FALSE;
}
Beispiel #2
0
static void edit_hist_back(edit *e)
{
	const char *text = gtk_entry_get_text(e->edit_w);
	if(e->ch) {
		if(!e->ch->h)
			return;
		e->ch = e->ch->h;
	} else {
		if(!e->h)
			return;
		if(!strcmp(text, e->h->e)) {
			if(!e->h->h)
				return;
			e->ch = e->h->h;
		} else {
			if(text[0])
				e->hold = mame_strdup(text);
			e->ch = e->h;
		}
	}
	gtk_entry_set_text(e->edit_w, e->ch->e);
	gtk_editable_select_region(GTK_EDITABLE(e->edit_w), 0, -1);
}
static void
expander_activated_cb (GtkExpander *w,
                       CajaFileConflictDialog *dialog)
{
    CajaFileConflictDialogDetails *details;
    int start_pos, end_pos;

    details = dialog->details;

    if (!gtk_expander_get_expanded (w))
    {
        if (g_strcmp0 (gtk_entry_get_text (GTK_ENTRY (details->entry)),
                       details->conflict_name) == 0)
        {
            gtk_widget_grab_focus (details->entry);

            eel_filename_get_rename_region (details->conflict_name,
                                            &start_pos, &end_pos);
            gtk_editable_select_region (GTK_EDITABLE (details->entry),
                                        start_pos, end_pos);
        }
    }
}
Beispiel #4
0
void XttTblGtk::activate_command(GtkWidget* w, gpointer data)
{
  XttTbl* xtt = (XttTbl*)data;

  if (!xtt->is_authorized())
    return;

  if (xtt->command_open) {
    g_object_set(((XttTblGtk*)xtt)->cmd_input, "visible", FALSE, NULL);
    xtt->set_prompt("");
    xtt->command_open = 0;
    return;
  }

  gtk_editable_delete_text(GTK_EDITABLE(((XttTblGtk*)xtt)->cmd_input), 0, -1);

  g_object_set(((XttTblGtk*)xtt)->cmd_input, "visible", TRUE, NULL);
  xtt->message(' ', "");
  gtk_widget_grab_focus(((XttTblGtk*)xtt)->cmd_input);

  xtt->set_prompt("xtt >");
  xtt->command_open = 1;
}
Beispiel #5
0
/*!
  \brief updates the curve with new data from the corresponding text entry
  This extracts the curve axis and index from the widget in order to know 
  which vertex of the curve to change
  \param widget is hte entry that was changed via the user
  \param data is a pointer to the curve to update
  \returns FALSE
  */
G_MODULE_EXPORT gboolean update_2d_curve(GtkWidget *widget, gpointer data)
{
	GtkWidget *curve = (GtkWidget *)data;
	MtxCurveCoord point;
	Axis axis;
	gint index = 0;
	gchar * text = NULL;
	gfloat tmpf = 0.0;

	index = (GINT) OBJ_GET(widget,"curve_index");
	axis = (Axis) OBJ_GET(widget,"curve_axis");
	mtx_curve_get_coords_at_index(MTX_CURVE(curve),index,&point);
	text = gtk_editable_get_chars(GTK_EDITABLE(widget),0,-1);
	tmpf = (gfloat)strtod(g_strdelimit(text,",.",'.'),NULL);
	if (axis == _X_)
		point.x = tmpf;
	else if (axis == _Y_)
		point.y = tmpf;
	else
		printf(_("ERROR in update_2d_curve()!!!\n"));
	mtx_curve_set_coords_at_index(MTX_CURVE(curve),index,point);
	return FALSE;
}
Beispiel #6
0
static void
selection_changed_callback (GtkWidget *widget,
                            gpointer callback_data)
{
    TargetCallbackData *target_data;
    GtkEditable *editable;
    int start, end;

    target_data = (TargetCallbackData *) callback_data;
    g_assert (target_data != NULL);

    editable = GTK_EDITABLE (widget);
    g_assert (editable != NULL);

    if (gtk_editable_get_selection_bounds (editable, &start, &end) && start != end)
    {
        set_clipboard_menu_items_sensitive (target_data->action_group);
    }
    else
    {
        set_clipboard_menu_items_insensitive (target_data->action_group);
    }
}
/**
 * \internal
 */
static void category_edit_add_request(CategoryEdit * category_edit, GtkWidget *combo)
{
    gchar *name;
    GtkWidget *entry;

    entry = gtk_bin_get_child (GTK_BIN (category_edit->categories_combo));
    gtk_editable_select_region (GTK_EDITABLE (entry), 0, -1);
    gtk_widget_grab_focus (entry);
    name = gtk_combo_box_get_active_text(GTK_COMBO_BOX(combo));
    if (check_duplicate (GEBR_GUI_SEQUENCE_EDIT(category_edit), name) ||
            __category_edit_check_text(name)) {
        g_free(name);
        return;
    }

    debr_has_category(name, TRUE);
    __category_edit_add(category_edit, GEBR_GEOXML_SEQUENCE(gebr_geoxml_flow_append_category(category_edit->menu, name)));

    validate_image_set_check_category_list(category_edit->validate_image, category_edit->menu);
    g_signal_emit_by_name(category_edit, "changed");

    g_free(name);
}
Beispiel #8
0
EXPORT wBool_t wTextSave(
		wText_p bt,
		const char * fileName )
{
#ifndef USE_TEXTVIEW
	int siz, pos, cnt;
#endif
	FILE * f;
	char * cp;

	f = fopen( fileName, "w" );
	if (f==NULL) {
		wNoticeEx( NT_ERROR, fileName, "Ok", NULL );
		return FALSE;
	}
#ifdef USE_TEXTVIEW
	cp = gtkGetText( bt );
	fwrite( cp, 1, strlen(cp), f );
	free(cp);
#else
	siz = gtk_text_get_length( GTK_TEXT(bt->text) );
	pos = 0;
	cnt = BUFSIZ;
	while (pos<siz) {
		if (pos+cnt>siz)
			 cnt = siz-pos;
		cp = gtk_editable_get_chars( GTK_EDITABLE(bt->text), pos, pos+cnt );
		if (cp == NULL)
			break;
		fwrite( cp, 1, cnt, f );
		free(cp);
		pos += cnt;
	}
#endif
	fclose(f);
	return TRUE;
}
Beispiel #9
0
static void
wep_entry_filter_cb (GtkEntry *   entry,
                     const gchar *text,
                     gint         length,
                     gint *       position,
                     gpointer     data)
{
	WirelessSecurityWEPKey *sec = (WirelessSecurityWEPKey *) data;
	GtkEditable *editable = GTK_EDITABLE (entry);
	int i, count = 0;
	gchar *result = g_new (gchar, length);

	if (sec->type == NM_WEP_KEY_TYPE_KEY) {
		for (i = 0; i < length; i++) {
			if (isxdigit(text[i]) || isascii(text[i]))
				result[count++] = text[i];
		}
	} else if (sec->type == NM_WEP_KEY_TYPE_PASSPHRASE) {
		for (i = 0; i < length; i++)
			result[count++] = text[i];
	}

	if (count == 0)
		goto out;

	g_signal_handlers_block_by_func (G_OBJECT (editable),
	                                 G_CALLBACK (wep_entry_filter_cb),
	                                 data);
	gtk_editable_insert_text (editable, result, count, position);
	g_signal_handlers_unblock_by_func (G_OBJECT (editable),
	                                   G_CALLBACK (wep_entry_filter_cb),
	                                   data);

out:
	g_signal_stop_emission_by_name (G_OBJECT (editable), "insert-text");
	g_free (result);
}
static gboolean
create_ring_account(RingMainWindow *win)
{
    g_return_val_if_fail(IS_RING_MAIN_WINDOW(win), G_SOURCE_REMOVE);
    RingMainWindowPrivate *priv = RING_MAIN_WINDOW_GET_PRIVATE(win);

    /* create account and set UPnP enabled, as its not by default in the daemon */
    const gchar *alias = gtk_entry_get_text(GTK_ENTRY(priv->entry_alias));
    Account *account = AccountModel::instance().add(alias, Account::Protocol::RING);
    account->setDisplayName(alias); // set the display name to the same as the alias
    account->setUpnpEnabled(TRUE);

    /* wait for hash to be generated to show the next view */
    priv->hash_updated = QObject::connect(
        account,
        &Account::changed,
        [=] (Account *a) {
            QString hash = a->username();
            if (!hash.isEmpty()) {
                /* set the hash */
                gtk_entry_set_text(GTK_ENTRY(priv->entry_hash), hash.toUtf8().constData());

                /* show the next accont creation view */
                gtk_stack_set_transition_type(GTK_STACK(priv->stack_main_view), GTK_STACK_TRANSITION_TYPE_SLIDE_LEFT);
                gtk_stack_set_visible_child_name(GTK_STACK(priv->stack_main_view), CREATE_ACCOUNT_2_VIEW_NAME);

                /* select the hash text */
                gtk_widget_grab_focus(priv->entry_hash);
                gtk_editable_select_region(GTK_EDITABLE(priv->entry_hash), 0, -1);
            }
        }
    );

    account->performAction(Account::EditAction::SAVE);

    return G_SOURCE_REMOVE;
}
static GtkCellEditable*
thunar_text_renderer_start_editing (GtkCellRenderer     *renderer,
                                    GdkEvent            *event,
                                    GtkWidget           *widget,
                                    const gchar         *path,
                                    GdkRectangle        *background_area,
                                    GdkRectangle        *cell_area,
                                    GtkCellRendererState flags)
{
  ThunarTextRenderer *text_renderer = THUNAR_TEXT_RENDERER (renderer);

  /* verify that we are editable */
  if (renderer->mode != GTK_CELL_RENDERER_MODE_EDITABLE)
    return NULL;

  /* allocate a new text entry widget to be used for editing */
  text_renderer->entry = g_object_new (GTK_TYPE_ENTRY,
                                       "has-frame", FALSE,
                                       "text", text_renderer->text,
                                       "visible", TRUE,
                                       "xalign", renderer->xalign,
                                       NULL);

  /* select the whole text */
  gtk_editable_select_region (GTK_EDITABLE (text_renderer->entry), 0, -1);

  /* remember the tree path that we're editing */
  g_object_set_data_full (G_OBJECT (text_renderer->entry), I_("thunar-text-renderer-path"), g_strdup (path), g_free);

  /* connect required signals */
  g_signal_connect (G_OBJECT (text_renderer->entry), "editing-done", G_CALLBACK (thunar_text_renderer_editing_done), text_renderer);
  g_signal_connect_after (G_OBJECT (text_renderer->entry), "grab-focus", G_CALLBACK (thunar_text_renderer_grab_focus), text_renderer);
  g_signal_connect (G_OBJECT (text_renderer->entry), "focus-out-event", G_CALLBACK (thunar_text_renderer_focus_out_event), text_renderer);
  g_signal_connect (G_OBJECT (text_renderer->entry), "populate-popup", G_CALLBACK (thunar_text_renderer_populate_popup), text_renderer);

  return GTK_CELL_EDITABLE (text_renderer->entry);
}
static void
new_chatroom_dialog_update_widgets (EmpathyNewChatroomDialog *dialog)
{
	const gchar           *protocol;

	if (dialog->account == NULL)
		return;

	protocol = tp_account_get_protocol (dialog->account);

	gtk_entry_set_text (GTK_ENTRY (dialog->entry_server), "");

	/* hardcode here known protocols */
	if (strcmp (protocol, "jabber") == 0) {
		gtk_widget_set_sensitive (dialog->entry_server, TRUE);
	}
	else if (strcmp (protocol, "local-xmpp") == 0) {
		gtk_widget_set_sensitive (dialog->entry_server, FALSE);
	}
	else if (strcmp (protocol, "irc") == 0) {
		gtk_widget_set_sensitive (dialog->entry_server, FALSE);
	}
	else {
		gtk_widget_set_sensitive (dialog->entry_server, TRUE);
	}

	if (!tp_strdiff (protocol, "irc"))
		gtk_entry_set_text (GTK_ENTRY (dialog->entry_room), "#");
	else
		gtk_entry_set_text (GTK_ENTRY (dialog->entry_room), "");

	update_join_button_sensitivity (dialog);

	/* Final set up of the dialog */
	gtk_widget_grab_focus (dialog->entry_room);
	gtk_editable_set_position (GTK_EDITABLE (dialog->entry_room), -1);
}
int
ags_machine_popup_rename_audio_response_callback(GtkWidget *widget, gint response, AgsMachine *machine)
{
  if(response == GTK_RESPONSE_ACCEPT){
    GList *children;

    gchar *str;

    children = gtk_container_get_children((GtkContainer *) GTK_DIALOG(widget)->vbox);
    
    str = gtk_editable_get_chars(GTK_EDITABLE(children->data),
				 0, -1);
    g_object_set(machine->audio,
		 "audio-name", str,
		 NULL);
    
    g_list_free(children);
  }
  
  machine->rename_audio = NULL;
  gtk_widget_destroy(widget);

  return(0);
}
Beispiel #14
0
static void
integer_set(node_gui_t *ng)
{
    unsigned long oldvalue;
    const cml_atom *oldvalue_a;
    unsigned long newvalue;
    char *newvalue_str;
    
    oldvalue_a = cml_node_get_value(ng->node);
    oldvalue = oldvalue_a->value.integer;
    newvalue_str = gtk_editable_get_chars(GTK_EDITABLE(ng->entry), 0, -1);
    newvalue = (unsigned long)strtoul(newvalue_str, 0, 0);
    
    if (oldvalue != newvalue)
    {
	cml_atom a;
	a.type = oldvalue_a->type;
	a.value.integer = newvalue;
	set_value(ng->node, &a);
    }
    integer_update_value(ng);

    g_free(newvalue_str);
}
Beispiel #15
0
EXPORT wBool_t wTextPrint(
		wText_p bt )
{
	wPrinterStream_p f;
#ifndef USE_TEXTVIEW
	int siz, pos, cnt;
#endif
	char * cp;

	f = wPrinterOpen();
	if (f==NULL) {
		return FALSE;
	}
#ifdef USE_TEXTVIEW
	cp = gtkGetText( bt );
	wPrinterWrite( f, cp, strlen(cp) );
	free(cp);

#else
	siz = gtk_text_get_length( GTK_TEXT(bt->text) );
	pos = 0;
	cnt = BUFSIZ;
	while (pos<siz) {
		if (pos+cnt>siz)
			 cnt = siz-pos;
		cp = gtk_editable_get_chars( GTK_EDITABLE(bt->text), pos, pos+cnt );
		if (cp == NULL)
			break;
		wPrinterWrite( f, cp, cnt );
		free(cp);
		pos += cnt;
	}
#endif
	wPrinterClose(f);
	return TRUE;
}
Beispiel #16
0
static void
widget_name_edited (GtkWidget *editable, GladeEditorTable *table)
{
  GladeWidget *widget;
  gchar *new_name;

  g_return_if_fail (GTK_IS_EDITABLE (editable));
  g_return_if_fail (GLADE_IS_EDITOR_TABLE (table));

  if (table->priv->loaded_widget == NULL)
    {
      g_warning ("Name entry edited with no loaded widget in editor %p!\n",
                 table);
      return;
    }

  widget = table->priv->loaded_widget;
  new_name = gtk_editable_get_chars (GTK_EDITABLE (editable), 0, -1);

  if (glade_project_available_widget_name (glade_widget_get_project (widget), 
					   widget, new_name))
    glade_command_set_name (widget, new_name);
  g_free (new_name);
}
Beispiel #17
0
static gboolean
on_entry_draw (GtkWidget *widget,
               cairo_t   *cr,
               gpointer   user_data)
{
  g_debug (G_STRLOC ": %s", G_STRFUNC);

  GtkStyleContext *style_context;
  PangoContext    *pango_context;
  PangoLayout     *layout;
  const char      *text;
  gint             cursor_index;
  gint             x, y;

  style_context = gtk_widget_get_style_context (widget);
  pango_context = gtk_widget_get_pango_context (widget);
  layout = gtk_entry_get_layout (GTK_ENTRY (widget));
  text = pango_layout_get_text (layout);
  gtk_entry_get_layout_offsets (GTK_ENTRY (widget), &x, &y);
  cursor_index = g_utf8_offset_to_pointer (text, gtk_editable_get_position (GTK_EDITABLE (widget))) - text;
  gtk_render_insertion_cursor (style_context, cr, x, y, layout, cursor_index,
                               pango_context_get_base_dir (pango_context));
  return FALSE;
}
Beispiel #18
0
static void
gimp_data_editor_init (GimpDataEditor *editor)
{
  editor->data_factory  = NULL;
  editor->context       = NULL;
  editor->data          = NULL;
  editor->data_editable = FALSE;

  editor->name_entry = gtk_entry_new ();
  gtk_box_pack_start (GTK_BOX (editor), editor->name_entry, FALSE, FALSE, 0);
  gtk_widget_show (editor->name_entry);

  gtk_editable_set_editable (GTK_EDITABLE (editor->name_entry), FALSE);

  g_signal_connect (editor->name_entry, "key-press-event",
                    G_CALLBACK (gimp_data_editor_name_key_press),
                    editor);
  g_signal_connect (editor->name_entry, "activate",
                    G_CALLBACK (gimp_data_editor_name_activate),
                    editor);
  g_signal_connect (editor->name_entry, "focus-out-event",
                    G_CALLBACK (gimp_data_editor_name_focus_out),
                    editor);
}
Beispiel #19
0
static void prefs_message_save(PrefsPage *_page)
{
	MessagePage *page = (MessagePage *) _page;

	prefs_common.display_header_pane = gtk_toggle_button_get_active(
		GTK_TOGGLE_BUTTON(page->checkbtn_disphdrpane));
	prefs_common.display_xface = gtk_toggle_button_get_active(
		GTK_TOGGLE_BUTTON(page->checkbtn_dispxface));
	prefs_common.display_header = gtk_toggle_button_get_active(
		GTK_TOGGLE_BUTTON(page->checkbtn_disphdr));
	prefs_common.render_html = gtk_toggle_button_get_active(
		GTK_TOGGLE_BUTTON(page->checkbtn_html));
	prefs_common.invoke_plugin_on_html = gtk_toggle_button_get_active(
		GTK_TOGGLE_BUTTON(page->checkbtn_html_plugin));
	prefs_common.promote_html_part = gtk_toggle_button_get_active(
		GTK_TOGGLE_BUTTON(page->checkbtn_promote_html_part));
	prefs_common.enable_smooth_scroll = gtk_toggle_button_get_active(
		GTK_TOGGLE_BUTTON(page->checkbtn_smoothscroll));
	prefs_common.scroll_halfpage = gtk_toggle_button_get_active(
		GTK_TOGGLE_BUTTON(page->checkbtn_halfpage));
	prefs_common.hide_quoted = gtk_toggle_button_get_active(
		GTK_TOGGLE_BUTTON(page->checkbtn_hide_quoted));
	prefs_common.attach_desc = gtk_toggle_button_get_active(
		GTK_TOGGLE_BUTTON(page->checkbtn_attach_desc));
	prefs_common.line_space = gtk_spin_button_get_value_as_int(
		GTK_SPIN_BUTTON(page->spinbtn_linespc));
	prefs_common.scroll_step = gtk_spin_button_get_value_as_int(
		GTK_SPIN_BUTTON(page->spinbtn_scrollstep));

	g_free(prefs_common.quote_chars); 
	prefs_common.quote_chars = gtk_editable_get_chars(
			GTK_EDITABLE(page->entry_quote_chars), 0, -1);
	remove_space(prefs_common.quote_chars);

	main_window_reflect_prefs_all_real(FALSE);
}
///////////////////////////////////////////////////////////////////////////////////////////
// 
// PRIVATE void clearTextArea(const gchar *pWidgetName)
// IN     : const gchar *pWidgetName : Widget name.
// OUT    : None.
// RETURN : None.
// 
PRIVATE void clearTextArea(const gchar *pWidgetName)
{
/*** Parameters start ***/
	GtkWidget	*widget = NULL;		// Temporary pointer to widget.
#ifndef USE_GTK12
	GtkTextIter start;
	GtkTextIter end;
	GtkTextBuffer *buffer;
#endif
/*** Parameters end ***/
	
	widget = lookupWidget(pWidgetName);
#ifdef USE_GTK12
	gtk_editable_delete_text(GTK_EDITABLE(widget), 0, -1);
#else
	buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget));
	gtk_text_buffer_get_start_iter(buffer, &start);
	gtk_text_buffer_get_end_iter(buffer, &end);

	gtk_text_buffer_delete(buffer, &start, &end);
#endif	  
	
	return;
}// End clearTextArea
Beispiel #21
0
static gboolean
nautilus_entry_motion_notify (GtkWidget *widget, GdkEventMotion *event)
{
	int result;
	gboolean old_had, new_had;
	int old_start, old_end, new_start, new_end;
	GtkEditable *editable;

	editable = GTK_EDITABLE (widget);

	old_had = gtk_editable_get_selection_bounds (editable, &old_start, &old_end);

	result = GTK_WIDGET_CLASS (nautilus_entry_parent_class)->motion_notify_event (widget, event);

	/* Send a signal if dragging the mouse caused the selection to change. */
	if (result) {
		new_had = gtk_editable_get_selection_bounds (editable, &new_start, &new_end);
		if (old_had != new_had || (old_had && (old_start != new_start || old_end != new_end))) {
			g_signal_emit (widget, signals[SELECTION_CHANGED], 0);
		}
	}
	
	return result;
}
Beispiel #22
0
static void
config_entry_changed_callback(GtkWidget* entry, gpointer data)
{
    GtkWidget* prefs_dialog = data;
    GConfChangeSet* cs;
    gchar* text;
    const gchar* key;

    cs = prefs_dialog_get_change_set(prefs_dialog);

    text = gtk_editable_get_chars(GTK_EDITABLE(entry), 0, -1);

    key = g_object_get_data(entry, "key");

    /* Unset if the string is zero-length, otherwise set */
    if (*text != '\0')
        gconf_change_set_set_string(cs, key, text);
    else
        gconf_change_set_unset(cs, key);

    g_free(text);

    prefs_dialog_update_sensitivity(prefs_dialog);
}
Beispiel #23
0
static void
mood_populate(JamView *view) {
	if (JAM_ACCOUNT_IS_LJ(view->account)) {
		/* load moods. */
		LJServer *server = jam_host_lj_get_server(JAM_HOST_LJ(jam_account_get_host(view->account)));
		LJMood *m;
		char *text;
		GList *strings = NULL;
		GSList *l;

		text = gtk_editable_get_chars(GTK_EDITABLE(GTK_COMBO(view->moodcombo)->entry), 0, -1);

		for (l = server->moods; l; l = l->next) {
			m = l->data;
			strings = g_list_insert_sorted(strings, m->name,
					(GCompareFunc)g_ascii_strcasecmp);
		}
		if (strings)
			gtk_combo_set_popdown_strings(GTK_COMBO(view->moodcombo), strings);

		gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(view->moodcombo)->entry), text);
		g_free(text);
	}
}
Beispiel #24
0
static void
imageheader_refresh( Imageheader *imageheader )
{
	gtk_list_store_clear( imageheader->store );

	if( imageheader->iimage && 
		imageheader->iimage->value.ii ) {
		Imageinfo *ii = imageheader->iimage->value.ii;
		IMAGE *im = imageinfo_get( FALSE, ii );

		im_header_map( im, 
			(im_header_map_fn) imageheader_add_item,
			imageheader );

		gtk_text_buffer_set_text( 
			gtk_text_view_get_buffer( 
				GTK_TEXT_VIEW( imageheader->history ) ),
			im_history_get( im ), -1 );
	}
	else {
		gtk_editable_delete_text( GTK_EDITABLE( imageheader->history ),
			0, -1 );
	}
}
void ui_playlist_notebook_edit_tab_title(GtkWidget *ebox)
{
    if (!gtk_notebook_get_show_tabs(UI_PLAYLIST_NOTEBOOK))
        return;

    if (ebox == NULL || !GTK_IS_EVENT_BOX(ebox))
    {
        GtkWidget *page = gtk_notebook_get_nth_page(UI_PLAYLIST_NOTEBOOK, aud_playlist_get_active());
        ebox = gtk_notebook_get_tab_label(UI_PLAYLIST_NOTEBOOK, page);
    }

    GtkWidget *label = g_object_get_data(G_OBJECT(ebox), "label");
    GtkWidget *entry = g_object_get_data(G_OBJECT(ebox), "entry");
    gtk_widget_hide(label);

    gchar * title = aud_playlist_get_title (aud_playlist_get_active ());
    gtk_entry_set_text ((GtkEntry *) entry, title);
    str_unref (title);
    gtk_widget_grab_focus(entry);
    gtk_editable_select_region(GTK_EDITABLE(entry), 0, -1);
    gtk_widget_show(entry);

    ui_playlist_notebook_tab_title_editing = ebox;
}
static GtkWidget * build_properties_area(WBPlugin *wb, const gchar *buffer, gsize length) {
    GError *error = NULL;
    GObject *area = NULL;
    GtkRadioButton *only_maximized, *active_window;
    GtkToggleButton *show_on_desktop, *sync_wm_theme;
    GtkTreeSelection *selection;
    GtkCellRenderer *renderer;
    GtkListStore *list_store;
    GtkWidget *view, *theme_name_treeview;
    GtkEntry *button_layout;

    wb->prefs->builder = gtk_builder_new();

    if (gtk_builder_add_from_string(wb->prefs->builder, buffer, length, &error)) {
        area = gtk_builder_get_object(wb->prefs->builder, "alignment0");

        if (G_LIKELY (area != NULL))
        {
            only_maximized = GTK_RADIO_BUTTON(gtk_builder_get_object(wb->prefs->builder, "only_maximized"));
            active_window = GTK_RADIO_BUTTON(gtk_builder_get_object(wb->prefs->builder, "active_window"));

            if (G_LIKELY (only_maximized != NULL))
            {
                gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(only_maximized), wb->prefs->only_maximized);
                gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(active_window), !wb->prefs->only_maximized);
                g_signal_connect(only_maximized, "toggled", G_CALLBACK(on_only_maximized_toggled), wb);
            }
            else {
                DBG("No widget with the name \"only_maximized\" found");
            }

            show_on_desktop = GTK_TOGGLE_BUTTON(gtk_builder_get_object(wb->prefs->builder, "show_on_desktop"));

            if (G_LIKELY (show_on_desktop != NULL)) {
                gtk_toggle_button_set_active(show_on_desktop, wb->prefs->show_on_desktop);
                g_signal_connect(show_on_desktop, "toggled", G_CALLBACK(on_show_on_desktop_toggled), wb);
            }
            else {
                DBG("No widget with the name \"show_on_desktop\" found");
            }

            /* Style widgets */
            theme_name_treeview = GTK_WIDGET (gtk_builder_get_object (wb->prefs->builder, "theme_name_treeview"));

            /* theme name */
            {
            list_store = gtk_list_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING);
            gtk_tree_sortable_set_sort_func (GTK_TREE_SORTABLE (list_store), COL_THEME_NAME,
                                             (GtkTreeIterCompareFunc) wckbuttons_theme_sort_func,
                                             NULL, NULL);
            gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (list_store), COL_THEME_NAME, GTK_SORT_ASCENDING);
            gtk_tree_view_set_model (GTK_TREE_VIEW (theme_name_treeview), GTK_TREE_MODEL (list_store));
            g_object_unref (G_OBJECT (list_store));

            renderer = gtk_cell_renderer_text_new ();

            gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (theme_name_treeview),
                                                         0, _("Directory"), renderer, "text", 1, NULL);
            gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (theme_name_treeview),
                                                         0, _("Themes usable"), renderer, "text", 0, NULL);
            selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (theme_name_treeview));
            g_signal_connect (selection, "changed", G_CALLBACK (wckbuttons_theme_selection_changed),
                              wb);
            gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
            view = GTK_WIDGET (gtk_builder_get_object (wb->prefs->builder, "theme_name_treeview"));
            wckbuttons_load_themes (view, wb);
            }

            sync_wm_theme = GTK_TOGGLE_BUTTON(gtk_builder_get_object(wb->prefs->builder, "sync_wm_theme"));

            if (G_LIKELY (sync_wm_theme != NULL))
            {
                if (wb->wm_channel)
                {
                    gtk_toggle_button_set_active(sync_wm_theme, wb->prefs->sync_wm_theme);
                    g_signal_connect(sync_wm_theme, "toggled", G_CALLBACK(on_sync_theme_with_wm_toggled), wb);
                }
                else {
                    gtk_widget_set_sensitive (GTK_WIDGET(sync_wm_theme), FALSE);
                }
            }
            else {
                DBG("No widget with the name \"sync_wm_theme\" found");
            }

            button_layout = GTK_ENTRY(gtk_builder_get_object(wb->prefs->builder, "button_layout"));

            if (G_LIKELY (button_layout != NULL))
            {
                gtk_entry_set_text(button_layout, wb->prefs->button_layout);
                g_signal_connect(GTK_EDITABLE(button_layout), "changed", G_CALLBACK(on_button_layout_changed), wb);
            }
            else {
                DBG("No widget with the name \"button_layout\" found");
            }

            return GTK_WIDGET(area) ;
        }
        else {
            g_set_error_literal(&error, 0, 0, "No widget with the name \"contentarea\" found");
        }
    }

    g_critical("Faild to construct the builder for plugin %s-%d: %s.", xfce_panel_plugin_get_name (wb->plugin), xfce_panel_plugin_get_unique_id (wb->plugin), error->message);
    g_error_free(error);
    g_object_unref(G_OBJECT (wb->prefs->builder) );

    return NULL ;
}
Beispiel #27
0
int XAttOneGtk::change_value(int set_focus)
{
  int sts;
  GtkWidget* text_w;
  char* value = 0;
  int input_size;
  char aval[1024];
  char buf[1024];
  int len;

  sts = gdh_GetAttributeCharAttrref(&aref, &atype, &asize, &aoffs, &aelem);
  if (EVEN(sts))
    return sts;

  switch (atype) {
  case pwr_eType_String:
  case pwr_eType_Text:
    input_size = asize;
    break;
  default:
    input_size = 80;
  }

  sts = gdh_GetObjectInfoAttrref(&aref, aval, sizeof(aval));
  if (EVEN(sts))
    return sts;

  if (atype == pwr_eType_Text)
    value = aval;
  else {
    XNav::attrvalue_to_string(
        atype, atype, &aval, buf, sizeof(buf), &len, NULL, 0);
    value = buf;
  }

  if (!access_rw) {
    gtk_label_set_text(GTK_LABEL(cmd_label), buf);
  } else {
    if (atype == pwr_eType_Text) {
      text_w = cmd_scrolledinput;
      g_object_set(cmd_input, "visible", FALSE, NULL);
      g_object_set(cmd_scrolledinput, "visible", TRUE, NULL);

      // int w, h;
      // gdk_drawable_get_size( pane->window, &w, &h);
      // gtk_paned_set_position( GTK_PANED(pane), h - 170);
      if (set_focus)
        gtk_widget_grab_focus(cmd_scrolledtextview);
      input_multiline = 1;

      if (value) {
        GtkTextIter start_iter, end_iter;
        gtk_text_buffer_get_start_iter(cmd_scrolled_buffer, &start_iter);
        gtk_text_buffer_get_end_iter(cmd_scrolled_buffer, &end_iter);
        gtk_text_buffer_delete(cmd_scrolled_buffer, &start_iter, &end_iter);

        gtk_text_buffer_get_start_iter(cmd_scrolled_buffer, &start_iter);
        gtk_text_buffer_insert(cmd_scrolled_buffer, &start_iter, value, -1);
      } else {
        GtkTextIter start_iter, end_iter;
        gtk_text_buffer_get_start_iter(cmd_scrolled_buffer, &start_iter);
        gtk_text_buffer_get_end_iter(cmd_scrolled_buffer, &end_iter);
        gtk_text_buffer_delete(cmd_scrolled_buffer, &start_iter, &end_iter);
      }
    } else {
      text_w = cmd_input;
      g_object_set(cmd_input, "visible", TRUE, NULL);
      g_object_set(cmd_scrolledinput, "visible", FALSE, NULL);
      if (set_focus)
        gtk_widget_grab_focus(cmd_input);
      input_multiline = 0;

      gtk_entry_set_max_length(GTK_ENTRY(text_w), input_size - 1);

      gint pos = 0;
      gtk_editable_delete_text(GTK_EDITABLE(cmd_input), 0, -1);

      if (value) {
        gtk_editable_insert_text(
            GTK_EDITABLE(text_w), value, strlen(value), &pos);

        // Select the text
        gtk_editable_set_position(GTK_EDITABLE(cmd_input), -1);
        gtk_editable_select_region(GTK_EDITABLE(cmd_input), 0, -1);
      }
    }
    message(' ', "");
    set_prompt(Lng::translate("value >"));
    input_open = 1;
  }
  return XATT__SUCCESS;
}
Beispiel #28
0
static void	ug_proxy_form_std_init (UgProxyForm* pform)
{
	GtkGrid*	grid;
	GtkWidget*	widget;
	GtkWidget*	hbox;

	pform->changed.host = FALSE;
	pform->changed.port = FALSE;
	pform->changed.user = FALSE;
	pform->changed.password = FALSE;

	pform->std = gtk_grid_new ();
	grid       = (GtkGrid*) pform->std;
	// host label & entry
	widget = gtk_label_new_with_mnemonic (_("Host:"));
	pform->host = gtk_entry_new ();
	gtk_entry_set_width_chars (GTK_ENTRY (pform->host), 8);
	gtk_entry_set_activates_default (GTK_ENTRY (pform->host), TRUE);
	gtk_label_set_mnemonic_widget (GTK_LABEL (widget), pform->host);
	g_object_set (widget, "margin-left", 3, "margin-right", 3, NULL);
	g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
	g_object_set (pform->host, "margin", 1, "hexpand", TRUE, NULL);
	gtk_grid_attach (grid, widget, 0, 0, 1, 1);
	gtk_grid_attach (grid, pform->host, 1, 0, 1, 1);
	// port label & entry
	widget = gtk_label_new_with_mnemonic (_("Port:"));
	pform->port  = gtk_spin_button_new_with_range (0.0, 65535.0, 1.0);
	gtk_entry_set_width_chars (GTK_ENTRY (pform->port), 5);
	gtk_label_set_mnemonic_widget (GTK_LABEL (widget), pform->port);
	hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
	gtk_box_pack_start (GTK_BOX (hbox), pform->port, FALSE, FALSE, 0);
	g_object_set (widget, "margin-left", 3, "margin-right", 3, NULL);
	g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
	g_object_set (hbox, "margin", 1, NULL);
	gtk_grid_attach (grid, widget, 0, 1, 1, 1);
	gtk_grid_attach (grid, hbox, 1, 1, 1, 1);
	// center separator
	widget = gtk_separator_new (GTK_ORIENTATION_VERTICAL);
	g_object_set (widget, "margin", 1, NULL);
	gtk_grid_attach (grid, widget, 2, 0, 1, 2);
	// user label & entry
	widget = gtk_label_new_with_mnemonic (_("User:"******"margin-left", 3, "margin-right", 3, NULL);
	g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
	g_object_set (pform->user, "margin", 1, "hexpand", TRUE, NULL);
	gtk_grid_attach (grid, widget, 3, 0, 1, 1);
	gtk_grid_attach (grid, pform->user, 4, 0, 1, 1);
	// password label & entry
	widget = gtk_label_new_with_mnemonic (_("Password:"******"margin-left", 3, "margin-right", 3, NULL);
	g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
	g_object_set (pform->password, "margin", 1, "hexpand", TRUE, NULL);
	gtk_grid_attach (grid, widget, 3, 1, 1, 1);
	gtk_grid_attach (grid, pform->password, 4, 1, 1, 1);

	g_signal_connect (GTK_EDITABLE (pform->user), "changed",
			G_CALLBACK (on_entry_std_changed), pform);
	g_signal_connect (GTK_EDITABLE (pform->password), "changed",
			G_CALLBACK (on_entry_std_changed), pform);
	g_signal_connect (GTK_EDITABLE (pform->host), "changed",
			G_CALLBACK (on_entry_std_changed), pform);
	g_signal_connect (GTK_EDITABLE (pform->port), "changed",
			G_CALLBACK (on_entry_std_changed), pform);

	gtk_widget_show_all (pform->std);
}
Beispiel #29
0
static void	ug_proxy_form_pwmd_init (struct UgProxyFormPwmd* pfp, UgProxyForm* pform)
{
	GtkGrid*	grid;
	GtkWidget*	widget;

	pfp->self = gtk_grid_new ();
	grid = (GtkGrid*) pfp->self;
	widget = gtk_label_new_with_mnemonic (_("Socket:"));
	pfp->socket = gtk_entry_new ();
	gtk_entry_set_width_chars (GTK_ENTRY (pfp->socket), 16);
	gtk_label_set_mnemonic_widget (GTK_LABEL (widget), pfp->socket);
	g_object_set (widget, "margin-left", 3, "margin-right", 3, NULL);
	g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
	g_object_set (pfp->socket, "margin", 1, "hexpand", TRUE, NULL);
	gtk_grid_attach (grid, widget, 0, 0, 1, 1);
	gtk_grid_attach (grid, pfp->socket, 1, 0, 4, 1);

	widget = gtk_label_new_with_mnemonic (_("Socket args:"));
	pfp->socket_args = gtk_entry_new ();
	gtk_entry_set_width_chars (GTK_ENTRY (pfp->socket_args), 16);
	gtk_label_set_mnemonic_widget (GTK_LABEL (widget), pfp->socket_args);
	g_object_set (widget, "margin-left", 3, "margin-right", 3, NULL);
	g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
	g_object_set (pfp->socket_args, "margin", 1, "hexpand", TRUE, NULL);
	gtk_grid_attach (grid, widget, 0, 1, 1, 1);
	gtk_grid_attach (grid, pfp->socket_args, 1, 1, 4, 1);

	widget = gtk_label_new_with_mnemonic (_("Element:"));
	pfp->element = gtk_entry_new ();
	gtk_entry_set_width_chars (GTK_ENTRY (pfp->element), 16);
	gtk_label_set_mnemonic_widget (GTK_LABEL (widget), pfp->element);
	g_object_set (widget, "margin-left", 3, "margin-right", 3, NULL);
	g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
	g_object_set (pfp->element, "margin", 1, "hexpand", TRUE, NULL);
	gtk_grid_attach (grid, widget, 3, 2, 1, 1);
	gtk_grid_attach (grid, pfp->element, 4, 2, 1, 1);

	widget = gtk_separator_new (GTK_ORIENTATION_VERTICAL);
	g_object_set (widget, "margin", 1, NULL);
	gtk_grid_attach (grid, widget, 2, 2, 1, 2);

	widget = gtk_label_new_with_mnemonic (_("File:"));
	pfp->file = gtk_entry_new ();
	gtk_entry_set_width_chars (GTK_ENTRY (pfp->file), 16);
	gtk_label_set_mnemonic_widget (GTK_LABEL (widget), pfp->file);
	g_object_set (widget, "margin-left", 3, "margin-right", 3, NULL);
	g_object_set (widget, "margin-top", 1, "margin-bottom", 1, NULL);
	g_object_set (pfp->file, "margin", 1, "hexpand", TRUE, NULL);
	gtk_grid_attach (grid, widget, 0, 2, 1, 1);
	gtk_grid_attach (grid, pfp->file, 1, 2, 1, 1);

	g_signal_connect (GTK_EDITABLE (pform->pwmd.socket), "changed",
			G_CALLBACK (on_entry_pwmd_changed), pform);
	g_signal_connect (GTK_EDITABLE (pform->pwmd.socket_args), "changed",
			G_CALLBACK (on_entry_pwmd_changed), pform);
	g_signal_connect (GTK_EDITABLE (pform->pwmd.file), "changed",
			G_CALLBACK (on_entry_pwmd_changed), pform);
	g_signal_connect (GTK_EDITABLE (pform->pwmd.element), "changed",
			G_CALLBACK (on_entry_pwmd_changed), pform);

	gtk_widget_show_all ((GtkWidget*) grid);
	gtk_widget_hide ((GtkWidget*) grid);
}
Beispiel #30
0
Datei: gtk.c Projekt: foo/ii
int run_window( int   argc,char *argv[] )
{
    GtkWidget *window;
    GtkWidget *box1, *box2;
    GtkWidget *button;
    GtkWidget *table;
    gint       tmp_pos;


    gtk_init (&argc, &argv);

    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);

    gtk_window_set_title (GTK_WINDOW (window), "GTK - test");

    g_signal_connect (G_OBJECT (window), "delete_event",G_CALLBACK (gtk_main_quit), NULL);
    g_signal_connect (G_OBJECT (window), "destroy",G_CALLBACK (gtk_main_quit), NULL);

    gtk_container_set_border_width (GTK_CONTAINER (window), 10);

    box1 = gtk_vbox_new (FALSE, 0);

    gtk_container_add (GTK_CONTAINER (window), box1);


    text = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY (text), 50);
    g_signal_connect (G_OBJECT (text), "activate",
		      G_CALLBACK (wprowadzony_tekst),
		      (gpointer) text);
    gtk_entry_set_text (GTK_ENTRY (text), "");
    gtk_editable_select_region (GTK_EDITABLE (text),
			        0, GTK_ENTRY (text)->text_length);
    gtk_box_pack_start (GTK_BOX (box1), text, TRUE, TRUE, 0);
    gtk_widget_show (text);

    table = gtk_table_new(5,4,TRUE);
    gtk_table_set_row_spacings(GTK_TABLE(table), 3);
    gtk_table_set_col_spacings(GTK_TABLE(table), 3);
    gtk_box_pack_start (GTK_BOX (box1), table, TRUE, TRUE, 0);
    gtk_widget_show(table);
	
    for(int i = 0; i < 19; i++) {
      button = gtk_button_new_with_label(tab[i].opis);
      g_signal_connect(G_OBJECT(button), "clicked",G_CALLBACK(dodaj_do_text), (gpointer) tab[i].wyjscie);
      gtk_table_attach_defaults(GTK_TABLE(table), button, tab[i].posX, tab[i].posX+tab[i].lenX, 
	 		                                  tab[i].posY, tab[i].posY+tab[i].lenY);
      gtk_widget_show(button);
    }


    box2 = gtk_hbox_new (FALSE, 0);
    button = gtk_button_new_with_label ("Koniec");
    g_signal_connect (G_OBJECT (button), "clicked",G_CALLBACK (wyjscie_przycisk), NULL);
    gtk_box_pack_start(GTK_BOX (box2), button, TRUE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX (box1), box2, TRUE, TRUE, 0);
    gtk_widget_show (button);
    gtk_widget_show (box2);


    gtk_widget_show (box1);
    gtk_widget_show (window);

    
    gtk_main ();

    return 0;
}