Пример #1
0
GtkWidget* eee_account_wizard_page(EPlugin *epl, EConfigHookItemFactoryData *data)
{
    GtkWidget *page, *panel, *section, *checkbutton_status, *label;

    char *title = _("3e Calendar Account");
    assistant = GTK_ASSISTANT(data->parent);

    if (data->old)
        return data->old;

    page = gtk_vbox_new (FALSE, 12);
    gtk_container_set_border_width (GTK_CONTAINER (page), 12);
    // toplevel vbox contains frames that group 3E account settings into various
    // groups

    // Status group
    section = add_section(page, _("Enable 3e calendar account"));
//    char* note = g_strdup(_("3e calendar server has been found for your domain. You can enable\n"
//                            "calendar account if you have it. If you don't know ask your system\n"
//                            "administrator or provider of your email service. Go to email account\n"
//                            "preferences to change this setting later."));
    label = GTK_WIDGET(g_object_new(GTK_TYPE_LABEL, 
             "label", "", 
             "use-markup", TRUE,
             "justify", GTK_JUSTIFY_LEFT, 
             "xalign", 0, 
             "yalign", 0.5, 
             NULL));
//    g_free(note);
    lbl = (GtkLabel*)label;

    gtk_box_pack_start(GTK_BOX(section), label, FALSE, FALSE, 0);

    checkbutton_status = gtk_check_button_new_with_label(_("Enable 3e calendar account"));
    gtk_widget_set_can_focus (checkbutton_status, FALSE);
    gtk_box_pack_start(GTK_BOX(section), checkbutton_status, FALSE, FALSE, 0);

    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_status), TRUE);
    g_signal_connect(checkbutton_status, "toggled", G_CALLBACK(wizard_chb_status_changed), (gpointer)title);

    gtk_widget_show_all(page);

    gtk_assistant_append_page(GTK_ASSISTANT(data->parent), page);
    gtk_assistant_set_page_title (GTK_ASSISTANT(data->parent), page, title);
    gtk_assistant_set_page_type (GTK_ASSISTANT(data->parent), page, GTK_ASSISTANT_PAGE_CONTENT);	

//    g_object_set_data((GObject *)data->parent, "restore", GINT_TO_POINTER(FALSE));
    
    return GTK_WIDGET(page);
}
Пример #2
0
static void create_icon (WindowckPlugin *wckp)
{
    wckp->icon = g_slice_new0 (WindowIcon);
    wckp->icon->eventbox = GTK_EVENT_BOX (gtk_event_box_new());
    wckp->icon->symbol = NULL;

    gtk_widget_set_can_focus (GTK_WIDGET(wckp->icon->eventbox), TRUE);

    gtk_event_box_set_visible_window (wckp->icon->eventbox, FALSE);

    gtk_box_pack_start (GTK_BOX (wckp->hvbox), GTK_WIDGET(wckp->icon->eventbox), FALSE, FALSE, 0);

    create_symbol (wckp);
}
Пример #3
0
static void gtk_sys_menu_init (GtkSysMenu *menu)
{
	menu->priv = GTK_SYS_MENU_GET_PRIVATE (menu);
    gtk_widget_set_can_focus (GTK_WIDGET(menu), TRUE);
    gtk_widget_set_receives_default (GTK_WIDGET(menu), TRUE);
    gtk_widget_set_has_window (GTK_WIDGET(menu), FALSE); 
	menu->priv->start  = 0;
	menu->priv->end    = 0;
	menu->priv->amount = 0;
	menu->priv->hover  = -1;
	menu->priv->exceed = FALSE;
	menu->priv->children = NULL;
	menu->priv->selected = -1;
}
Пример #4
0
static GtkWidget *
glide_window_make_embed ()
{
  GtkWidget *embed = gtk_clutter_embed_new ();
  
  // TODO: Leaks signal.
  g_signal_connect (embed, "enter-notify-event",
		    G_CALLBACK (glide_window_stage_enter_notify),
		    NULL);
  
  gtk_widget_set_can_focus (embed, TRUE);
  
  return embed;
}
Пример #5
0
static void notebook_init(Notebook *notebook)
{
  notebook -> tabs_showed = TRUE;
  
  GtkWidget *nb = GTK_WIDGET(notebook);
  
  gtk_notebook_set_group_name(GTK_NOTEBOOK(nb), "main_tabs");
  gtk_notebook_set_scrollable(GTK_NOTEBOOK(nb), TRUE);
  
  
  gtk_widget_set_can_focus(nb, FALSE);
  //gtk_widget_set_size_request(nb, 200, 200);
  //gtk_window_resize(GTK_NOTEBOOK(nb), 600, 450);
}
Пример #6
0
src_view___::src_view___(GtkWidget* scrolled2, void* window):view___(scrolled2, window) {
	buf_ = GTK_SOURCE_BUFFER (gtk_source_buffer_new (NULL));

	widget_ = gtk_source_view_new_with_buffer(buf_);
	gtk_container_add (GTK_CONTAINER (scrolled2), widget_);

	GtkSourceView* sv = handle__();
	gtk_source_view_set_show_line_numbers(sv, true);
	gtk_source_view_set_tab_width(sv, 4);
	gtk_source_view_set_auto_indent (sv, true);
	gtk_source_view_set_smart_home_end(sv, GTK_SOURCE_SMART_HOME_END_ALWAYS);
	gtk_source_view_set_draw_spaces (sv, GTK_SOURCE_DRAW_SPACES_ALL);
	gtk_widget_set_can_focus(widget_, true);
}
Пример #7
0
static void
gnucash_register_init (GnucashRegister *g_reg)
{
    GtkGrid *table = GTK_GRID(g_reg);

    gtk_widget_set_can_focus (GTK_WIDGET(table), FALSE);
    gtk_widget_set_can_default (GTK_WIDGET(table), FALSE);

    // This sets a style class for when Gtk+ version is less than 3.20
    gnc_widget_set_css_name (GTK_WIDGET(g_reg), "register");

    gtk_grid_set_row_homogeneous (GTK_GRID(table), FALSE);
    gtk_grid_set_column_homogeneous (GTK_GRID(table), FALSE);
}
Пример #8
0
static void
gtk_tool_item_init (GtkToolItem *toolitem)
{
    gtk_widget_set_can_focus (GTK_WIDGET (toolitem), FALSE);

    toolitem->priv = GTK_TOOL_ITEM_GET_PRIVATE (toolitem);

    toolitem->priv->visible_horizontal = TRUE;
    toolitem->priv->visible_vertical = TRUE;
    toolitem->priv->homogeneous = FALSE;
    toolitem->priv->expand = FALSE;

    toolitem->priv->use_action_appearance = TRUE;
}
Пример #9
0
static void
add_dns_row (CEPageIP6   *page,
             const gchar *address)
{
        GtkWidget *row;
        GtkWidget *row_box;
        GtkWidget *label;
        GtkWidget *widget;
        GtkWidget *delete_button;
        GtkWidget *image;

        row = gtk_list_box_row_new ();
        gtk_widget_set_can_focus (row, FALSE);

        row_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
        label = gtk_label_new (_("Server"));
        gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);
        gtk_box_pack_start (GTK_BOX (row_box), label, FALSE, FALSE, 0);
        widget = gtk_entry_new ();
        gtk_label_set_mnemonic_widget (GTK_LABEL (label), widget);
        g_signal_connect_swapped (widget, "changed", G_CALLBACK (ce_page_changed), page);
        g_object_set_data (G_OBJECT (row), "address", widget);
        gtk_entry_set_text (GTK_ENTRY (widget), address);
        gtk_widget_set_margin_left (widget, 10);
        gtk_widget_set_margin_right (widget, 10);
        gtk_widget_set_hexpand (widget, TRUE);
        gtk_box_pack_start (GTK_BOX (row_box), widget, TRUE, TRUE, 0);

        delete_button = gtk_button_new ();
        gtk_style_context_add_class (gtk_widget_get_style_context (delete_button), "image-button");
        g_signal_connect (delete_button, "clicked", G_CALLBACK (remove_row), page);
        image = gtk_image_new_from_icon_name ("user-trash-symbolic", GTK_ICON_SIZE_MENU);
        atk_object_set_name (gtk_widget_get_accessible (delete_button), _("Delete DNS Server"));
        gtk_button_set_image (GTK_BUTTON (delete_button), image);
        gtk_box_pack_start (GTK_BOX (row_box), delete_button, FALSE, FALSE, 0);
        g_object_set_data (G_OBJECT (row), "delete-button", delete_button);

        gtk_widget_set_margin_left (row_box, 10);
        gtk_widget_set_margin_right (row_box, 10);
        gtk_widget_set_margin_top (row_box, 10);
        gtk_widget_set_margin_bottom (row_box, 10);
        gtk_widget_set_halign (row_box, GTK_ALIGN_FILL);

        gtk_container_add (GTK_CONTAINER (row), row_box);
        gtk_widget_show_all (row);
        gtk_container_add (GTK_CONTAINER (page->dns_list), row);

        update_row_sensitivity (page, page->dns_list);
}
Пример #10
0
static void sp_button_init(SPButton *button)
{
    button->action = NULL;
    button->doubleclick_action = NULL;
    new (&button->c_set_active) sigc::connection();
    new (&button->c_set_sensitive) sigc::connection();

    gtk_container_set_border_width(GTK_CONTAINER(button), 0);

    gtk_widget_set_can_focus(GTK_WIDGET(button), FALSE);
    gtk_widget_set_can_default(GTK_WIDGET(button), FALSE);

    g_signal_connect_after(G_OBJECT(button), "clicked", G_CALLBACK(sp_button_perform_action), NULL);
    g_signal_connect_after(G_OBJECT(button), "event", G_CALLBACK(sp_button_process_event), NULL);
}
Пример #11
0
static gboolean 
panel_applet_focus (GtkWidget        *widget,
		    GtkDirectionType  dir)
{
	gboolean ret;
	GtkWidget *previous_focus_child;

	g_return_val_if_fail (PANEL_IS_APPLET (widget), FALSE);

	previous_focus_child = gtk_container_get_focus_child (GTK_CONTAINER (widget));
	if (!previous_focus_child && !gtk_widget_has_focus (widget)) {
		if (gtk_widget_get_has_tooltip (widget)) {
			gtk_widget_set_can_focus (widget, TRUE);
			gtk_widget_grab_focus (widget);
			gtk_widget_set_can_focus (widget, FALSE);
			return TRUE;
		}
	}
	ret = GTK_WIDGET_CLASS (panel_applet_parent_class)->focus (widget, dir);

	if (!ret && !previous_focus_child) {
		if (!gtk_widget_has_focus (widget))  {
			/*
			 * Applet does not have a widget which can focus so set
			 * the focus on the applet unless it already had focus
			 * because it had a tooltip.
			 */ 
			gtk_widget_set_can_focus (widget, TRUE);
			gtk_widget_grab_focus (widget);
			gtk_widget_set_can_focus (widget, FALSE);
			ret = TRUE;
		}
	}

	return ret;
}
Пример #12
0
static void
populate_flowbox_buttons (GtkFlowBox *flowbox)
{
  GtkWidget *widget;
  gint i;

  for (i = 0; i < 50; i++)
    {
      widget = gtk_button_new_with_label ("Button");
      gtk_widget_show (widget);
      gtk_container_add (GTK_CONTAINER (flowbox), widget);
      widget = gtk_widget_get_parent (widget);
      gtk_widget_set_can_focus (widget, FALSE);
    }
}
Пример #13
0
void
InterfaceGtk::main(int &argc, char **&argv)
{
	GtkWidget *vbox;
	GtkWidget *info_content;

	gtk_init(&argc, &argv);

	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title(GTK_WINDOW(window), PACKAGE_NAME);
	g_signal_connect(G_OBJECT(window), "delete-event",
			 G_CALLBACK(exit_app), NULL);

	vbox = gtk_vbox_new(FALSE, 0);

	editor_widget = scintilla_new();
	scintilla_set_id(SCINTILLA(editor_widget), 0);
	gtk_widget_set_usize(editor_widget, 500, 300);
	gtk_widget_set_can_focus(editor_widget, FALSE);
	g_signal_connect(G_OBJECT(editor_widget), SCINTILLA_NOTIFY,
			 G_CALLBACK(scintilla_notify), NULL);
	gtk_box_pack_start(GTK_BOX(vbox), editor_widget, TRUE, TRUE, 0);

	info_widget = gtk_info_bar_new();
	info_content = gtk_info_bar_get_content_area(GTK_INFO_BAR(info_widget));
	message_widget = gtk_label_new("");
	gtk_misc_set_alignment(GTK_MISC(message_widget), 0., 0.);
	gtk_container_add(GTK_CONTAINER(info_content), message_widget);
	gtk_box_pack_start(GTK_BOX(vbox), info_widget, FALSE, FALSE, 0);

	cmdline_widget = gtk_entry_new();
	gtk_entry_set_has_frame(GTK_ENTRY(cmdline_widget), FALSE);
	gtk_editable_set_editable(GTK_EDITABLE(cmdline_widget), FALSE);
	widget_set_font(cmdline_widget, "Courier");
	g_signal_connect(G_OBJECT(cmdline_widget), "key-press-event",
			 G_CALLBACK(cmdline_key_pressed), NULL);
	gtk_box_pack_start(GTK_BOX(vbox), cmdline_widget, FALSE, FALSE, 0);

	gtk_container_add(GTK_CONTAINER(window), vbox);

	popup_widget = gtk_info_popup_new(cmdline_widget);

	gtk_widget_grab_focus(cmdline_widget);

	ssm(SCI_SETFOCUS, TRUE);

	cmdline_update("");
}
Пример #14
0
static void gtk_service_init(GtkService *service)
{
	GtkServicePrivate *priv;

	priv =  G_TYPE_INSTANCE_GET_PRIVATE(service,
						GTK_TYPE_SERVICE,
						GtkServicePrivate);
	service->priv = priv;

	priv->box = (GtkBox *) gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 10);

	priv->name = (GtkLabel *) gtk_label_new(NULL);
	priv->state = (GtkImage *) gtk_image_new();
	priv->security = (GtkImage *) gtk_image_new();
	priv->signal = (GtkImage *) gtk_image_new();

	priv->selected = FALSE;

	//gtk_widget_set_halign((GtkWidget *)priv->box, GTK_ALIGN_START);
	gtk_widget_set_halign((GtkWidget *)priv->name, GTK_ALIGN_START);

	gtk_widget_set_halign((GtkWidget *)priv->state, GTK_ALIGN_END);
	gtk_widget_set_halign((GtkWidget *)priv->security, GTK_ALIGN_END);
	gtk_widget_set_halign((GtkWidget *)priv->signal, GTK_ALIGN_END);

	gtk_box_set_homogeneous(priv->box, FALSE);

	gtk_box_pack_start(priv->box,
			(GtkWidget *)priv->name, TRUE, TRUE, 0);

	gtk_box_pack_start(priv->box,
			(GtkWidget *) priv->state, TRUE, TRUE, 0);
	gtk_box_pack_start(priv->box,
			(GtkWidget *) priv->security, TRUE, TRUE, 0);
	gtk_box_pack_start(priv->box,
			(GtkWidget *) priv->signal, TRUE, TRUE, 0);

	gtk_widget_set_visible((GtkWidget *)priv->box, TRUE);
	gtk_widget_set_visible((GtkWidget *)priv->name, TRUE);

	gtk_widget_set_visible((GtkWidget *)priv->state, FALSE);
	gtk_widget_set_visible((GtkWidget *)priv->security, FALSE);
	gtk_widget_set_visible((GtkWidget *)priv->signal, FALSE);

	gtk_container_add(GTK_CONTAINER(service), (GtkWidget *)priv->box);

	gtk_widget_set_can_focus((GtkWidget *)priv->box, TRUE);
}
Пример #15
0
static void
bytes_view_init(BytesView *bv)
{
#ifdef WANT_PACKET_EDITOR
	gtk_widget_set_can_focus(GTK_WIDGET(bv), TRUE);
#endif
	bv->context = NULL;

	bv->encoding = PACKET_CHAR_ENC_CHAR_ASCII;
	bv->format = BYTES_HEX;

	bv->per_line = 16;
	bv->use_digits = 4;

	bv->max_width = 0;
}
Пример #16
0
static GtkWidget *
create_box (GtkWidget *term)
{
	GtkWidget *sb, *hbox;
	
	sb = gtk_vscrollbar_new (GTK_ADJUSTMENT (vte_terminal_get_adjustment (VTE_TERMINAL (term))));
	gtk_widget_set_can_focus (sb, FALSE);

	hbox = gtk_hbox_new (FALSE, 0);
	gtk_box_pack_start (GTK_BOX (hbox), term, TRUE, TRUE, 0);
	gtk_box_pack_start (GTK_BOX (hbox), sb, FALSE, TRUE, 0);
	
	g_object_ref_sink (hbox);
	
	return hbox;
}	
Пример #17
0
static void
ide_terminal_page_init (IdeTerminalPage *self)
{
  GtkStyleContext *style_context;

  self->close_on_exit = TRUE;
  self->respawn_on_exit = TRUE;
  self->manage_spawn = TRUE;

  self->tsearch = g_object_new (IDE_TYPE_TERMINAL_SEARCH,
                                "visible", TRUE,
                                NULL);
  self->search_revealer_top = ide_terminal_search_get_revealer (self->tsearch);

  gtk_widget_init_template (GTK_WIDGET (self));

  g_signal_connect_object (self->terminal_top,
                           "text-inserted",
                           G_CALLBACK (ide_terminal_page_on_text_inserted_cb),
                           self,
                           G_CONNECT_SWAPPED);

  ide_page_set_icon_name (IDE_PAGE (self), "utilities-terminal-symbolic");
  ide_page_set_can_split (IDE_PAGE (self), TRUE);
  ide_page_set_menu_id (IDE_PAGE (self), "ide-terminal-page-document-menu");

  gtk_overlay_add_overlay (self->terminal_overlay_top, GTK_WIDGET (self->tsearch));

  ide_terminal_page_connect_terminal (self, VTE_TERMINAL (self->terminal_top));

  ide_terminal_search_set_terminal (self->tsearch, VTE_TERMINAL (self->terminal_top));

  ide_terminal_page_actions_init (self);

  style_context = gtk_widget_get_style_context (GTK_WIDGET (self->terminal_top));
  gtk_style_context_add_class (style_context, "terminal");
  g_signal_connect_object (style_context,
                           "changed",
                           G_CALLBACK (style_context_changed),
                           self,
                           0);
  style_context_changed (style_context, self);

  gtk_widget_set_can_focus (GTK_WIDGET (self->terminal_top), TRUE);

  ide_widget_set_context_handler (self, ide_terminal_page_context_set);
}
Пример #18
0
static GtkWidget*
create_zoom_widget(DDisplay *ddisp) { 
  GtkWidget *combo;
  GtkWidget *entry;
  GtkWidget *menu;
  GtkWidget *button;
  GtkWidget *arrow;

  combo = gtk_hbox_new(FALSE, 0);
  entry = gtk_entry_new();
  g_signal_connect (G_OBJECT (entry), "activate",
		    G_CALLBACK(zoom_activate_callback),
		      ddisp);
  gtk_box_pack_start(GTK_BOX(combo), entry, TRUE, TRUE, 0);
  g_object_set_data (G_OBJECT(combo), "user_data", entry);
  gtk_entry_set_width_chars(GTK_ENTRY(entry), 8);
  gtk_widget_show(entry);

  button = gtk_button_new();
#if GTK_CHECK_VERSION(2,18,0)
  gtk_widget_set_can_focus (GTK_WIDGET (button), FALSE);
#else
  GTK_WIDGET_UNSET_FLAGS(button, GTK_CAN_FOCUS);
#endif
  arrow = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_OUT);
  gtk_container_add(GTK_CONTAINER(button), arrow);
  gtk_box_pack_start(GTK_BOX(combo), button, TRUE, TRUE, 0);
  g_object_set_data (G_OBJECT(combo), "user_data", entry);
  gtk_widget_show_all(button);

  menu = gtk_menu_new();
  zoom_add_zoom_amount(menu, "800%", ddisp);
  zoom_add_zoom_amount(menu, "400%", ddisp);
  zoom_add_zoom_amount(menu, "200%", ddisp);
  zoom_add_zoom_amount(menu, "100%", ddisp);
  zoom_add_zoom_amount(menu, "50%", ddisp);
  zoom_add_zoom_amount(menu, "25%", ddisp);
  zoom_add_zoom_amount(menu, "12%", ddisp);

  gtk_widget_show_all(menu);

  g_signal_connect (G_OBJECT (button), "button_press_event",
		    G_CALLBACK(zoom_popup_menu),
		      menu);

  return combo;
}
Пример #19
0
/**
 * gs_shell_overview_get_categories_cb:
 **/
static void
gs_shell_overview_get_categories_cb (GObject *source_object,
				     GAsyncResult *res,
				     gpointer user_data)
{
	GsShellOverview *self = GS_SHELL_OVERVIEW (user_data);
	GsShellOverviewPrivate *priv = gs_shell_overview_get_instance_private (self);
	GsPluginLoader *plugin_loader = GS_PLUGIN_LOADER (source_object);
	GList *l;
	GsCategory *cat;
	GtkWidget *tile;
	gboolean has_category = FALSE;
	g_autoptr(GError) error = NULL;
	g_autoptr(GsAppList) list = NULL;

	list = gs_plugin_loader_get_categories_finish (plugin_loader, res, &error);
	if (list == NULL) {
		if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
			g_warning ("failed to get categories: %s", error->message);
		goto out;
	}
	gs_container_remove_all (GTK_CONTAINER (priv->flowbox_categories));

	for (l = list; l; l = l->next) {
		cat = GS_CATEGORY (l->data);
		if (gs_category_get_size (cat) == 0)
			continue;
		tile = gs_category_tile_new (cat);
		g_signal_connect (tile, "clicked",
				  G_CALLBACK (category_tile_clicked), self);
		gtk_flow_box_insert (GTK_FLOW_BOX (priv->flowbox_categories), tile, -1);
		gtk_widget_set_can_focus (gtk_widget_get_parent (tile), FALSE);
		has_category = TRUE;
	}
out:
	if (has_category) {
		priv->empty = FALSE;
	}
	gtk_widget_set_visible (priv->category_heading, has_category);

	priv->loading_categories = FALSE;
	priv->refresh_count--;
	if (priv->refresh_count == 0) {
		priv->cache_valid = TRUE;
		g_signal_emit (self, signals[SIGNAL_REFRESHED], 0);
	}
}
Пример #20
0
void chat_init(Chat *chat)
{
  GtkTextBuffer *buff;

  gtk_table_resize(GTK_TABLE(chat), 3, 3);

  chat->text_view = gtk_text_view_new();
  gtk_widget_set_can_focus(chat->text_view, FALSE);

  buff = gtk_text_view_get_buffer(GTK_TEXT_VIEW(chat->text_view));

  gtk_text_view_set_editable(GTK_TEXT_VIEW(chat->text_view), FALSE);
  gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(chat->text_view), FALSE);

  chat->scroll = gtk_scrolled_window_new(NULL, NULL);
  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(chat->scroll),
                                 GTK_POLICY_AUTOMATIC,
                                 GTK_POLICY_AUTOMATIC);
  gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(chat->scroll),
                                      GTK_SHADOW_IN);

  gtk_container_add(GTK_CONTAINER(chat->scroll), chat->text_view);

  gtk_table_attach(GTK_TABLE(chat), chat->scroll, 0, 1, 0, 1,
                   GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 0, 0);

  chat->entry = gtk_entry_new();
  gtk_signal_connect(GTK_OBJECT(chat->entry), "key-press-event",
                     G_CALLBACK(chat_on_keypress), chat);
  gtk_widget_add_events (chat->entry, GDK_KEY_PRESS_MASK);
  gtk_table_attach(GTK_TABLE(chat), chat->entry, 0, 1, 1, 2,
                   GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);

  gtk_text_buffer_create_tag(buff, "normal", NULL);
  gtk_text_buffer_create_tag(buff, "good", "foreground", "#00AA00", NULL);
  gtk_text_buffer_create_tag(buff, "bad", "foreground", "#AA0000", NULL);
  gtk_text_buffer_create_tag(buff, "info", "foreground", "#333399", NULL);
  gtk_text_buffer_create_tag(buff, "error", "foreground", "#AA0000", NULL);

  g_signal_connect(G_OBJECT(buff), "insert-text",
                   G_CALLBACK(chat_scroll_to_end), chat);

  chat->history = NULL;
  chat->history_current = NULL;
  chat->in_history = FALSE;
}
Пример #21
0
static void create_vte(void)
{
	GtkWidget *vte, *scrollbar, *hbox, *frame;

	vc->vte = vte = vf->vte_terminal_new();
	scrollbar = gtk_vscrollbar_new(GTK_ADJUSTMENT(VTE_TERMINAL(vte)->adjustment));
	gtk_widget_set_can_focus(scrollbar, FALSE);

	/* create menu now so copy/paste shortcuts work */
	vc->menu = vte_create_popup_menu();
	g_object_ref_sink(vc->menu);

	frame = gtk_frame_new(NULL);

	hbox = gtk_hbox_new(FALSE, 0);
	gtk_container_add(GTK_CONTAINER(frame), hbox);
	gtk_box_pack_start(GTK_BOX(hbox), vte, TRUE, TRUE, 0);
	gtk_box_pack_start(GTK_BOX(hbox), scrollbar, FALSE, FALSE, 0);

	/* set the default widget size first to prevent VTE expanding too much,
	 * sometimes causing the hscrollbar to be too big or out of view. */
	gtk_widget_set_size_request(GTK_WIDGET(vte), 10, 10);
	vf->vte_terminal_set_size(VTE_TERMINAL(vte), 30, 1);

	vf->vte_terminal_set_mouse_autohide(VTE_TERMINAL(vte), TRUE);
	vf->vte_terminal_set_word_chars(VTE_TERMINAL(vte), VTE_WORDCHARS);

	gtk_drag_dest_set(vte, GTK_DEST_DEFAULT_ALL,
		dnd_targets, G_N_ELEMENTS(dnd_targets), GDK_ACTION_COPY);

	g_signal_connect(vte, "child-exited", G_CALLBACK(vte_start), NULL);
	g_signal_connect(vte, "button-press-event", G_CALLBACK(vte_button_pressed), NULL);
	g_signal_connect(vte, "event", G_CALLBACK(vte_keypress_cb), NULL);
	g_signal_connect(vte, "key-release-event", G_CALLBACK(vte_keyrelease_cb), NULL);
	g_signal_connect(vte, "commit", G_CALLBACK(vte_commit_cb), NULL);
	g_signal_connect(vte, "motion-notify-event", G_CALLBACK(on_motion_event), NULL);
	g_signal_connect(vte, "drag-data-received", G_CALLBACK(vte_drag_data_received), NULL);

	vte_start(vte);

	gtk_widget_show_all(frame);
	gtk_notebook_insert_page(GTK_NOTEBOOK(msgwindow.notebook), frame, gtk_label_new(_("Terminal")), MSG_VTE);

	g_signal_connect_after(vte, "realize", G_CALLBACK(on_vte_realize), NULL);
}
Пример #22
0
int
main (int argc, char *argv[])
{
	set_log_handlers();

	wf_debug = 1;

	gtk_init(&argc, &argv);
	GdkGLConfig* glconfig;
	if(!(glconfig = gdk_gl_config_new_by_mode(GDK_GL_MODE_RGBA | GDK_GL_MODE_DEPTH | GDK_GL_MODE_DOUBLE))){
		gerr ("Cannot initialise gtkglext."); return EXIT_FAILURE;
	}

	GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

	canvas = gtk_drawing_area_new();
	gtk_widget_set_can_focus     (canvas, true);
	gtk_widget_set_size_request  (canvas, GL_WIDTH + 2 * HBORDER, 128);
	gtk_widget_set_gl_capability (canvas, glconfig, NULL, 1, GDK_GL_RGBA_TYPE);
	gtk_widget_add_events        (canvas, GDK_POINTER_MOTION_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
	gtk_container_add((GtkContainer*)window, (GtkWidget*)canvas);

	agl = agl_get_instance();

	scene = (AGlRootActor*)agl_actor__new_root(canvas);

	wfc = wf_canvas_new((AGlRootActor*)scene);

	char* filename = find_wav(WAV);
	w1 = waveform_load_new(filename);
	g_free(filename);

	g_signal_connect((gpointer)canvas, "realize",       G_CALLBACK(on_canvas_realise), NULL);
	g_signal_connect((gpointer)canvas, "size-allocate", G_CALLBACK(on_allocate), NULL);
	g_signal_connect((gpointer)canvas, "expose-event",  G_CALLBACK(agl_actor__on_expose), scene);

	gtk_widget_show_all(window);

	add_key_handlers((GtkWindow*)window, NULL, (Key*)&keys);

	gboolean window_on_delete(GtkWidget* widget, GdkEvent* event, gpointer user_data){
		gtk_main_quit();
		return false;
	}
Пример #23
0
GtkWidget* eee_account_wizard_page(EPlugin *epl, EConfigHookItemFactoryData *data)
{
    GtkWidget *page, *panel, *section, *checkbutton_status, *label;

    char *title = _("3e Calendar Account");
    assistant = GTK_ASSISTANT(data->parent);

    if (data->old)
        return data->old;

    page = gtk_vbox_new (FALSE, 12);
    gtk_container_set_border_width (GTK_CONTAINER (page), 12);
    // toplevel vbox contains frames that group 3E account settings into various
    // groups

    // Status group
    section = add_section(page, _("Enable 3e calendar account"));

    label = gtk_label_new (NULL);
    gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
    gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);

    lbl = GTK_LABEL (label);

    gtk_box_pack_start(GTK_BOX(section), label, FALSE, FALSE, 0);

    checkbutton_status = gtk_check_button_new_with_label(_("Enable 3e calendar account"));
    gtk_widget_set_can_focus (checkbutton_status, FALSE);
    gtk_box_pack_start(GTK_BOX(section), checkbutton_status, FALSE, FALSE, 0);

    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbutton_status), TRUE);
    g_signal_connect(checkbutton_status, "toggled", G_CALLBACK(wizard_chb_status_changed), (gpointer)title);

    gtk_widget_show_all(page);

    gtk_assistant_append_page(GTK_ASSISTANT(data->parent), page);
    gtk_assistant_set_page_title (GTK_ASSISTANT(data->parent), page, title);
    gtk_assistant_set_page_type (GTK_ASSISTANT(data->parent), page, GTK_ASSISTANT_PAGE_CONTENT);	

//    g_object_set_data((GObject *)data->parent, "restore", GINT_TO_POINTER(FALSE));
    
    return page;
}
Пример #24
0
/* Cut and paste from gtkwindow.c */
static void
ccombo_focus_change (GtkWidget *widget, gboolean in)
{
	GdkEventFocus fevent;

	g_object_ref (widget);

	gtk_widget_set_can_focus (widget, in);

	fevent.type = GDK_FOCUS_CHANGE;
	fevent.window = gtk_widget_get_window (widget);
	fevent.in = in;

	gtk_widget_event (widget, (GdkEvent *)&fevent);

	g_object_notify (G_OBJECT (widget), "has-focus");

	g_object_unref (widget);
}
Пример #25
0
static void
gcal_event_widget_init (GcalEventWidget *self)
{
  GtkWidget *widget;

  widget = GTK_WIDGET (self);
  self->clock_format_24h = is_clock_format_24h ();

  gtk_widget_init_template (widget);

  gtk_widget_set_can_focus (widget, TRUE);
  gtk_widget_set_has_window (widget, FALSE);

  /* Setup the event widget as a drag source */
  set_drag_source_enabled (self, TRUE);

  /* Starts with horizontal */
  self->orientation = GTK_ORIENTATION_HORIZONTAL;
  gtk_style_context_add_class (gtk_widget_get_style_context (widget), "horizontal");
}
Пример #26
0
static gboolean
move_window (GtkWidget *widget, GdkEventButton *event, gpointer user_data)
{
    g_debug ("installer:move window");
    if (event->y > 50 || (event->x > 740) && (event->y < 50)) {
        return TRUE;
    }
    if (event->button == 1) {
        g_debug ("move window:in drag x_root->%g, y_root->%g", event->x_root, event->y_root);
        gtk_widget_set_can_focus (widget, TRUE);
        gtk_widget_grab_focus (widget);

        gtk_window_begin_move_drag (GTK_WINDOW (widget),
                                    event->button,
                                    event->x_root,
                                    event->y_root,
                                    event->time);
    }
    return FALSE;
}
Пример #27
0
/**
 * gnm_cell_combo_view_new:
 * @so: #SheetObject
 * @type: #GType
 * @container: SheetObjectViewContainer (a GnmPane)
 *
 * Create and register an in cell combo to pick from an autofilter list.
 **/
SheetObjectView *
gnm_cell_combo_view_new (SheetObject *so, GType type,
			     SheetObjectViewContainer *container)
{
	GnmPane *pane = GNM_PANE (container);
	GtkWidget *view_widget = gtk_button_new ();
	GocItem *ccombo = goc_item_new (pane->object_views, type, NULL);
	goc_item_new (GOC_GROUP (ccombo), GOC_TYPE_WIDGET,
		"widget",	view_widget,
		NULL);
	gtk_widget_set_can_focus (view_widget, FALSE);

	gtk_container_add (GTK_CONTAINER (view_widget),
		ccombo_create_arrow (GNM_CCOMBO_VIEW (ccombo), so));
	g_signal_connect_swapped (view_widget, "pressed",
		G_CALLBACK (cb_ccombo_button_pressed), ccombo);
	gtk_widget_show_all (view_widget);

	return gnm_pane_object_register (so, ccombo, FALSE);
}
Пример #28
0
static void playlist_widget_init(PlaylistWidget *wgt)
{
	wgt->indicator_renderer = gtk_cell_renderer_text_new();
	wgt->title_renderer = gtk_cell_renderer_text_new();

	wgt->list_store = gtk_list_store_new(	3,
						G_TYPE_STRING,
						G_TYPE_STRING,
						G_TYPE_STRING );

	wgt->tree_view
		= gtk_tree_view_new_with_model(GTK_TREE_MODEL(wgt->list_store));

	wgt->indicator_column
		= gtk_tree_view_column_new_with_attributes
			(	"\xe2\x80\xa2", /* UTF-8 bullet */
				wgt->indicator_renderer,
				"text",
				0,
				NULL );

	wgt->title_column
		= gtk_tree_view_column_new_with_attributes
			(_("Playlist"), wgt->title_renderer, "text", 1, NULL);

	g_signal_connect(	wgt->tree_view,
				"button-press-event",
				G_CALLBACK(mouse_press_handler),
				NULL );

	gtk_widget_set_can_focus(GTK_WIDGET(wgt->tree_view), FALSE);
	gtk_tree_view_set_reorderable(GTK_TREE_VIEW(wgt->tree_view), TRUE);

	gtk_tree_view_append_column
		(GTK_TREE_VIEW(wgt->tree_view), wgt->indicator_column);

	gtk_tree_view_append_column
		(GTK_TREE_VIEW(wgt->tree_view), wgt->title_column);

	gtk_container_add(GTK_CONTAINER(wgt), wgt->tree_view);
}
Пример #29
0
static GtkWidget *
append_label (GtkWidget *vbox,
              const char *str)
{
    GtkWidget *label;

    label = gtk_label_new (NULL);
    gtk_label_set_markup (GTK_LABEL (label), str);
    gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
    gtk_label_set_selectable (GTK_LABEL (label), TRUE);

    /* setting can_focus to FALSE will allow to make the label
     * selectable but without the cursor showing.
     */
    gtk_widget_set_can_focus (label, FALSE);

    gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0);
    gtk_widget_show (label);

    return label;
}
Пример #30
0
static gboolean
panel_applet_button_press (GtkWidget      *widget,
			   GdkEventButton *event)
{
	PanelApplet *applet = PANEL_APPLET (widget);

	if (!container_has_focusable_child (GTK_CONTAINER (applet))) {
		if (!gtk_widget_has_focus (widget)) {
			gtk_widget_set_can_focus (widget, TRUE);
			gtk_widget_grab_focus (widget);
		}
	}

	if (event->button == 3) {
		panel_applet_menu_popup (applet, event->button, event->time);

		return TRUE;
	}

	return TRUE;
}