예제 #1
0
static void messageview_set_encoding_menu(MessageView *messageview)
{
	GtkItemFactoryEntry *entry;
	GtkItemFactory *ifactory;
	CharSet encoding;
	gchar *path, *p, *q;
	GtkWidget *item;

	encoding = conv_get_charset_from_str(prefs_common.force_charset);
	ifactory = gtk_item_factory_from_widget(messageview->menubar);

	for (entry = msgview_entries; entry->callback != view_source_cb;
	     entry++) {
		if (entry->callback == set_charset_cb &&
		    (CharSet)entry->callback_action == encoding) {
			p = q = path = g_strdup(entry->path);
			while (*p) {
				if (*p == '_') {
					if (p[1] == '_') {
						p++;
						*q++ = '_';
					}
				} else
					*q++ = *p;
				p++;
			}
			*q = '\0';
			item = gtk_item_factory_get_item(ifactory, path);
			gtk_widget_activate(item);
			g_free(path);
			break;
		}
	}
}
예제 #2
0
static VALUE
ifact_s_from_widget(VALUE self, VALUE widget)
{
    VALUE obj = GOBJ2RVAL(gtk_item_factory_from_widget(RVAL2WIDGET(widget)));
    G_RELATIVE(obj, self);
    return obj;
}
예제 #3
0
파일: thumbview.c 프로젝트: gentoo/pornview
static  gint
cb_thumbview_button_press (GtkWidget * widget, GdkEventButton * event,
			   ThumbView * tv)
{
    if (ZALBUM (tv->album)->len == 0 || ZLIST (tv->album)->focus < 0)
	return FALSE;

    gtk_widget_grab_focus (GTK_WIDGET (tv->album));

    if (event->type == GDK_BUTTON_PRESS && event->button == 3)
    {
	gint    type;
	guint   n_menu_items;
	GtkWidget *popup_menu, *progs_submenu, *scripts_submenu;
	GtkWidget *menuitem;
	GtkItemFactory *ifactory;

	/*
	 * create popup menu 
	 */
	n_menu_items = sizeof (thumbview_popupmenu_items)
	    / sizeof (thumbview_popupmenu_items[0]) - 1;

	popup_menu =
	    menu_create_items (BROWSER_WINDOW, thumbview_popupmenu_items,
			       n_menu_items, "<ThumbnailButtonPop>", tv);

	ifactory = gtk_item_factory_from_widget (popup_menu);

	type = (gint) zalbum_get_cell_data (ZALBUM (tv->album), tv->current);

	thumbview_update_popupmenu (type, ifactory);

	menuitem =
	    gtk_item_factory_get_item (ifactory, "/Open in External Program");

	progs_submenu = create_progs_submenu (tv);
	menu_set_submenu (popup_menu, "/Open in External Program",
			  progs_submenu);

	menuitem = gtk_item_factory_get_item (ifactory, "/Scripts");
	scripts_submenu = create_scripts_submenu (tv);
	menu_set_submenu (popup_menu, "/Scripts", scripts_submenu);

	gtk_menu_popup (GTK_MENU (popup_menu),
			NULL, NULL, NULL, NULL, event->button, event->time);

#ifdef USE_GTK2
	gtk_object_ref (GTK_OBJECT (popup_menu));
	gtk_object_sink (GTK_OBJECT (popup_menu));
#endif
	gtk_widget_unref (popup_menu);

	return TRUE;
    }

    tv->current = ZLIST (tv->album)->focus;

    return FALSE;
}
예제 #4
0
void save_config_file(void)				//not called in gint main
{
	FILE *fp;
	gchar *path;
	GtkItemFactory *ifactory;			//GtkItemFactory ??
	gint width, height;
	gchar *fontname;
	gboolean wordwrap, linenumbers, autoindent;
	
	gtk_window_get_size(GTK_WINDOW(pub->mw->window), &width, &height);
	fontname = get_font_name_from_widget(pub->mw->view);
	ifactory = gtk_item_factory_from_widget(pub->mw->menubar);
	wordwrap = gtk_check_menu_item_get_active(
		GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(ifactory,
			"/Options/Word Wrap")));
	linenumbers = gtk_check_menu_item_get_active(
		GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(ifactory,
			"/Options/Line Numbers")));
	autoindent = gtk_check_menu_item_get_active(
		GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(ifactory,
			"/Options/Auto Indent")));
										//saves the variables for conf file
#if GLIB_CHECK_VERSION(2, 6, 0)
	path = g_build_filename(g_get_user_config_dir(), PACKAGE, NULL);	//fetches the address for conf and makes a dir for first 
	if (!g_file_test(path, G_FILE_TEST_IS_DIR)) {				//use if not present
# if GLIB_CHECK_VERSION(2, 8, 0)
		g_mkdir_with_parents(path, 0700);
# else
		g_mkdir(g_get_user_config_dir(), 0700);
		g_mkdir(path, 0700);
# endif
	}
	g_free(path);
	path = g_build_filename(g_get_user_config_dir(),
	    PACKAGE, PACKAGE "rc", NULL);
#else
	path = g_build_filename(g_get_home_dir(), "." PACKAGE, NULL);
#endif
	fp = fopen(path, "w");
	if (!fp) {
		g_print("%s: can't save config file - %s\n", PACKAGE, path);
		return;
	}
	g_free(path);
	
	fprintf(fp, "%s\n", PACKAGE_VERSION);
	fprintf(fp, "%d\n", width);
	fprintf(fp, "%d\n", height);
	fprintf(fp, "%s\n", fontname); 
	fprintf(fp, "%d\n", wordwrap);
	fprintf(fp, "%d\n", linenumbers);
	fprintf(fp, "%d\n", autoindent);
	fclose(fp);
	
	g_free(fontname);
}
예제 #5
0
/*
 *  menu_remove_submenu:
 *     @ Set sub menu.
 *
 *  widget  : Menu widget to set sub menu.
 *  path    : Menu path to check menu item.
 *  submenu : Submenu widget.
 */
void
menu_remove_submenu (GtkWidget *widget, const gchar *path, GtkWidget *submenu)
{
   GtkWidget *menuitem;
   GtkItemFactory *ifactory;

   ifactory = gtk_item_factory_from_widget (widget);
   menuitem = gtk_item_factory_get_item (ifactory, path);
   gtk_menu_item_remove_submenu (GTK_MENU_ITEM (menuitem));
}
예제 #6
0
/*
 *  menu_set_check_item:
 *     @ Set check menu item's value (TRUE or FALSE).
 *
 *  widget : Menu widget that contains check menu item.
 *  path   : Menu path to check menu item.
 *  active : Value for set.
 */
gboolean
menu_check_item_get_active (GtkWidget *widget, gchar *path)
{
   GtkWidget *menuitem;
   GtkItemFactory *ifactory;

   ifactory = gtk_item_factory_from_widget (widget);
   menuitem = gtk_item_factory_get_item (ifactory, path);
   return GTK_CHECK_MENU_ITEM(menuitem)->active;
}
예제 #7
0
/*
 *  menu_set_check_item:
 *     @ Set check menu item's value (TRUE or FALSE).
 *
 *  widget : Menu widget that contains check menu item.
 *  path   : Menu path to check menu item.
 *  active : Value for set.
 */
void
menu_check_item_set_active (GtkWidget *widget, gchar *path, gboolean active)
{
   GtkWidget *menuitem;
   GtkItemFactory *ifactory;

   ifactory = gtk_item_factory_from_widget (widget);
   menuitem = gtk_item_factory_get_item (ifactory, path);
   gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM(menuitem), active);
}
예제 #8
0
void
menu_item_set_sensitive (GtkWidget *widget, gchar *path, gboolean sensitive)
{
   GtkWidget *menuitem;
   GtkItemFactory *ifactory;

   ifactory = gtk_item_factory_from_widget (widget);
   menuitem = gtk_item_factory_get_item (ifactory, path);
   gtk_widget_set_sensitive (menuitem, sensitive);
}
예제 #9
0
GtkWidget *
menu_get_submenu (GtkWidget *widget, const gchar *path)
{
   GtkWidget *menuitem;
   GtkItemFactory *ifactory;

   ifactory = gtk_item_factory_from_widget (widget);
   menuitem = gtk_item_factory_get_item (ifactory, path);
   g_return_val_if_fail (menuitem, NULL);
   return GTK_MENU_ITEM(menuitem)->submenu;
}
예제 #10
0
static void messageview_set_menu_state(MessageView *messageview)
{
	GtkItemFactory *ifactory;
	GtkWidget *menuitem;

	messageview->menu_locked = TRUE;

	ifactory = gtk_item_factory_from_widget(messageview->menubar);
	menuitem = gtk_item_factory_get_widget
		(ifactory, "/View/All headers");
	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(menuitem),
				       messageview->textview->show_all_headers);

	if (messageview->msginfo &&
	    FOLDER_ITEM_IS_SENT_FOLDER(messageview->msginfo->folder))
		menu_set_sensitive(ifactory, "/Message/Re-edit", TRUE);
	else
		menu_set_sensitive(ifactory, "/Message/Re-edit", FALSE);

	messageview->menu_locked = FALSE;
}
예제 #11
0
/******************************************************************************
* gtk_ItemFactoryFromWidget( widget ) --> itemFactory
******************************************************************************/
int
clip_GTK_ITEMFACTORYFROMWIDGET(ClipMachine * cm)
{
        C_widget        *cwid = _fetch_cw_arg(cm);
        C_object       *citem ;
        GtkItemFactory  *item;

	CHECKARG(1, MAP_t); CHECKCWID(cwid, GTK_IS_WIDGET);

	item = gtk_item_factory_from_widget(GTK_WIDGET(cwid->widget));

	if (item)
	{
		citem = _list_get_cobject(cm,item);
		if (!citem) citem = _register_object(cm,item,GTK_TYPE_ITEM_FACTORY,NULL,NULL);
		if (citem) _clip_mclone(cm,RETPTR(cm),&citem->obj);
	}
	return 0;
err:
	return 1;
}
예제 #12
0
MessageView *messageview_create_with_new_window(void)
{
	MessageView *msgview;
	GtkWidget *window;
	GtkWidget *window_vbox;
	GtkWidget *body_vbox;
	GtkWidget *vspacer;
	GtkWidget *menubar;
	GtkItemFactory *ifactory;
	GtkWidget *statusbar;
	guint n_menu_entries;

	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title(GTK_WINDOW(window), _("Message View - Sylpheed"));
	gtk_window_set_wmclass(GTK_WINDOW(window), "message_view", "Sylpheed");
	gtk_window_set_policy(GTK_WINDOW(window), TRUE, TRUE, FALSE);
	gtk_widget_set_size_request(window, prefs_common.msgwin_width,
				    prefs_common.msgwin_height);

	msgview = messageview_create();

	window_vbox = gtk_vbox_new(FALSE, 0);
	gtk_container_add(GTK_CONTAINER(window), window_vbox);

	g_signal_connect(G_OBJECT(window), "size_allocate",
			 G_CALLBACK(messageview_size_allocate_cb),
			 msgview);
	g_signal_connect(G_OBJECT(window), "delete_event",
			 G_CALLBACK(messageview_delete_cb), msgview);
	g_signal_connect(G_OBJECT(window), "key_press_event",
			 G_CALLBACK(key_pressed), msgview);
	MANAGE_WINDOW_SIGNALS_CONNECT(window);

	n_menu_entries = sizeof(msgview_entries) / sizeof (msgview_entries[0]);
	menubar = menubar_create(window, msgview_entries, n_menu_entries,
				 "<MessageView>", msgview);
#if 0
	menu_factory_copy_rc("<Main>", "<MessageView>");
#endif
	gtk_box_pack_start(GTK_BOX(window_vbox), menubar, FALSE, TRUE, 0);

	vspacer = gtk_vbox_new(FALSE, 0);
	gtk_box_pack_start(GTK_BOX(window_vbox), vspacer, FALSE, TRUE,
			   BORDER_WIDTH);

	body_vbox = gtk_vbox_new(FALSE, BORDER_WIDTH);
	gtk_box_pack_start(GTK_BOX(window_vbox), body_vbox, TRUE, TRUE, 0);

	gtk_box_pack_start(GTK_BOX(body_vbox), GTK_WIDGET_PTR(msgview),
			   TRUE, TRUE, 0);
	gtk_widget_grab_focus(msgview->textview->text);

	statusbar = gtk_statusbar_new();
	gtk_box_pack_end(GTK_BOX(body_vbox), statusbar, FALSE, FALSE, 0);
	msgview->statusbar = statusbar;
	msgview->statusbar_cid = gtk_statusbar_get_context_id
		(GTK_STATUSBAR(statusbar), "Message View");

	msgview->new_window = TRUE;
	msgview->window = window;
	msgview->window_vbox = window_vbox;
	msgview->body_vbox = body_vbox;
	msgview->menubar = menubar;
	msgview->menu_locked = FALSE;
	msgview->visible = TRUE;

	gtk_widget_show_all(window);

	messageview_init(msgview);

	messageview_set_encoding_menu(msgview);

	ifactory = gtk_item_factory_from_widget(menubar);
#ifndef G_OS_WIN32
	action_update_msgview_menu(ifactory, msgview);
#endif

	messageview_list = g_list_append(messageview_list, msgview);

	return msgview;
}
예제 #13
0
PRIVATE void newmenu_callback(MenuEntry *p, guint callback_action, GtkWidget *widget) {

    GtkItemFactory *ifact = gtk_item_factory_from_widget( widget );
    Sheet *sheet = gtk_object_get_user_data( GTK_OBJECT( ifact ) );
    sheet_build_new_component(sheet, p->k, p->init_data);
}
예제 #14
0
gint main(gint argc, gchar **argv)
{
	Conf *conf;
	GtkItemFactory *ifactory;
	gchar *stdin_data = NULL;
	
	bindtextdomain(PACKAGE, LOCALEDIR);			//bindtextdomain ??
	bind_textdomain_codeset(PACKAGE, "UTF-8");		// ??
	textdomain(PACKAGE);					// ??
	
	pub = g_malloc(sizeof(PublicData));			
	pub->fi = g_malloc(sizeof(FileInfo));
	pub->fi->filename     = NULL;
	pub->fi->charset      = NULL;
	pub->fi->charset_flag = FALSE;
	pub->fi->lineend      = LF;
	
	parse_args(argc, argv, pub->fi);
	
	gtk_init(&argc, &argv);					//call before using any gtk fuction
	g_set_application_name(PACKAGE_NAME);
	g_print("%s\n", PACKAGE_NAME);
	
#if !GTK_CHECK_VERSION(2, 6, 0)
	add_about_stock();
#endif
	
	pub->mw = create_main_window();			//Find create_main_window
	
	conf = g_malloc(sizeof(Conf));				//sends default vlues to load and overwrites in the function
	conf->width       = 600;
	conf->height      = 400;
	conf->fontname    = g_strdup("Monospace 12");
	conf->wordwrap    = FALSE;
	conf->linenumbers = FALSE;
	conf->autoindent  = FALSE;
	
	load_config_file(conf);
	//gtk options for GUI
	gtk_window_set_default_size(
		GTK_WINDOW(pub->mw->window), conf->width, conf->height);
	set_text_font_by_name(pub->mw->view, conf->fontname);
	
	ifactory = gtk_item_factory_from_widget(pub->mw->menubar);
	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(
		gtk_item_factory_get_widget(ifactory, "/Options/Word Wrap")),
		conf->wordwrap);
	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(
		gtk_item_factory_get_widget(ifactory, "/Options/Line Numbers")),
		conf->linenumbers);
	indent_refresh_tab_width(pub->mw->view);
	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(
		gtk_item_factory_get_widget(ifactory, "/Options/Auto Indent")),
		conf->autoindent);
	
	gtk_widget_show_all(pub->mw->window);
	g_free(conf->fontname);
	g_free(conf);
	
#ifdef ENABLE_EMACS
	check_emacs_key_theme(GTK_WINDOW(pub->mw->window), ifactory);
#endif
	
	hlight_init(pub->mw->buffer);
	undo_init(pub->mw->view,
		gtk_item_factory_get_widget(ifactory, "/Edit/Undo"),
		gtk_item_factory_get_widget(ifactory, "/Edit/Redo"));
//	hlight_init(pub->mw->buffer);
	dnd_init(pub->mw->view);
	
	if (pub->fi->filename)
		file_open_real(pub->mw->view, pub->fi);
#ifdef G_OS_UNIX
	else
		stdin_data = gedit_utils_get_stdin();
#endif
	if (stdin_data) {
		gchar *str;
		GtkTextIter iter;
		
		str = g_convert(stdin_data, -1, "UTF-8",
			get_default_charset(), NULL, NULL, NULL);
		g_free(stdin_data);
	
//		gtk_text_buffer_set_text(buffer, "", 0);
		gtk_text_buffer_get_start_iter(pub->mw->buffer, &iter);
		gtk_text_buffer_insert(pub->mw->buffer, &iter, str, strlen(str));
		gtk_text_buffer_get_start_iter(pub->mw->buffer, &iter);
		gtk_text_buffer_place_cursor(pub->mw->buffer, &iter);
		gtk_text_buffer_set_modified(pub->mw->buffer, FALSE);
		gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(pub->mw->view), &iter, 0, FALSE, 0, 0);
		g_free(str);
	}
	
	if (jump_linenum) {
		GtkTextIter iter;
		
		gtk_text_buffer_get_iter_at_line(pub->mw->buffer, &iter, jump_linenum - 1);
		gtk_text_buffer_place_cursor(pub->mw->buffer, &iter);
//		gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(textview), &iter, 0.1, FALSE, 0.5, 0.5);
		scroll_to_cursor(pub->mw->buffer, 0.25);
	}
	
	set_main_window_title();
//	hlight_apply_all(pub->mw->buffer);
	
	gtk_main();
	
	return 0;
}
예제 #15
0
/** Initialize the menu
 *
 * @param widget Context menu root
 * @return void
 */
void proto_help_menu_init(GtkWidget *widget)
{
	g_ph_menu_factory = gtk_item_factory_from_widget(widget);
	ph_menu_reset();
}
예제 #16
0
파일: emacs.c 프로젝트: Baltasarq/texted
static void cb_key_press_event(GtkWidget *view, GdkEventKey *event)
{
//g_print("key-release-event: 0x%X\n", event->keyval);
	if (event->keyval < 0x1000 || event->keyval == GDK_Escape) {
		switch (event->keyval) {
		case GDK_f:
		case GDK_F:
		case GDK_v:
		case GDK_V:
			if (event->state & GDK_CONTROL_MASK)
				on_file_open();
			else
				gdk_beep();
			break;
		case GDK_d:
		case GDK_D:
			if (event->state & GDK_CONTROL_MASK)
				gdk_beep();
			else
				on_file_open();
			break;
		case GDK_s:
		case GDK_S:
			if (GTK_WIDGET_IS_SENSITIVE(gtk_item_factory_get_widget(
				gtk_item_factory_from_widget(pub->mw->menubar), "/File/Save")
				))
				on_file_save();
			break;
		case GDK_w:
		case GDK_W:
			if (event->state & GDK_CONTROL_MASK)
				on_file_save_as();
			else
				gdk_beep();
			break;
		case GDK_k:
		case GDK_K:
			if (event->state & GDK_CONTROL_MASK)
				gdk_beep();
			else
				on_file_close();
			break;
		case GDK_c:
		case GDK_C:
			if (event->state & GDK_CONTROL_MASK)
				on_file_quit();
			else
				gdk_beep();
			break;
		case GDK_u:
		case GDK_U:
			if (event->state & GDK_CONTROL_MASK)
				gdk_beep();
			else
				on_edit_undo();
			break;
		case GDK_h:
		case GDK_H:
			if (event->state & GDK_CONTROL_MASK)
				gdk_beep();
			else
				on_edit_select_all();
			break;
		default:
			gdk_beep();
		}
		gtk_main_quit();
	}
}