Esempio n. 1
0
GtkWidget*
create_window (void)
{
  GtkWidget *window;
  GtkWidget *vboxMain;
  GtkWidget *statusBar;
  GtkWidget *hbox1;
  GtkWidget *imageUri;
  GtkWidget *btnOpen;
  GtkWidget *scrolledwindow;
  GtkWidget *imgViewport;
  GtkWidget *hbox2;
  GtkWidget *imageBox;

  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_widget_set_name (window, "window");
  gtk_container_set_border_width (GTK_CONTAINER (window), 2);
  gtk_window_set_title (GTK_WINDOW (window), _("BeautyOnline"));
  gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER);
  gtk_window_set_default_size (GTK_WINDOW (window), 500, 400);
  gtk_window_set_icon_name (GTK_WINDOW (window), "stock_draw-sphere");
  gtk_window_set_urgency_hint (GTK_WINDOW (window), TRUE);

  vboxMain = gtk_vbox_new (FALSE, 2);
  gtk_widget_set_name (vboxMain, "vboxMain");
  gtk_widget_show (vboxMain);
  gtk_container_add (GTK_CONTAINER (window), vboxMain);
  gtk_container_set_border_width (GTK_CONTAINER (vboxMain), 1);

  statusBar = gtk_statusbar_new ();
  gtk_widget_set_name (statusBar, "statusBar");
  gtk_widget_show (statusBar);
  gtk_box_pack_end (GTK_BOX (vboxMain), statusBar, FALSE, TRUE, 0);

  hbox1 = gtk_hbox_new (FALSE, 0);
  gtk_widget_set_name (hbox1, "hbox1");
  gtk_widget_show (hbox1);
  gtk_box_pack_start (GTK_BOX (vboxMain), hbox1, FALSE, TRUE, 0);

  imageUri = gtk_entry_new ();
  gtk_widget_set_name (imageUri, "imageUri");
  gtk_widget_show (imageUri);
  gtk_box_pack_start (GTK_BOX (hbox1), imageUri, TRUE, TRUE, 0);
  gtk_entry_set_invisible_char (GTK_ENTRY (imageUri), 8226);

  btnOpen = gtk_button_new_with_mnemonic (_("Open"));
  gtk_widget_set_name (btnOpen, "btnOpen");
  gtk_widget_show (btnOpen);
  gtk_box_pack_start (GTK_BOX (hbox1), btnOpen, FALSE, FALSE, 0);

  scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
  gtk_widget_set_name (scrolledwindow, "scrolledwindow");
  gtk_widget_show (scrolledwindow);
  gtk_box_pack_end (GTK_BOX (vboxMain), scrolledwindow, TRUE, TRUE, 0);
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);

  imgViewport = gtk_viewport_new (NULL, NULL);
  gtk_widget_set_name (imgViewport, "imgViewport");
  gtk_widget_show (imgViewport);
  gtk_container_add (GTK_CONTAINER (scrolledwindow), imgViewport);

  hbox2 = gtk_hbox_new (TRUE, 0);
  gtk_widget_set_name (hbox2, "hbox2");
  gtk_widget_show (hbox2);
  gtk_container_add (GTK_CONTAINER (imgViewport), hbox2);

  imageBox = create_pixmap (window, NULL);
  gtk_widget_set_name (imageBox, "imageBox");
  gtk_widget_show (imageBox);
  gtk_box_pack_start (GTK_BOX (hbox2), imageBox, TRUE, FALSE, 0);
  gtk_misc_set_alignment (GTK_MISC (imageBox), 0, 0);

  g_signal_connect_swapped ((gpointer) imageUri, "activate",
                            G_CALLBACK (on_imageUri_activate),
                            GTK_OBJECT (imageBox));
  g_signal_connect_swapped ((gpointer) btnOpen, "clicked",
                            G_CALLBACK (on_btnOpen_clicked),
                            GTK_OBJECT (imageUri));

  /* Store pointers to all widgets, for use by lookup_widget(). */
  GLADE_HOOKUP_OBJECT_NO_REF (window, window, "window");
  GLADE_HOOKUP_OBJECT (window, vboxMain, "vboxMain");
  GLADE_HOOKUP_OBJECT (window, statusBar, "statusBar");
  GLADE_HOOKUP_OBJECT (window, hbox1, "hbox1");
  GLADE_HOOKUP_OBJECT (window, imageUri, "imageUri");
  GLADE_HOOKUP_OBJECT (window, btnOpen, "btnOpen");
  GLADE_HOOKUP_OBJECT (window, scrolledwindow, "scrolledwindow");
  GLADE_HOOKUP_OBJECT (window, imgViewport, "imgViewport");
  GLADE_HOOKUP_OBJECT (window, hbox2, "hbox2");
  GLADE_HOOKUP_OBJECT (window, imageBox, "imageBox");

  return window;
}
Esempio n. 2
0
ScreenInfo *
myScreenInit (DisplayInfo *display_info, GdkScreen *gscr, unsigned long event_mask, gboolean replace_wm)
{
#ifdef ENABLE_KDE_SYSTRAY_PROXY
    gchar selection[32];
#endif
    ScreenInfo *screen_info;
    GdkWindow *event_win;
    PangoLayout *layout;
    long desktop_visible;
    int i, j;

    g_return_val_if_fail (display_info, NULL);
    g_return_val_if_fail (GDK_IS_SCREEN (gscr), NULL);
    TRACE ("entering myScreenInit");

    screen_info = g_new0 (ScreenInfo, 1);
    screen_info->params = g_new0 (XfwmParams, 1);

    screen_info->display_info = display_info;
    screen_info->gscr = gscr;
    desktop_visible = 0;
    layout = NULL;

    /* Create a GTK window so that we are just like any other GTK application */
    screen_info->gtk_win = gtk_window_new (GTK_WINDOW_POPUP);
    gtk_window_set_screen (GTK_WINDOW (screen_info->gtk_win), gscr);
    gtk_window_resize (GTK_WINDOW (screen_info->gtk_win), 5, 5);
    gtk_window_move (GTK_WINDOW (screen_info->gtk_win), -1000, -1000);
    gtk_widget_set_name (screen_info->gtk_win, "xfwm");
    gtk_widget_show_now (screen_info->gtk_win);

    /*
     * The first time the first Gtk application on a display uses pango,
     * pango grabs the XServer while it creates the font cache window.
     * Therefore, force the cache window to be created now instead of
     * trying to do it while we have another grab and deadlocking the server.
     */
    layout = gtk_widget_create_pango_layout (screen_info->gtk_win, "-");
    pango_layout_get_pixel_extents (layout, NULL, NULL);
    g_object_unref (G_OBJECT (layout));

    screen_info->xscreen = gdk_x11_screen_get_xscreen (gscr);
    screen_info->xroot = (Window) GDK_DRAWABLE_XID(gdk_screen_get_root_window (gscr));
    screen_info->screen = gdk_screen_get_number (gscr);
    screen_info->cmap = GDK_COLORMAP_XCOLORMAP(gdk_screen_get_rgb_colormap (gscr));
    screen_info->depth = DefaultDepth (display_info->dpy, screen_info->screen);
    screen_info->visual = DefaultVisual (display_info->dpy, screen_info->screen);
    screen_info->shape_win = (Window) None;
    myScreenComputeSize (screen_info);

    screen_info->xfwm4_win = GDK_WINDOW_XWINDOW (screen_info->gtk_win->window);
    if (!myScreenSetWMAtom (screen_info, replace_wm))
    {
        gtk_widget_destroy (screen_info->gtk_win);
        g_free (screen_info);
        return NULL;
    }

    event_win = eventFilterAddWin (gscr, event_mask);
    if (!event_win)
    {
        gtk_widget_destroy (screen_info->gtk_win);
        g_free (screen_info);
        return NULL;
    }
    gdk_window_set_user_data (event_win, screen_info->gtk_win);

    screen_info->current_ws = 0;
    screen_info->previous_ws = 0;
    screen_info->current_ws = 0;
    screen_info->previous_ws = 0;

    screen_info->margins[STRUTS_TOP] = screen_info->gnome_margins[STRUTS_TOP] = 0;
    screen_info->margins[STRUTS_LEFT] = screen_info->gnome_margins[STRUTS_LEFT] = 0;
    screen_info->margins[STRUTS_RIGHT] = screen_info->gnome_margins[STRUTS_RIGHT] = 0;
    screen_info->margins[STRUTS_BOTTOM] = screen_info->gnome_margins[STRUTS_BOTTOM] = 0;

    screen_info->workspace_count = 0;
    screen_info->workspace_names = NULL;
    screen_info->workspace_names_items = 0;

    screen_info->windows_stack = NULL;
    screen_info->last_raise = NULL;
    screen_info->windows = NULL;
    screen_info->clients = NULL;
    screen_info->client_count = 0;
    screen_info->client_serial = 0L;
    screen_info->button_handler_id = 0L;

    screen_info->key_grabs = 0;
    screen_info->pointer_grabs = 0;

    getHint (display_info, screen_info->xroot, NET_SHOWING_DESKTOP, &desktop_visible);
    screen_info->show_desktop = (desktop_visible != 0);

    /* Create the side windows to detect edge movement */

    /*left*/
    xfwmWindowTemp (screen_info,
                    NULL, 0,
                    screen_info->xroot,
                    &screen_info->sidewalk[0],
                    0, 0,
                    1, screen_info->height,
                    EnterWindowMask,
                    TRUE);

    /*right*/
    xfwmWindowTemp (screen_info,
                    NULL, 0,
                    screen_info->xroot,
                    &screen_info->sidewalk[1],
                    screen_info->width - 1, 0,
                    1, screen_info->height,
                    EnterWindowMask,
                    TRUE);

    /*top*/
    xfwmWindowTemp (screen_info,
                    NULL, 0,
                    screen_info->xroot,
                    &screen_info->sidewalk[2],
                    0, 0,
                    screen_info->width, 1,
                    EnterWindowMask,
                    TRUE);

    /*bottom*/
    xfwmWindowTemp (screen_info,
                    NULL, 0,
                    screen_info->xroot,
                    &screen_info->sidewalk[3],
                    0, screen_info->height - 1,
                    screen_info->width, 1,
                    EnterWindowMask,
                    TRUE);

#ifdef ENABLE_KDE_SYSTRAY_PROXY
    g_snprintf (selection, sizeof (selection), "_NET_SYSTEM_TRAY_S%d", screen_info->screen);
    screen_info->net_system_tray_selection = XInternAtom (display_info->dpy, selection, FALSE);
    screen_info->systray = getSystrayWindow (display_info, screen_info->net_system_tray_selection);
#endif

    screen_info->font_height = 0;
    screen_info->box_gc = None;
    screen_info->black_gc = NULL;
    screen_info->white_gc = NULL;
    screen_info->title_colors[ACTIVE].gc = NULL;
    screen_info->title_colors[ACTIVE].allocated = FALSE;
    screen_info->title_colors[INACTIVE].gc = NULL;
    screen_info->title_colors[INACTIVE].allocated = FALSE;
    screen_info->title_shadow_colors[ACTIVE].gc = NULL;
    screen_info->title_shadow_colors[ACTIVE].allocated = FALSE;
    screen_info->title_shadow_colors[INACTIVE].gc = NULL;
    screen_info->title_shadow_colors[INACTIVE].allocated = FALSE;

    for (i = 0; i < SIDE_COUNT; i++)
    {
        xfwmPixmapInit (screen_info, &screen_info->sides[i][ACTIVE]);
        xfwmPixmapInit (screen_info, &screen_info->sides[i][INACTIVE]);
    }
    for (i = 0; i < CORNER_COUNT; i++)
    {
        xfwmPixmapInit (screen_info, &screen_info->corners[i][ACTIVE]);
        xfwmPixmapInit (screen_info, &screen_info->corners[i][INACTIVE]);
    }
    for (i = 0; i < BUTTON_COUNT; i++)
    {
        for (j = 0; j < STATE_COUNT; j++)
        {
            xfwmPixmapInit (screen_info, &screen_info->buttons[i][j]);
        }
    }
    for (i = 0; i < TITLE_COUNT; i++)
    {
        xfwmPixmapInit (screen_info, &screen_info->title[i][ACTIVE]);
        xfwmPixmapInit (screen_info, &screen_info->title[i][INACTIVE]);
        xfwmPixmapInit (screen_info, &screen_info->top[i][ACTIVE]);
        xfwmPixmapInit (screen_info, &screen_info->top[i][INACTIVE]);
    }

    screen_info->monitors_index = NULL;
    myScreenInvalidateMonitorCache (screen_info);
    myScreenRebuildMonitorIndex (screen_info);

    return (screen_info);
}
Esempio n. 3
0
GtkWidget *dt_lib_gui_get_expander(dt_lib_module_t *module)
{
  /* check if module is expandable */
  if(!module->expandable(module))
  {
    module->expander = NULL;
    return NULL;
  }

  int bs = DT_PIXEL_APPLY_DPI(12);

  GtkWidget *header = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
  GtkWidget *expander = dtgtk_expander_new(header, module->widget);
  GtkWidget *header_evb = dtgtk_expander_get_header_event_box(DTGTK_EXPANDER(expander));
  GtkWidget *pluginui_frame = dtgtk_expander_get_frame(DTGTK_EXPANDER(expander));

  /* setup the header box */
  g_signal_connect(G_OBJECT(header_evb), "button-press-event", G_CALLBACK(_lib_plugin_header_button_press),
                   module);

  /* setup plugin content frame */
  gtk_frame_set_shadow_type(GTK_FRAME(pluginui_frame), GTK_SHADOW_IN);

  /*
   * initialize the header widgets
   */
  int idx = 0;
  GtkWidget *hw[5] = { NULL, NULL, NULL, NULL, NULL };

  /* add the expand indicator icon */
  hw[idx] = dtgtk_icon_new(dtgtk_cairo_paint_solid_arrow, CPF_DIRECTION_LEFT);
  gtk_widget_set_size_request(GTK_WIDGET(hw[idx++]), bs, bs);

  /* add module label */
  char label[128];
  g_snprintf(label, sizeof(label), "<span size=\"larger\">%s</span>", module->name(module));
  hw[idx] = gtk_label_new("");
  gtk_widget_set_name(hw[idx], "panel_label");
  gtk_label_set_markup(GTK_LABEL(hw[idx]), label);
  gtk_widget_set_tooltip_text(hw[idx], module->name(module));
  gtk_label_set_ellipsize(GTK_LABEL(hw[idx++]), PANGO_ELLIPSIZE_MIDDLE);

  /* add reset button if module has implementation */
  if(module->gui_reset)
  {
    hw[idx] = dtgtk_button_new(dtgtk_cairo_paint_reset, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER);
    module->reset_button = GTK_WIDGET(hw[idx]);
    gtk_widget_set_tooltip_text(hw[idx], _("reset parameters"));
    g_signal_connect(G_OBJECT(hw[idx]), "clicked", G_CALLBACK(dt_lib_gui_reset_callback), module);
  }
  else
    hw[idx] = gtk_fixed_new();
  gtk_widget_set_size_request(GTK_WIDGET(hw[idx++]), bs, bs);

  /* add preset button if module has implementation */
  if(module->get_params)
  {
    hw[idx] = dtgtk_button_new(dtgtk_cairo_paint_presets, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER);
    module->presets_button = GTK_WIDGET(hw[idx]);
    gtk_widget_set_tooltip_text(hw[idx], _("presets"));
    g_signal_connect(G_OBJECT(hw[idx]), "clicked", G_CALLBACK(popup_callback), module);
  }
  else
    hw[idx] = gtk_fixed_new();
  gtk_widget_set_size_request(GTK_WIDGET(hw[idx++]), bs, bs);

  /* add a spacer to align buttons with iop buttons (enabled button) */
  hw[idx] = gtk_fixed_new();
  gtk_widget_set_size_request(GTK_WIDGET(hw[idx++]), bs, bs);

  /* lets order header elements depending on left/right side panel placement */
  int c = module->container(module);
  if((c == DT_UI_CONTAINER_PANEL_LEFT_TOP) || (c == DT_UI_CONTAINER_PANEL_LEFT_CENTER)
     || (c == DT_UI_CONTAINER_PANEL_LEFT_BOTTOM))
  {
    for(int i = 0; i <= 4; i++)
      if(hw[i]) gtk_box_pack_start(GTK_BOX(header), hw[i], i == 1 ? TRUE : FALSE, i == 1 ? TRUE : FALSE, 2);
    gtk_widget_set_halign(hw[1], GTK_ALIGN_START);
    dtgtk_icon_set_paint(hw[0], dtgtk_cairo_paint_solid_arrow, CPF_DIRECTION_RIGHT);
  }
  else
  {
    for(int i = 4; i >= 0; i--)
      if(hw[i]) gtk_box_pack_start(GTK_BOX(header), hw[i], i == 1 ? TRUE : FALSE, i == 1 ? TRUE : FALSE, 2);
    gtk_widget_set_halign(hw[1], GTK_ALIGN_END);
    dtgtk_icon_set_paint(hw[0], dtgtk_cairo_paint_solid_arrow, CPF_DIRECTION_LEFT);
  }

  /* add empty space around widget */
  gtk_widget_set_margin_start(module->widget, DT_PIXEL_APPLY_DPI(8));
  gtk_widget_set_margin_end(module->widget, DT_PIXEL_APPLY_DPI(8));
  gtk_widget_set_margin_top(module->widget, DT_PIXEL_APPLY_DPI(8));
  gtk_widget_set_margin_bottom(module->widget, DT_PIXEL_APPLY_DPI(8));
  gtk_widget_show_all(module->widget);
  gtk_widget_set_name(pluginui_frame, "lib-plugin-ui");
  module->expander = expander;

  gtk_widget_set_hexpand(module->widget, FALSE);
  gtk_widget_set_vexpand(module->widget, FALSE);

  return module->expander;
}
Esempio n. 4
0
static void
anjuta_docman_page_init (AnjutaDocman *docman, IAnjutaDocument *doc,
						 GFile* file, AnjutaDocmanPage *page)
{
	GtkWidget *close_button;
	GtkWidget *close_pixmap;
	GtkWidget *label, *menu_label;
	GtkWidget *box, *menu_box;
	GtkWidget *event_hbox;
	GtkWidget *event_box;
	gint h, w;
	GdkColor color;
	const gchar *filename;
	gchar *ruri;
	
	g_return_if_fail (IANJUTA_IS_DOCUMENT (doc));
	
	gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);

	close_pixmap = gtk_image_new_from_stock(GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU);
	gtk_widget_show (close_pixmap);
	
	/* setup close button, zero out {x,y} thickness to get smallest possible size */
	close_button = gtk_button_new();
	gtk_button_set_focus_on_click (GTK_BUTTON (close_button), FALSE);
	gtk_container_add(GTK_CONTAINER(close_button), close_pixmap);
	gtk_button_set_relief(GTK_BUTTON(close_button), GTK_RELIEF_NONE);

	gtk_widget_set_name (close_button, "anjuta-tab-close-button");
	
	gtk_widget_set_size_request (close_button, w, h);
	gtk_widget_set_tooltip_text (close_button, _("Close file"));

	filename = ianjuta_document_get_filename (doc, NULL);
	label = gtk_label_new (filename);
	gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
	gtk_widget_show (label);

	menu_label = gtk_label_new (filename);
	gtk_misc_set_alignment (GTK_MISC (menu_label), 0.0, 0.5);
	gtk_widget_show (menu_label);
	menu_box = gtk_hbox_new(FALSE, 2);
	
	color.red = 0;
	color.green = 0;
	color.blue = 0;
	
	gtk_widget_modify_fg (close_button, GTK_STATE_NORMAL, &color);
	gtk_widget_modify_fg (close_button, GTK_STATE_INSENSITIVE, &color);
	gtk_widget_modify_fg (close_button, GTK_STATE_ACTIVE, &color);
	gtk_widget_modify_fg (close_button, GTK_STATE_PRELIGHT, &color);
	gtk_widget_modify_fg (close_button, GTK_STATE_SELECTED, &color);
	gtk_widget_show(close_button);
	
	box = gtk_hbox_new (FALSE, 2);
	/* create our layout/event boxes */
	event_box = gtk_event_box_new();
	gtk_event_box_set_visible_window (GTK_EVENT_BOX (event_box), FALSE);

	event_hbox = gtk_hbox_new (FALSE, 2);	
	
	page->menu_icon = gtk_image_new();
	page->mime_icon = gtk_image_new();
	gtk_box_pack_start (GTK_BOX (event_hbox), page->mime_icon, FALSE, FALSE, 0);
	gtk_box_pack_start (GTK_BOX (menu_box), page->menu_icon, FALSE, FALSE, 0);	
	if (file != NULL)
	{
		GdkPixbuf* pixbuf = anjuta_docman_get_pixbuf_for_file (file);
		if (pixbuf != NULL)
		{
			gtk_image_set_from_pixbuf (GTK_IMAGE (page->menu_icon), pixbuf);
			gtk_image_set_from_pixbuf (GTK_IMAGE (page->mime_icon), pixbuf);
			g_object_unref (pixbuf);
		}
		ruri = g_file_get_parse_name (file);
		if (ruri != NULL)
		{
			/* set the tab-tooltip */
			gchar *tip;
			tip = g_markup_printf_escaped ("<b>%s</b> %s", _("Path:"), ruri);
			gtk_widget_set_tooltip_markup (event_box, tip);

			g_free (ruri);
			g_free (tip);
		}
	}
	
	gtk_box_pack_start (GTK_BOX (event_hbox), label, TRUE, TRUE, 0);
	gtk_box_pack_start (GTK_BOX (event_hbox), close_button, FALSE, FALSE, 0);
	gtk_container_add (GTK_CONTAINER (event_box), event_hbox);
	
	/* setup the data hierarchy */
	g_object_set_data (G_OBJECT (box), "event_box", event_box);
	
	/* pack our top-level layout box */
	gtk_box_pack_start (GTK_BOX (box), event_box, TRUE, TRUE, 0);
	
	/* show the widgets of the tab */
	gtk_widget_show_all(box);
	
	/* menu box */
	gtk_box_pack_start (GTK_BOX (menu_box), menu_label, TRUE, TRUE, 0);
	gtk_widget_show_all (menu_box);
	
	/* main box */
	g_signal_connect (G_OBJECT (close_button), "clicked",
					  G_CALLBACK (on_notebook_page_close_button_click),
					  docman);
	g_signal_connect (G_OBJECT (close_button), "enter",
					  G_CALLBACK (on_notebook_page_close_button_enter),
					  page);
	g_signal_connect (G_OBJECT (close_button), "leave",
					  G_CALLBACK (on_notebook_page_close_button_leave),
					  page);
	g_signal_connect (G_OBJECT (box), "button-press-event",
					  G_CALLBACK (on_notebook_tab_btnpress),
					  docman);
	g_signal_connect (G_OBJECT (box), "button-release-event",
					  G_CALLBACK (on_notebook_tab_btnrelease),
					  docman);

	page->widget = GTK_WIDGET (doc);	/* this is the notebook-page child widget */
	page->doc = doc;
	page->box = box;
	page->close_image = close_pixmap;
	page->close_button = close_button;
	page->label = label;
	page->menu_box = menu_box;
	page->menu_label = menu_label;

	gtk_widget_show_all (page->widget);
}
Esempio n. 5
0
GtkWidget *
userlist_create (GtkWidget *box)
{
    GtkWidget *sw, *treeview;
    static const GtkTargetEntry dnd_dest_targets[] =
    {
        {"text/uri-list", 0, 1},
        {"XCHAT_CHANVIEW", GTK_TARGET_SAME_APP, 75 }
    };
    static const GtkTargetEntry dnd_src_target[] =
    {
        {"XCHAT_USERLIST", GTK_TARGET_SAME_APP, 75 }
    };

    sw = gtk_scrolled_window_new (NULL, NULL);
    gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
                                         GTK_SHADOW_ETCHED_IN);
    gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
                                    prefs.pchat_gui_ulist_show_hosts ?
                                    GTK_POLICY_AUTOMATIC :
                                    GTK_POLICY_NEVER,
                                    GTK_POLICY_AUTOMATIC);
    gtk_box_pack_start (GTK_BOX (box), sw, TRUE, TRUE, 0);
    gtk_widget_show (sw);

    treeview = gtk_tree_view_new ();
    gtk_widget_set_name (treeview, "xchat-userlist");
    gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
    gtk_tree_selection_set_mode (gtk_tree_view_get_selection
                                 (GTK_TREE_VIEW (treeview)),
                                 GTK_SELECTION_MULTIPLE);

    /* set up drops */
    gtk_drag_dest_set (treeview, GTK_DEST_DEFAULT_ALL, dnd_dest_targets, 2,
                       GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK);
    gtk_drag_source_set (treeview, GDK_BUTTON1_MASK, dnd_src_target, 1, GDK_ACTION_MOVE);

    /* file DND (for DCC) */
    g_signal_connect (G_OBJECT (treeview), "drag_motion",
                      G_CALLBACK (userlist_dnd_motion), treeview);
    g_signal_connect (G_OBJECT (treeview), "drag_leave",
                      G_CALLBACK (userlist_dnd_leave), 0);
    g_signal_connect (G_OBJECT (treeview), "drag_data_received",
                      G_CALLBACK (userlist_dnd_drop), treeview);

    g_signal_connect (G_OBJECT (treeview), "button_press_event",
                      G_CALLBACK (userlist_click_cb), 0);
    g_signal_connect (G_OBJECT (treeview), "key_press_event",
                      G_CALLBACK (userlist_key_cb), 0);

    /* tree/chanview DND */
#ifndef _WIN32	/* leaks GDI pool memory, don't enable */
    g_signal_connect (G_OBJECT (treeview), "drag_begin",
                      G_CALLBACK (mg_drag_begin_cb), NULL);
    g_signal_connect (G_OBJECT (treeview), "drag_drop",
                      G_CALLBACK (mg_drag_drop_cb), NULL);
    g_signal_connect (G_OBJECT (treeview), "drag_motion",
                      G_CALLBACK (mg_drag_motion_cb), NULL);
    g_signal_connect (G_OBJECT (treeview), "drag_end",
                      G_CALLBACK (mg_drag_end_cb), NULL);
#endif

    userlist_add_columns (GTK_TREE_VIEW (treeview));

    gtk_container_add (GTK_CONTAINER (sw), treeview);
    gtk_widget_show (treeview);

    return treeview;
}
Esempio n. 6
0
//
// Object hierarchy:
//      parentWindow
//        |-- background (event-box)
//             |-- screen_alignment
//                   |-- topLevelVBox (vbox)
//                         |-- title_hbox
//                         |     |-- title_padding (event box)
//                         |     |-- title_background (event box)
//                         |           |-- g_titleItem (label)
//                         |-- g_settingsArea (event box)
//
static GtkWidget *bg_screen_create(GtkWidget *parentWindow)
{
    GtkWidget *background;
    GtkWidget *topLevelVBox;
    GtkWidget *title_background;
    GtkWidget *title_hbox;
    GtkWidget *title_padding;
    GtkWidget *screen_alignment;

    // background
    background = gtk_event_box_new();
    gtk_widget_set_name(GTK_WIDGET(background), "screen_background");
    gtk_container_add(GTK_CONTAINER(parentWindow), background);

    // screen_alignment
    screen_alignment = gtk_alignment_new(0.0, 0.0, 1.0, 1.0);
    gtk_widget_set_name(GTK_WIDGET(screen_alignment), "screen_background");
    gtk_alignment_set_padding(GTK_ALIGNMENT(screen_alignment),
                              SCREEN_BORDER_TOP,
                              SCREEN_BORDER_BOTTOM,
                              1,
                              SCREEN_BORDER_RIGHT);
    gtk_container_add(GTK_CONTAINER(background), screen_alignment);

    // topLevelVBox
    topLevelVBox = gtk_vbox_new(FALSE, SCREEN_ITEM_SPACING);
    gtk_container_add(GTK_CONTAINER(screen_alignment), topLevelVBox);

    // title_hbox
    title_hbox = gtk_hbox_new(FALSE, 0);
    gtk_box_pack_start(GTK_BOX(topLevelVBox), title_hbox, FALSE, FALSE, 0);

    // title_padding
    title_padding = gtk_event_box_new();
    gtk_widget_set_name(GTK_WIDGET(title_padding), "title_padding");
    gtk_widget_set_size_request(GTK_WIDGET(title_padding), 
                                SCREEN_BORDER_LEFT, -1);
    gtk_box_pack_start(GTK_BOX(title_hbox), title_padding, FALSE, FALSE, 0);

    // title_background
    title_background = gtk_event_box_new();
    gtk_widget_set_name(GTK_WIDGET(title_background), "title_background");
    gtk_widget_set_size_request(GTK_WIDGET(title_background), 
                                TITLE_MIN_WIDTH, TITLE_MIN_HEIGHT);
    gtk_box_pack_start(GTK_BOX(title_hbox), title_background, 
                       FALSE, FALSE, 0);

    // g_titleItem: screen title text
    g_titleItem = gtk_label_new("");
    gtk_misc_set_alignment(GTK_MISC(g_titleItem), 0.0, 0.5);
    gtk_misc_set_padding(GTK_MISC(g_titleItem), BACKGROUND_TITLE_OFFSET, 0);
    gtk_widget_set_name(GTK_WIDGET(g_titleItem), "title_item");
    gtk_container_add(GTK_CONTAINER(title_background), g_titleItem);

    // g_settingsArea: area to place remaining objects
    g_settingsArea = gtk_event_box_new();
    gtk_widget_set_name(GTK_WIDGET(g_settingsArea), "settings_area");
    gtk_box_pack_end(GTK_BOX(topLevelVBox), g_settingsArea, TRUE, TRUE, 0);

    gtk_widget_show_all(background);

    return g_settingsArea;
}
Esempio n. 7
0
// widget layout
// sortOrderSelection
// |--background
//    |--alignment
//       |--vbox
//          |--alignment_1
//             |--sortOrderLabel
//          |--hbox
//             |--selLabel
//             |--selSortLabel
//                |--hbox_1
//                   |--ascendingButton
//                   |--descendingButton
//
static GtkWidget *create_sort_order_widget(void)
{
    GtkWidget *sortOrderSelection; 
    GtkWidget *background;
    GtkWidget *alignment;
    GtkWidget *vbox;
    GtkWidget *alignment_1;
    GtkWidget *sortOrderLabel; 
    GtkWidget *hbox;
    GtkWidget *selLabel;      
    GtkWidget *selSortLabel;
    GtkWidget *hbox_1;
    GtkWidget *ascendingButton;
    GtkWidget *descendingButton;
    GtkToggleButton *button_tbl[3];

    // background
    background = gtk_event_box_new();
    gtk_widget_set_name(background, "sort_order_background");
    gtk_widget_set_size_request(background, SORT_WND_SORTORDER_BK_WIDTH, SORT_WND_SORTORDER_BK_HEIGHT);
    // alignment
    alignment = gtk_alignment_new(0.0, 0.0, 0.0, 0.0);
    gtk_alignment_set_padding(GTK_ALIGNMENT(alignment),
                              SORT_WND_TOP_PADDING, SORT_WND_BOTTOM_PADDING,
                              SORT_WND_LEFT_PADDING, SORT_WND_RIGHT_PADDING);
    gtk_container_add(GTK_CONTAINER(background), alignment);
    // vbox
    vbox = gtk_vbox_new(FALSE, SORT_WND_SPACING_V * 3);
    gtk_container_add(GTK_CONTAINER(alignment), vbox);
    // alignment_1
    alignment_1 = gtk_alignment_new(0.0, 0.0, 0.0, 0.0);
    gtk_box_pack_start(GTK_BOX(vbox), alignment_1, FALSE, FALSE, 0);
    // sortOrderLabel
    sortOrderLabel = gtk_label_new("");
    gtk_widget_set_name(sortOrderLabel, "sort_wnd_text_bold");
    gtk_misc_set_alignment(GTK_MISC(sortOrderLabel), 0.0, 0.5);
    gtk_widget_set_size_request(sortOrderLabel,
                                SORT_WND_SORTORDER_BK_WIDTH - SORT_WND_LEFT_PADDING - SORT_WND_RIGHT_PADDING, -1);
    gtk_label_set_ellipsize(GTK_LABEL(sortOrderLabel), PANGO_ELLIPSIZE_END);
    gtk_label_set_justify(GTK_LABEL(sortOrderLabel), GTK_JUSTIFY_LEFT);
    gtk_container_add(GTK_CONTAINER(alignment_1), sortOrderLabel);
    // hbox
    hbox = gtk_hbox_new(FALSE, SORT_WND_SPACING_H);
    gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
    // selLabel
    selLabel = gtk_label_new("");
    gtk_widget_set_name(selLabel, "sort_wnd_text_normal");
    gtk_misc_set_alignment(GTK_MISC(selLabel), 0.0, 0.5);
    gtk_widget_set_size_request(selLabel, SORT_WND_BUTTON_WIDTH - 20, -1);
    gtk_label_set_ellipsize(GTK_LABEL(selLabel), PANGO_ELLIPSIZE_END);
    gtk_label_set_justify(GTK_LABEL(selLabel), GTK_JUSTIFY_LEFT);
    gtk_box_pack_start(GTK_BOX(hbox), selLabel, FALSE, FALSE, 0);
    // selSortLabel
    selSortLabel = gtk_label_new("");
    gtk_widget_set_name(selSortLabel, "sort_wnd_text_bold");
    gtk_widget_set_size_request(selSortLabel, SORT_WND_BUTTON_WIDTH + 40, -1);
    gtk_misc_set_alignment(GTK_MISC(selSortLabel), 0.0, 0.5);
    gtk_label_set_ellipsize(GTK_LABEL(selSortLabel), PANGO_ELLIPSIZE_END);
    gtk_label_set_justify(GTK_LABEL(selSortLabel), GTK_JUSTIFY_CENTER);
    gtk_box_pack_start(GTK_BOX(hbox), selSortLabel, FALSE, FALSE, 0);
    // hbox_1
    hbox_1 = gtk_hbox_new(FALSE, 0);
    gtk_box_pack_start(GTK_BOX(hbox), hbox_1, FALSE, FALSE, 25);
    // ascendingButton
    ascendingButton = ergtk_toggle_button_new_with_label("");
    gtk_widget_set_size_request(ascendingButton, ASCENDING_BTN_WIDTH, ASCENDING_BTN_HEIGHT);
    gtk_widget_set_name(ascendingButton, "sort_order_ascending_button");
    gtk_box_pack_start(GTK_BOX(hbox_1), ascendingButton, FALSE, FALSE, 0);
    // descendingButton
    descendingButton = ergtk_toggle_button_new_with_label("");
    gtk_widget_set_size_request(descendingButton, ASCENDING_BTN_WIDTH, ASCENDING_BTN_HEIGHT);
    gtk_widget_set_name(descendingButton, "sort_order_descending_button");
    gtk_box_pack_start(GTK_BOX(hbox_1), descendingButton, FALSE, FALSE, 0);
    // 
    button_tbl[0] = GTK_TOGGLE_BUTTON(ascendingButton);
    button_tbl[1] = GTK_TOGGLE_BUTTON(descendingButton);
    button_tbl[2] = NULL;
    // add buttons to selection group
    sortOrderSelection = ergtk_selection_group_new(button_tbl);
    ergtk_selection_group_set_details(ERGTK_SELECTION_GROUP(sortOrderSelection), 1, 1);
    gtk_container_add(GTK_CONTAINER(sortOrderSelection), background);

    // show widgets
    gtk_widget_show_all(background);

    // set global values
    g_sort_wnd.sortOrderLabel = sortOrderLabel;
    g_sort_wnd.selLabel = selLabel;
    g_sort_wnd.selSortLabel = selSortLabel;
    g_sort_wnd.sortOrderSelection = sortOrderSelection;

    // return
    return sortOrderSelection;
}
Esempio n. 8
0
static void
cv_tree_init (chanview *cv)
{
	GtkWidget *view, *win;
	GtkCellRenderer *renderer;
	GtkTreeViewColumn *col;
	int wid1, wid2;
	static const GtkTargetEntry dnd_src_target[] =
	{
		{"HEXCHAT_CHANVIEW", GTK_TARGET_SAME_APP, 75 }
	};
	static const GtkTargetEntry dnd_dest_target[] =
	{
		{"HEXCHAT_USERLIST", GTK_TARGET_SAME_APP, 75 }
	};

	win = gtk_scrolled_window_new (0, 0);
	/*gtk_container_set_border_width (GTK_CONTAINER (win), 1);*/
	gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (win),
													 GTK_SHADOW_IN);
	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (win),
											  GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
	gtk_container_add (GTK_CONTAINER (cv->box), win);
	gtk_widget_show (win);

	view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (cv->store));
	gtk_widget_set_name (view, "hexchat-tree");
	if (cv->style)
		gtk_widget_set_style (view, cv->style);
	/*gtk_widget_modify_base (view, GTK_STATE_NORMAL, &colors[COL_BG]);*/
	GTK_WIDGET_UNSET_FLAGS (view, GTK_CAN_FOCUS);
	gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (view), FALSE);

	if (prefs.hex_gui_tab_dots)
	{
		gtk_tree_view_set_enable_tree_lines (GTK_TREE_VIEW (view), TRUE);
	}
	
	/* Indented channels with no server looks silly, but we still want expanders */
	if (!prefs.hex_gui_tab_server)
	{
		gtk_widget_style_get (view, "expander-size", &wid1, "horizontal-separator", &wid2, NULL);
		gtk_tree_view_set_level_indentation (GTK_TREE_VIEW (view), -wid1 - wid2);
	}


	gtk_container_add (GTK_CONTAINER (win), view);
	col = gtk_tree_view_column_new();

	/* icon column */
	if (cv->use_icons)
	{
		renderer = gtk_cell_renderer_pixbuf_new ();
		if (prefs.hex_gui_compact)
			g_object_set (G_OBJECT (renderer), "ypad", 0, NULL);

		gtk_tree_view_column_pack_start(col, renderer, FALSE);
		gtk_tree_view_column_set_attributes (col, renderer, "pixbuf", COL_PIXBUF, NULL);
	}

	/* main column */
	renderer = gtk_cell_renderer_text_new ();
	if (prefs.hex_gui_compact)
		g_object_set (G_OBJECT (renderer), "ypad", 0, NULL);
	gtk_cell_renderer_text_set_fixed_height_from_font (GTK_CELL_RENDERER_TEXT (renderer), 1);
	gtk_tree_view_column_pack_start(col, renderer, TRUE);
	gtk_tree_view_column_set_attributes (col, renderer, "text", COL_NAME, "attributes", COL_ATTR, NULL);
	gtk_tree_view_append_column(GTK_TREE_VIEW(view), col);									

	g_signal_connect (G_OBJECT (gtk_tree_view_get_selection (GTK_TREE_VIEW (view))),
							"changed", G_CALLBACK (cv_tree_sel_cb), cv);
	g_signal_connect (G_OBJECT (view), "button-press-event",
							G_CALLBACK (cv_tree_click_cb), cv);
	g_signal_connect (G_OBJECT (view), "row-activated",
							G_CALLBACK (cv_tree_activated_cb), NULL);

	gtk_drag_dest_set (view, GTK_DEST_DEFAULT_ALL, dnd_dest_target, 1,
							 GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK);
	gtk_drag_source_set (view, GDK_BUTTON1_MASK, dnd_src_target, 1, GDK_ACTION_COPY);

#ifndef WIN32
	g_signal_connect (G_OBJECT (view), "drag_begin",
							G_CALLBACK (mg_drag_begin_cb), NULL);
	g_signal_connect (G_OBJECT (view), "drag_drop",
							G_CALLBACK (mg_drag_drop_cb), NULL);
	g_signal_connect (G_OBJECT (view), "drag_motion",
							G_CALLBACK (mg_drag_motion_cb), NULL);
	g_signal_connect (G_OBJECT (view), "drag_end",
							G_CALLBACK (mg_drag_end_cb), NULL);
#endif

	((treeview *)cv)->tree = GTK_TREE_VIEW (view);
	((treeview *)cv)->scrollw = win;
	gtk_widget_show (view);
}
Esempio n. 9
0
static ButtonData*
bigboard_button_add_to_widget (GtkWidget *applet)
{
        ButtonData *button_data;
        AtkObject  *atk_obj;
        GtkWidget  *hbox;

        button_data = g_new0 (ButtonData, 1);

        button_data->applet = applet;

        button_data->image = gtk_image_new ();

        button_data->orient = GTK_ORIENTATION_HORIZONTAL;

        button_data->size = 24;

        g_signal_connect (G_OBJECT (button_data->applet), "realize",
                          G_CALLBACK (bigboard_button_applet_realized), button_data);

        button_data->button = gtk_toggle_button_new ();

        gtk_widget_set_name (button_data->button, "bigboard-button");
        gtk_rc_parse_string ("\n"
                             "   style \"bigboard-button-style\"\n"
                             "   {\n"
                             "      GtkWidget::focus-line-width=0\n"
                             "      GtkWidget::focus-padding=0\n"
                             "      GtkButton::interior-focus=0\n"
                             "   }\n"
                             "\n"
                             "    widget \"*.bigboard-button\" style \"bigboard-button-style\"\n"
                             "\n");

        atk_obj = gtk_widget_get_accessible (button_data->button);
        atk_object_set_name (atk_obj, _("Show Sidebar Button"));
        g_signal_connect (G_OBJECT (button_data->button), "button_press_event",
                          G_CALLBACK (do_not_eat_button_press), NULL);

        g_signal_connect (G_OBJECT (button_data->button), "toggled",
                          G_CALLBACK (button_toggled_callback), button_data);

        gtk_container_set_border_width (GTK_CONTAINER (button_data->button), 0);
        gtk_container_add (GTK_CONTAINER (button_data->button), button_data->image);

        button_data->launchers = launchers_new();

        hbox = gtk_hbox_new(FALSE, 0);
        gtk_box_pack_start(GTK_BOX(hbox), button_data->button, FALSE, TRUE, 0);
        gtk_box_pack_start(GTK_BOX(hbox), button_data->launchers, FALSE, TRUE, 0);

        gtk_container_add (GTK_CONTAINER (button_data->applet), hbox);

        g_signal_connect (G_OBJECT (button_data->button),
                          "size_allocate",
                          G_CALLBACK (button_size_allocated),
                          button_data);

        g_signal_connect (G_OBJECT (button_data->applet),
                          "destroy",
                          G_CALLBACK (applet_destroyed),
                          button_data);

        gtk_drag_dest_set (GTK_WIDGET(button_data->button), 0, NULL, 0, 0);

        g_signal_connect (G_OBJECT(button_data->button), "drag_motion",
                          G_CALLBACK (button_drag_motion),
                          button_data);
        g_signal_connect (G_OBJECT(button_data->button), "drag_leave",
                          G_CALLBACK (button_drag_leave),
                          button_data);

        button_data->connection = dbus_bus_get (DBUS_BUS_SESSION, NULL);
        if (button_data->connection) {

                dbus_connection_setup_with_g_main(button_data->connection, NULL);

                hippo_dbus_helper_register_service_tracker(button_data->connection,
                                                           "org.gnome.BigBoard",
                                                           &bigboard_tracker,
                                                           signal_handlers,
                                                           button_data);
                button_data->bb_proxy =
                        hippo_dbus_proxy_new (button_data->connection,
                                              "org.gnome.BigBoard",
                                              "/bigboard/panel",
                                              "org.gnome.BigBoard.Panel");
        }

        self_add_icon_changed_callback(user_photo_changed_callback, button_data);

        gtk_widget_show_all (hbox);

        return button_data;
}
Esempio n. 10
0
void
create_translatorchooser (HWND hwnd, TTRANSLATORCHOOSER *choose_t)
{
  GdkPixmap *pixmap;
  GdkBitmap *mask;
  GtkStyle *style;

  GtkWidget *translatorchooser;
  GtkWidget *vbox41;
  GtkWidget *hbox57;
  GtkWidget *frame97;
  GtkWidget *alignment81;
  GtkWidget *pixmap1;
  GtkWidget *frame98;
  GtkWidget *alignment82;
  GtkWidget *scrolledwindow21;
  GtkWidget *clist1;
  GtkWidget *label158;
  GtkWidget *label159;
  GtkWidget *label160;
  GtkWidget *label161;
  GtkWidget *label162;
  GtkWidget *hbuttonbox3;
  GtkWidget *b_finish;
  GtkWidget *b_cancel;

  if (hwnd == NULL || !GTK_IS_WIDGET (hwnd))
    return;

  translatorchooser = gtk_dialog_new ();
  gtk_widget_set_name (translatorchooser, "translatorchooser");
  gtk_widget_set_size_request (translatorchooser, 515, 335);
  gtk_window_set_title (GTK_WINDOW (translatorchooser), _("Choose a Translator"));
  gtk_window_set_position (GTK_WINDOW (translatorchooser), GTK_WIN_POS_CENTER_ON_PARENT);
  gtk_window_set_modal (GTK_WINDOW (translatorchooser), TRUE);
  gtk_window_set_default_size (GTK_WINDOW (translatorchooser), 600, 450);
  gtk_window_set_type_hint (GTK_WINDOW (translatorchooser), GDK_WINDOW_TYPE_HINT_DIALOG);

#if GTK_CHECK_VERSION(2,0,0)
  gtk_widget_show (translatorchooser);
#endif

  vbox41 = GTK_DIALOG (translatorchooser)->vbox;
  gtk_widget_set_name (vbox41, "vbox41");
  gtk_widget_show (vbox41);

  hbox57 = gtk_hbox_new (FALSE, 0);
  gtk_widget_set_name (hbox57, "hbox57");
  gtk_widget_show (hbox57);
  gtk_box_pack_start (GTK_BOX (vbox41), hbox57, TRUE, TRUE, 0);

  frame97 = gtk_frame_new (NULL);
  gtk_widget_set_name (frame97, "frame97");
  gtk_widget_show (frame97);
  gtk_box_pack_start (GTK_BOX (hbox57), frame97, FALSE, TRUE, 0);
  gtk_container_set_border_width (GTK_CONTAINER (frame97), 10);
  gtk_frame_set_shadow_type (GTK_FRAME (frame97), GTK_SHADOW_NONE);

  alignment81 = gtk_alignment_new (0.5, 0.5, 1, 1);
  gtk_widget_set_name (alignment81, "alignment81");
  gtk_widget_show (alignment81);
  gtk_container_add (GTK_CONTAINER (frame97), alignment81);
  gtk_widget_set_size_request (alignment81, 140, -1);

#if GTK_CHECK_VERSION(2,0,0)
  style = gtk_widget_get_style (translatorchooser);
  pixmap =
      gdk_pixmap_create_from_xpm_d (translatorchooser->window, &mask,
      &style->bg[GTK_STATE_NORMAL], (gchar **) img_xpm);
#else
  style = gtk_widget_get_style (GTK_WIDGET (hwnd));
  pixmap =
      gdk_pixmap_create_from_xpm_d (GTK_WIDGET (hwnd)->window, &mask,
      &style->bg[GTK_STATE_NORMAL], (gchar **) img_xpm);
#endif
  pixmap1 = gtk_pixmap_new (pixmap, mask);
  gtk_widget_set_name (pixmap1, "pixmap1");
  gtk_widget_show (pixmap1);
  gtk_container_add (GTK_CONTAINER (alignment81), pixmap1);

  frame98 = gtk_frame_new (NULL);
  gtk_widget_set_name (frame98, "frame98");
  gtk_widget_show (frame98);
  gtk_box_pack_start (GTK_BOX (hbox57), frame98, TRUE, TRUE, 0);
  gtk_frame_set_shadow_type (GTK_FRAME (frame98), GTK_SHADOW_NONE);

  alignment82 = gtk_alignment_new (0.5, 0.5, 1, 1);
  gtk_widget_set_name (alignment82, "alignment82");
  gtk_widget_show (alignment82);
  gtk_container_add (GTK_CONTAINER (frame98), alignment82);
  gtk_alignment_set_padding (GTK_ALIGNMENT (alignment82), 0, 10, 0, 0);

  scrolledwindow21 = gtk_scrolled_window_new (NULL, NULL);
  gtk_widget_set_name (scrolledwindow21, "scrolledwindow21");
  gtk_widget_show (scrolledwindow21);
  gtk_container_add (GTK_CONTAINER (alignment82), scrolledwindow21);

  clist1 = gtk_clist_new (4);
  gtk_widget_set_name (clist1, "clist1");
  gtk_widget_show (clist1);
  gtk_container_add (GTK_CONTAINER (scrolledwindow21), clist1);
  gtk_clist_set_column_width (GTK_CLIST (clist1), 0, 165);
  gtk_clist_set_column_width (GTK_CLIST (clist1), 1, 118);
  gtk_clist_set_column_width (GTK_CLIST (clist1), 2, 80);
  gtk_clist_set_column_width (GTK_CLIST (clist1), 3, 80);
  gtk_clist_column_titles_show (GTK_CLIST (clist1));

  label158 = gtk_label_new (_("Name"));
  gtk_widget_set_name (label158, "label158");
  gtk_widget_show (label158);
  gtk_clist_set_column_widget (GTK_CLIST (clist1), 0, label158);
  gtk_widget_set_size_request (label158, 165, -1);

  label159 = gtk_label_new (_("File"));
  gtk_widget_set_name (label159, "label159");
  gtk_widget_show (label159);
  gtk_clist_set_column_widget (GTK_CLIST (clist1), 1, label159);
  gtk_widget_set_size_request (label159, 118, -1);

  label160 = gtk_label_new (_("Date"));
  gtk_widget_set_name (label160, "label160");
  gtk_widget_show (label160);
  gtk_clist_set_column_widget (GTK_CLIST (clist1), 2, label160);
  gtk_widget_set_size_request (label160, 80, -1);

  label161 = gtk_label_new (_("Size"));
  gtk_widget_set_name (label161, "label161");
  gtk_widget_show (label161);
  gtk_clist_set_column_widget (GTK_CLIST (clist1), 3, label161);
  gtk_widget_set_size_request (label161, 80, -1);

  label162 = gtk_label_new (_("Select which ODBC Translator you want to use"));
  gtk_widget_set_name (label162, "label162");
  gtk_widget_show (label162);
  gtk_frame_set_label_widget (GTK_FRAME (frame98), label162);
  gtk_label_set_use_markup (GTK_LABEL (label162), TRUE);

  hbuttonbox3 = GTK_DIALOG (translatorchooser)->action_area;
  gtk_widget_set_name (hbuttonbox3, "hbuttonbox3");
  gtk_widget_show (hbuttonbox3);
  gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox3), GTK_BUTTONBOX_END);

  b_finish = gtk_button_new_from_stock ("gtk-ok");
  gtk_widget_set_name (b_finish, "b_finish");
  gtk_widget_show (b_finish);
  gtk_dialog_add_action_widget (GTK_DIALOG (translatorchooser), b_finish, GTK_RESPONSE_OK);
  GTK_WIDGET_SET_FLAGS (b_finish, GTK_CAN_DEFAULT);

  b_cancel = gtk_button_new_from_stock ("gtk-cancel");
  gtk_widget_set_name (b_cancel, "b_cancel");
  gtk_widget_show (b_cancel);
  gtk_dialog_add_action_widget (GTK_DIALOG (translatorchooser), b_cancel, GTK_RESPONSE_CANCEL);
  GTK_WIDGET_SET_FLAGS (b_cancel, GTK_CAN_DEFAULT);

  /* Store pointers to all widgets, for use by lookup_widget(). */
  GLADE_HOOKUP_OBJECT_NO_REF (translatorchooser, translatorchooser, "translatorchooser");
  GLADE_HOOKUP_OBJECT_NO_REF (translatorchooser, vbox41, "vbox41");
  GLADE_HOOKUP_OBJECT (translatorchooser, hbox57, "hbox57");
  GLADE_HOOKUP_OBJECT (translatorchooser, frame97, "frame97");
  GLADE_HOOKUP_OBJECT (translatorchooser, alignment81, "alignment81");
  GLADE_HOOKUP_OBJECT (translatorchooser, pixmap1, "pixmap1");
  GLADE_HOOKUP_OBJECT (translatorchooser, frame98, "frame98");
  GLADE_HOOKUP_OBJECT (translatorchooser, alignment82, "alignment82");
  GLADE_HOOKUP_OBJECT (translatorchooser, scrolledwindow21, "scrolledwindow21");
  GLADE_HOOKUP_OBJECT (translatorchooser, clist1, "clist1");
  GLADE_HOOKUP_OBJECT (translatorchooser, label158, "label158");
  GLADE_HOOKUP_OBJECT (translatorchooser, label159, "label159");
  GLADE_HOOKUP_OBJECT (translatorchooser, label160, "label160");
  GLADE_HOOKUP_OBJECT (translatorchooser, label161, "label161");
  GLADE_HOOKUP_OBJECT (translatorchooser, label162, "label162");
  GLADE_HOOKUP_OBJECT_NO_REF (translatorchooser, hbuttonbox3, "hbuttonbox3");
  GLADE_HOOKUP_OBJECT (translatorchooser, b_finish, "b_finish");
  GLADE_HOOKUP_OBJECT (translatorchooser, b_cancel, "b_cancel");

  /* Ok button events */
  gtk_signal_connect (GTK_OBJECT (b_finish), "clicked",
      GTK_SIGNAL_FUNC (translatorchooser_ok_clicked), choose_t);
  /* Cancel button events */
  gtk_signal_connect (GTK_OBJECT (b_cancel), "clicked",
      GTK_SIGNAL_FUNC (translatorchooser_cancel_clicked), choose_t);
  /* Close window button events */
  gtk_signal_connect (GTK_OBJECT (translatorchooser), "delete_event",
      GTK_SIGNAL_FUNC (delete_event), choose_t);
  gtk_signal_connect (GTK_OBJECT (translatorchooser), "destroy",
      GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
  /* Translator list events */
  gtk_signal_connect (GTK_OBJECT (clist1), "select_row",
      GTK_SIGNAL_FUNC (translator_list_select), choose_t);

  addtranslators_to_list (clist1, translatorchooser);

  choose_t->translatorlist = clist1;
  choose_t->translator = NULL;
  choose_t->mainwnd = translatorchooser;
  choose_t->b_finish = b_finish;

  gtk_widget_show_all (translatorchooser);
  gtk_main ();
}
Esempio n. 11
0
GtkWidget*
create_windowMain ()
{
	GtkWidget *vbox1;
	GtkWidget *hpaned1;
	GtkWidget *scrolledwindow1;
	GtkWidget *hbuttonbox1;
	GtkWidget *buttonRefresh;
	GtkWidget *buttonConfigure;
	GtkWidget *buttonClose;
	GtkWidget *buttonAbout;
	GdkPixbuf *icon;
	GtkCellRenderer *treeRenderer;
	GtkTreeViewColumn *treeColumn;

	windowMain = gtk_window_new (GTK_WINDOW_TOPLEVEL);
	gtk_widget_set_name (windowMain, "windowMain");
	gtk_window_set_title (GTK_WINDOW (windowMain), "USB Viewer");
	gtk_window_set_default_size (GTK_WINDOW (windowMain), 600, 300);

	icon = gdk_pixbuf_new_from_xpm_data((const char **)usbview_icon);
	gtk_window_set_icon(GTK_WINDOW(windowMain), icon);

	vbox1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
	gtk_widget_set_name (vbox1, "vbox1");
	gtk_widget_show (vbox1);
	gtk_container_add (GTK_CONTAINER (windowMain), vbox1);

	hpaned1 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
	gtk_widget_set_name (hpaned1, "hpaned1");
	gtk_widget_show (hpaned1);
	gtk_box_pack_start (GTK_BOX (vbox1), hpaned1, TRUE, TRUE, 0);

	treeStore = gtk_tree_store_new (N_COLUMNS,
				G_TYPE_STRING,	/* NAME_COLUMN */
				G_TYPE_INT,	/* DEVICE_ADDR_COLUMN */
				G_TYPE_STRING	/* COLOR_COLUMN */);
	treeUSB = gtk_tree_view_new_with_model (GTK_TREE_MODEL (treeStore));
	treeRenderer = gtk_cell_renderer_text_new ();
	treeColumn = gtk_tree_view_column_new_with_attributes (
					"USB devices",
					treeRenderer,
					"text", NAME_COLUMN,
					"foreground", COLOR_COLUMN,
					NULL);
	gtk_tree_view_append_column (GTK_TREE_VIEW (treeUSB), treeColumn);
	gtk_widget_set_name (treeUSB, "treeUSB");
	gtk_widget_show (treeUSB);
	gtk_paned_pack1 (GTK_PANED (hpaned1), treeUSB, FALSE, FALSE);

	scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
	gtk_widget_set_name (scrolledwindow1, "scrolledwindow1");
	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow1), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
	gtk_widget_show (scrolledwindow1);
	gtk_paned_pack2 (GTK_PANED (hpaned1), scrolledwindow1, TRUE, FALSE);

	textDescriptionBuffer = gtk_text_buffer_new(NULL);
	//textDescription = gtk_text_new (NULL, NULL);
	textDescriptionView = gtk_text_view_new_with_buffer(textDescriptionBuffer);
	gtk_widget_set_name (textDescriptionView, "textDescription");
	gtk_text_view_set_editable(GTK_TEXT_VIEW(textDescriptionView), FALSE);
	gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(textDescriptionView), FALSE);
	gtk_widget_show (textDescriptionView);
	gtk_container_add (GTK_CONTAINER (scrolledwindow1), textDescriptionView);

	hbuttonbox1 = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
	gtk_widget_set_name (hbuttonbox1, "hbuttonbox1");
	gtk_widget_show (hbuttonbox1);
	gtk_box_pack_start (GTK_BOX (vbox1), hbuttonbox1, FALSE, FALSE, 5);
	//gtk_button_box_set_spacing (GTK_BUTTON_BOX (hbuttonbox1), 10);
	//gtk_button_box_set_child_size (GTK_BUTTON_BOX (hbuttonbox1), 50, 25);
	//gtk_button_box_set_child_ipadding (GTK_BUTTON_BOX (hbuttonbox1), 25, 10);

	buttonRefresh = gtk_button_new_with_label("Refresh");
	gtk_widget_set_name (buttonRefresh, "buttonRefresh");
	gtk_widget_show (buttonRefresh);
	gtk_container_add (GTK_CONTAINER (hbuttonbox1), buttonRefresh);
	gtk_container_set_border_width (GTK_CONTAINER (buttonRefresh), 4);
	gtk_widget_set_can_default (buttonRefresh, TRUE);

	buttonConfigure = gtk_button_new_with_label ("Configure...");
	gtk_widget_set_name (buttonConfigure, "buttonConfigure");
	gtk_widget_show (buttonConfigure);
	gtk_container_add (GTK_CONTAINER (hbuttonbox1), buttonConfigure);
	gtk_container_set_border_width (GTK_CONTAINER (buttonConfigure), 4);
	gtk_widget_set_can_default (buttonConfigure, TRUE);

	buttonAbout = gtk_button_new_with_label("About");
	gtk_widget_set_name (buttonAbout, "buttonAbout");
	gtk_widget_show (buttonAbout);
	gtk_container_add (GTK_CONTAINER (hbuttonbox1), buttonAbout);
	gtk_container_set_border_width (GTK_CONTAINER (buttonAbout), 4);
	gtk_widget_set_can_default (buttonAbout, TRUE);

	buttonClose = gtk_button_new_with_label("Quit");
	gtk_widget_set_name (buttonClose, "buttonClose");
	gtk_widget_show (buttonClose);
	gtk_container_add (GTK_CONTAINER (hbuttonbox1), buttonClose);
	gtk_container_set_border_width (GTK_CONTAINER (buttonClose), 4);
	gtk_widget_set_can_default (buttonClose, TRUE);

	g_signal_connect (G_OBJECT (windowMain), "delete_event",
			    G_CALLBACK (on_window1_delete_event),
			    NULL);
	g_signal_connect (G_OBJECT (buttonRefresh), "clicked",
			    G_CALLBACK (on_buttonRefresh_clicked),
			    NULL);
	g_signal_connect (G_OBJECT (buttonConfigure), "clicked",
			    G_CALLBACK (on_buttonConfigure_clicked),
			    NULL);
	g_signal_connect (G_OBJECT (buttonAbout), "clicked",
			    G_CALLBACK (on_buttonAbout_clicked),
			    NULL);
	g_signal_connect (G_OBJECT (buttonClose), "clicked",
			    G_CALLBACK (on_buttonClose_clicked),
			    NULL);

	/* create our timer */
	//timer = gtk_timeout_add (2000, on_timer_timeout, 0);
	
	return windowMain;
}
static void
hd_incoming_event_window_init (HDIncomingEventWindow *window)
{
  HDIncomingEventWindowPrivate *priv = HD_INCOMING_EVENT_WINDOW_GET_PRIVATE (window);
  GtkWidget *main_table;

  window->priv = priv;

  main_table = gtk_table_new (2, 2, FALSE);
  gtk_table_set_col_spacings (GTK_TABLE (main_table), ICON_SPACING);
  gtk_container_set_border_width (GTK_CONTAINER (main_table), WINDOW_MARGIN);
  gtk_widget_set_size_request (GTK_WIDGET (main_table), WINDOW_WIDTH, WINDOW_HEIGHT);
  gtk_widget_show (main_table);

  priv->icon = gtk_image_new ();
/*  gtk_image_set_pixel_size (GTK_IMAGE (priv->icon), HILDON_ICON_SIZE_STYLUS); */
  gtk_widget_set_size_request (priv->icon, ICON_SIZE, ICON_SIZE);
  gtk_widget_show (priv->icon);
  gtk_table_attach (GTK_TABLE (main_table),
                    priv->icon,
                    0, 1,
                    0, 1,
                    0, 0,
                    0, 0);

  priv->title = gtk_label_new (NULL);
  gtk_widget_set_name (GTK_WIDGET (priv->title), "HDIncomingEventWindow-Text");
  gtk_misc_set_alignment (GTK_MISC (priv->title), 0.0, 0.5);
  gtk_widget_set_size_request (priv->title, TITLE_TEXT_WIDTH, TITLE_TEXT_HEIGHT);
  hildon_helper_set_logical_font (priv->title, TITLE_TEXT_FONT);
  gtk_widget_show (priv->title);
  gtk_table_attach (GTK_TABLE (main_table),
                    priv->title,
                    1, 2,
                    0, 1,
                    GTK_EXPAND | GTK_FILL, GTK_FILL,
                    0, TITLE_TEXT_PADDING);

  priv->amount_label = gtk_label_new (NULL);
  gtk_widget_set_name (GTK_WIDGET (priv->amount_label), "HDIncomingEventWindow-Text");
  gtk_misc_set_alignment (GTK_MISC (priv->amount_label), 0.5, 0.5);
  gtk_widget_set_size_request (priv->amount_label, ICON_SIZE, SECONDARY_TEXT_HEIGHT);
  hildon_helper_set_logical_font (priv->amount_label, SECONDARY_TEXT_FONT);
  gtk_widget_show (priv->amount_label);
  gtk_table_attach (GTK_TABLE (main_table),
                    priv->amount_label,
                    0, 1,
                    1, 2,
                    GTK_FILL, GTK_FILL,
                    0, 0);

  priv->message = gtk_label_new (NULL);
  gtk_widget_set_name (GTK_WIDGET (priv->message), "HDIncomingEventWindow-Secondary");
  gtk_misc_set_alignment (GTK_MISC (priv->message), 0.0, 0.5);
  gtk_widget_set_size_request (priv->message, SECONDARY_TEXT_WIDTH, SECONDARY_TEXT_HEIGHT);
  hildon_helper_set_logical_font (priv->message, SECONDARY_TEXT_FONT);
  gtk_widget_show (priv->message);
  gtk_table_attach (GTK_TABLE (main_table),
                    priv->message,
                    1, 2,
                    1, 2,
                    GTK_EXPAND | GTK_FILL, GTK_FILL,
                    0, 0);

  /* Pack containers */
  gtk_container_add (GTK_CONTAINER (window), main_table);

  /* Enable handling of button press events */
  gtk_widget_add_events (GTK_WIDGET (window), GDK_BUTTON_PRESS_MASK);

  /* Don't take focus away from the toplevel application. */
  gtk_window_set_accept_focus (GTK_WINDOW (window), FALSE);

  /* bg image */
  priv->bg_image = hd_cairo_surface_cache_get_surface (hd_cairo_surface_cache_get (),
                                                       BACKGROUND_IMAGE_FILE);

  g_signal_connect_object (hd_incoming_events_get (), "display-status-changed",
                           G_CALLBACK (display_status_changed), window, 0);

  gtk_widget_set_size_request (GTK_WIDGET (window),
                               cairo_image_surface_get_width (priv->bg_image),
                               cairo_image_surface_get_height (priv->bg_image));
}
Esempio n. 13
0
static PidginLogViewer *display_log_viewer(struct log_viewer_hash_t *ht, GList *logs,
						const char *title, GtkWidget *icon, int log_size)
{
	PidginLogViewer *lv;
	GtkWidget *title_box;
	char *text;
	GtkWidget *pane;
	GtkWidget *sw;
	GtkCellRenderer *rend;
	GtkTreeViewColumn *col;
	GtkTreeSelection *sel;
	GtkWidget *vbox;
	GtkWidget *frame;
	GtkWidget *hbox;
	GtkWidget *find_button;
	GtkWidget *size_label;

	if (logs == NULL)
	{
		/* No logs were found. */
		const char *log_preferences = NULL;

		if (ht == NULL) {
			if (!purple_prefs_get_bool("/purple/logging/log_system"))
				log_preferences = _("System events will only be logged if the \"Log all status changes to system log\" preference is enabled.");
		} else {
			if (ht->type == PURPLE_LOG_IM) {
				if (!purple_prefs_get_bool("/purple/logging/log_ims"))
					log_preferences = _("Instant messages will only be logged if the \"Log all instant messages\" preference is enabled.");
			} else if (ht->type == PURPLE_LOG_CHAT) {
				if (!purple_prefs_get_bool("/purple/logging/log_chats"))
					log_preferences = _("Chats will only be logged if the \"Log all chats\" preference is enabled.");
			}
			g_free(ht->buddyname);
			g_free(ht);
		}

		if(icon != NULL)
			gtk_widget_destroy(icon);

		purple_notify_info(NULL, title, _("No logs were found"), log_preferences);
		return NULL;
	}

	lv = g_new0(PidginLogViewer, 1);
	lv->logs = logs;

	if (ht != NULL)
		g_hash_table_insert(log_viewers, ht, lv);

	/* Window ***********/
	lv->window = gtk_dialog_new_with_buttons(title, NULL, 0,
					     GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, NULL);
#ifdef _WIN32
	/* Steal the "HELP" response and use it to trigger browsing to the logs folder */
	gtk_dialog_add_button(GTK_DIALOG(lv->window), _("_Browse logs folder"), GTK_RESPONSE_HELP);
#endif
	gtk_container_set_border_width (GTK_CONTAINER(lv->window), PIDGIN_HIG_BOX_SPACE);
	gtk_dialog_set_has_separator(GTK_DIALOG(lv->window), FALSE);
	gtk_box_set_spacing(GTK_BOX(GTK_DIALOG(lv->window)->vbox), 0);
	g_signal_connect(G_OBJECT(lv->window), "response",
					 G_CALLBACK(destroy_cb), ht);
	gtk_window_set_role(GTK_WINDOW(lv->window), "log_viewer");

	/* Icon *************/
	if (icon != NULL) {
		title_box = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
		gtk_container_set_border_width(GTK_CONTAINER(title_box), PIDGIN_HIG_BOX_SPACE);
		gtk_box_pack_start(GTK_BOX(GTK_DIALOG(lv->window)->vbox), title_box, FALSE, FALSE, 0);

		gtk_box_pack_start(GTK_BOX(title_box), icon, FALSE, FALSE, 0);
	} else
		title_box = GTK_DIALOG(lv->window)->vbox;

	/* Label ************/
	lv->label = gtk_label_new(NULL);

	text = g_strdup_printf("<span size='larger' weight='bold'>%s</span>", title);

	gtk_label_set_markup(GTK_LABEL(lv->label), text);
	gtk_misc_set_alignment(GTK_MISC(lv->label), 0, 0);
	gtk_box_pack_start(GTK_BOX(title_box), lv->label, FALSE, FALSE, 0);
	g_free(text);

	/* Pane *************/
	pane = gtk_hpaned_new();
	gtk_container_set_border_width(GTK_CONTAINER(pane), PIDGIN_HIG_BOX_SPACE);
	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(lv->window)->vbox), pane, TRUE, TRUE, 0);

	/* List *************/
	sw = gtk_scrolled_window_new (NULL, NULL);
	gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
	gtk_paned_add1(GTK_PANED(pane), sw);
	lv->treestore = gtk_tree_store_new (2, G_TYPE_STRING, G_TYPE_POINTER);
	lv->treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (lv->treestore));
	g_object_unref(G_OBJECT(lv->treestore));
	rend = gtk_cell_renderer_text_new();
	col = gtk_tree_view_column_new_with_attributes ("time", rend, "markup", 0, NULL);
	gtk_tree_view_append_column (GTK_TREE_VIEW(lv->treeview), col);
	gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (lv->treeview), FALSE);
	gtk_container_add (GTK_CONTAINER (sw), lv->treeview);

	populate_log_tree(lv);

	sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (lv->treeview));
	g_signal_connect (G_OBJECT (sel), "changed",
			G_CALLBACK (log_select_cb),
			lv);
	g_signal_connect (G_OBJECT(lv->treeview), "row-activated",
			G_CALLBACK(log_row_activated_cb),
			lv);
	pidgin_set_accessible_label(lv->treeview, lv->label);

	g_signal_connect(lv->treeview, "button-press-event", G_CALLBACK(log_button_press_cb), lv);
	g_signal_connect(lv->treeview, "popup-menu", G_CALLBACK(log_popup_menu_cb), lv);

	/* Log size ************/
	if(log_size) {
		char *sz_txt = purple_str_size_to_units(log_size);
		text = g_strdup_printf("<span weight='bold'>%s</span> %s", _("Total log size:"), sz_txt);
		size_label = gtk_label_new(NULL);
		gtk_label_set_markup(GTK_LABEL(size_label), text);
		/*		gtk_paned_add1(GTK_PANED(pane), size_label); */
		gtk_misc_set_alignment(GTK_MISC(size_label), 0, 0);
		gtk_box_pack_end(GTK_BOX(GTK_DIALOG(lv->window)->vbox), size_label, FALSE, FALSE, 0);
		g_free(sz_txt);
		g_free(text);
	}

	/* A fancy little box ************/
	vbox = gtk_vbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
	gtk_paned_add2(GTK_PANED(pane), vbox);

	/* Viewer ************/
	frame = pidgin_create_imhtml(FALSE, &lv->imhtml, NULL, NULL);
	gtk_widget_set_name(lv->imhtml, "pidgin_log_imhtml");
	gtk_widget_set_size_request(lv->imhtml, 320, 200);
	gtk_box_pack_start(GTK_BOX(vbox), frame, TRUE, TRUE, 0);
	gtk_widget_show(frame);

	/* Search box **********/
	hbox = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
	gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
	lv->entry = gtk_entry_new();
	gtk_box_pack_start(GTK_BOX(hbox), lv->entry, TRUE, TRUE, 0);
	find_button = gtk_button_new_from_stock(GTK_STOCK_FIND);
	gtk_box_pack_start(GTK_BOX(hbox), find_button, FALSE, FALSE, 0);
	g_signal_connect(GTK_ENTRY(lv->entry), "activate", G_CALLBACK(search_cb), lv);
	g_signal_connect(GTK_BUTTON(find_button), "clicked", G_CALLBACK(search_cb), lv);

	select_first_log(lv);

	gtk_widget_show_all(lv->window);

	return lv;
}
Esempio n. 14
0
static void clarity_widget_init (ClarityWidget *self) {
    ClarityWidgetPrivate *priv;

    priv = CLARITY_WIDGET_GET_PRIVATE (self);

    priv->album_model = album_model_new();

    priv->draw_area = clarity_canvas_new();
    g_signal_connect (G_OBJECT(priv->draw_area),
                                    "scroll-event",
                                    G_CALLBACK(_on_scrolling_covers_cb),
                                    priv);

    _set_background_color(self);
    _set_text_color(self);

    priv->leftbutton = gtk_button_new_with_label("<");
    gtk_widget_set_name(priv->leftbutton, LEFT_BUTTON);
    gtk_button_set_relief(GTK_BUTTON(priv->leftbutton), GTK_RELIEF_NONE);
    gtk_widget_set_can_focus(priv->leftbutton, TRUE);
    g_signal_connect (G_OBJECT(priv->leftbutton), "clicked",
                G_CALLBACK(_on_clarity_button_clicked), priv);

    priv->cdslider = gtk_scale_new_with_range(GTK_ORIENTATION_HORIZONTAL, 0, 1, 1);
    gtk_scale_set_digits(GTK_SCALE(priv->cdslider), 0);
    gtk_scale_set_draw_value(GTK_SCALE(priv->cdslider), FALSE);
    gtk_widget_set_can_focus(priv->cdslider, TRUE);
    gtk_range_set_increments(GTK_RANGE(priv->cdslider), 1, 2);
    priv->slider_signal_id = g_signal_connect (G_OBJECT(priv->cdslider), "value-changed",
                G_CALLBACK(_on_clarity_slider_value_changed), priv);

    priv->rightbutton = gtk_button_new_with_label(">");
    gtk_widget_set_name(priv->rightbutton, RIGHT_BUTTON);
    gtk_button_set_relief(GTK_BUTTON(priv->rightbutton), GTK_RELIEF_NONE);
    gtk_widget_set_can_focus(priv->rightbutton, TRUE);
    g_signal_connect (G_OBJECT(priv->rightbutton), "clicked",
                G_CALLBACK(_on_clarity_button_clicked), priv);

    /* Dnd destinaton for foreign image files */
    gtk_drag_dest_set(priv->draw_area, 0, clarity_drop_types, TGNR(clarity_drop_types), GDK_ACTION_COPY
            | GDK_ACTION_MOVE);

    g_signal_connect ((gpointer) priv->draw_area, "drag-drop",
            G_CALLBACK (dnd_clarity_drag_drop),
            NULL);

    g_signal_connect ((gpointer) priv->draw_area, "drag-data-received",
            G_CALLBACK (dnd_clarity_drag_data_received),
            NULL);

    g_signal_connect ((gpointer) priv->draw_area, "drag-motion",
            G_CALLBACK (dnd_clarity_drag_motion),
            NULL);

    /*
     * Ensure everything is inited correctly if gtkpod is loaded with
     * the clarity window is not initially visible.
     */
    g_signal_connect_after(GTK_WIDGET(self), "realize",
            G_CALLBACK(_clarity_widget_realized_cb),
            NULL);

    _init_slider_range(priv);

    priv->controlbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 2);
    gtk_box_pack_start(GTK_BOX(priv->controlbox), priv->leftbutton, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(priv->controlbox), priv->cdslider, TRUE, TRUE, 0);
    gtk_box_pack_start(GTK_BOX(priv->controlbox), priv->rightbutton, FALSE, FALSE, 0);

    priv->contentpanel = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
    gtk_box_pack_start(GTK_BOX(priv->contentpanel), priv->draw_area, TRUE, TRUE, 0);
    gtk_box_pack_end(GTK_BOX(priv->contentpanel), priv->controlbox, FALSE, TRUE, 0);

    gtk_box_pack_start(GTK_BOX (self), priv->contentpanel, TRUE, TRUE, 0);
    gtk_widget_show_all(GTK_WIDGET(self));
}
Esempio n. 15
0
GtkWidget*
create_shrimp (void)
{
  GtkWidget *shrimp;
  GtkWidget *dialog_vbox1;
  GtkWidget *table2;
  GtkWidget *label13;
  GtkWidget *current_version;
  GtkWidget *label15;
  GtkWidget *label16;
  GtkWidget *label17;
  GtkWidget *drives_combo;
  GtkWidget *target_version;
  GtkWidget *target_partitions;
  GtkWidget *status_label;
  GtkWidget *dialog_action_area1;
  GtkWidget *close_button;
  GtkWidget *install_button;

  shrimp = gtk_dialog_new ();
  gtk_widget_set_name (shrimp, "shrimp");
  gtk_window_set_title (GTK_WINDOW (shrimp), _("Thin Client Imager"));
  gtk_window_set_type_hint (GTK_WINDOW (shrimp), GDK_WINDOW_TYPE_HINT_DIALOG);
  gtk_dialog_set_has_separator (GTK_DIALOG (shrimp), FALSE);

  dialog_vbox1 = GTK_DIALOG (shrimp)->vbox;
  gtk_widget_set_name (dialog_vbox1, "dialog_vbox1");
  gtk_widget_show (dialog_vbox1);

  table2 = gtk_table_new (7, 2, FALSE);
  gtk_widget_set_name (table2, "table2");
  gtk_widget_show (table2);
  gtk_box_pack_start (GTK_BOX (dialog_vbox1), table2, TRUE, TRUE, 0);
  gtk_container_set_border_width (GTK_CONTAINER (table2), 6);
  gtk_table_set_row_spacings (GTK_TABLE (table2), 6);
  gtk_table_set_col_spacings (GTK_TABLE (table2), 12);

  label13 = gtk_label_new (_("Currently Running:"));
  gtk_widget_set_name (label13, "label13");
  gtk_widget_show (label13);
  gtk_table_attach (GTK_TABLE (table2), label13, 0, 1, 0, 1,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_misc_set_alignment (GTK_MISC (label13), 1, 0.5);

  current_version = gtk_label_new (_("--"));
  gtk_widget_set_name (current_version, "current_version");
  gtk_widget_show (current_version);
  gtk_table_attach (GTK_TABLE (table2), current_version, 1, 2, 0, 1,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_misc_set_alignment (GTK_MISC (current_version), 0, 0.5);

  label15 = gtk_label_new (_("Target:"));
  gtk_widget_set_name (label15, "label15");
  gtk_widget_show (label15);
  gtk_table_attach (GTK_TABLE (table2), label15, 0, 1, 2, 3,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_misc_set_alignment (GTK_MISC (label15), 1, 0.5);

  label16 = gtk_label_new (_("Version:"));
  gtk_widget_set_name (label16, "label16");
  gtk_table_attach (GTK_TABLE (table2), label16, 0, 1, 3, 4,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_misc_set_alignment (GTK_MISC (label16), 1, 0.5);

  label17 = gtk_label_new (_("Partitions:"));
  gtk_widget_set_name (label17, "label17");
  gtk_widget_show (label17);
  gtk_table_attach (GTK_TABLE (table2), label17, 0, 1, 4, 5,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_misc_set_alignment (GTK_MISC (label17), 1, 0.5);

  drives_combo = gtk_combo_box_new_text ();
  gtk_widget_set_name (drives_combo, "drives_combo");
  gtk_widget_show (drives_combo);
  gtk_table_attach (GTK_TABLE (table2), drives_combo, 1, 2, 2, 3,
                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
                    (GtkAttachOptions) (GTK_FILL), 0, 0);

  target_version = gtk_label_new (_("--"));
  gtk_widget_set_name (target_version, "target_version");
  gtk_table_attach (GTK_TABLE (table2), target_version, 1, 2, 3, 4,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_misc_set_alignment (GTK_MISC (target_version), 0, 0.5);

  target_partitions = gtk_label_new (_("--"));
  gtk_widget_set_name (target_partitions, "target_partitions");
  gtk_widget_show (target_partitions);
  gtk_table_attach (GTK_TABLE (table2), target_partitions, 1, 2, 4, 5,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_label_set_line_wrap (GTK_LABEL (target_partitions), TRUE);
  gtk_misc_set_alignment (GTK_MISC (target_partitions), 0, 0.5);

  status_label = gtk_label_new (_("All data on the target device will be erased"));
  gtk_widget_set_name (status_label, "status_label");
  gtk_widget_show (status_label);
  gtk_table_attach (GTK_TABLE (table2), status_label, 0, 2, 6, 7,
                    (GtkAttachOptions) (GTK_FILL),
                    (GtkAttachOptions) (0), 0, 0);
  gtk_misc_set_alignment (GTK_MISC (status_label), 0, 0.5);

  dialog_action_area1 = GTK_DIALOG (shrimp)->action_area;
  gtk_widget_set_name (dialog_action_area1, "dialog_action_area1");
  gtk_widget_show (dialog_action_area1);
  gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END);

  close_button = gtk_button_new_from_stock ("gtk-close");
  gtk_widget_set_name (close_button, "close_button");
  gtk_widget_show (close_button);
  gtk_dialog_add_action_widget (GTK_DIALOG (shrimp), close_button, GTK_RESPONSE_CLOSE);
  GTK_WIDGET_SET_FLAGS (close_button, GTK_CAN_DEFAULT);

  install_button = gtk_button_new_with_mnemonic (_("Install Image"));
  gtk_widget_set_name (install_button, "install_button");
  gtk_widget_show (install_button);
  gtk_dialog_add_action_widget (GTK_DIALOG (shrimp), install_button, 0);
  GTK_WIDGET_SET_FLAGS (install_button, GTK_CAN_DEFAULT);

  g_signal_connect ((gpointer) drives_combo, "changed",
                    G_CALLBACK (on_drives_combo_changed),
                    NULL);
  g_signal_connect ((gpointer) close_button, "clicked",
                    G_CALLBACK (gtk_main_quit),
                    NULL);
  g_signal_connect ((gpointer) install_button, "clicked",
                    G_CALLBACK (on_install_button_clicked),
                    NULL);

  /* Store pointers to all widgets, for use by lookup_widget(). */
  GLADE_HOOKUP_OBJECT_NO_REF (shrimp, shrimp, "shrimp");
  GLADE_HOOKUP_OBJECT_NO_REF (shrimp, dialog_vbox1, "dialog_vbox1");
  GLADE_HOOKUP_OBJECT (shrimp, table2, "table2");
  GLADE_HOOKUP_OBJECT (shrimp, label13, "label13");
  GLADE_HOOKUP_OBJECT (shrimp, current_version, "current_version");
  GLADE_HOOKUP_OBJECT (shrimp, label15, "label15");
  GLADE_HOOKUP_OBJECT (shrimp, label16, "label16");
  GLADE_HOOKUP_OBJECT (shrimp, label17, "label17");
  GLADE_HOOKUP_OBJECT (shrimp, drives_combo, "drives_combo");
  GLADE_HOOKUP_OBJECT (shrimp, target_version, "target_version");
  GLADE_HOOKUP_OBJECT (shrimp, target_partitions, "target_partitions");
  GLADE_HOOKUP_OBJECT (shrimp, status_label, "status_label");
  GLADE_HOOKUP_OBJECT_NO_REF (shrimp, dialog_action_area1, "dialog_action_area1");
  GLADE_HOOKUP_OBJECT (shrimp, close_button, "close_button");
  GLADE_HOOKUP_OBJECT (shrimp, install_button, "install_button");

  return shrimp;
}
Esempio n. 16
0
 /**
 * create the config widget for the reconcile
 * to modify/delete a reconcile
 *
 * \param
 *
 * \return a GtkWidget containing the config widget
 */
GtkWidget *gsb_reconcile_config_create ( void )
{
    GtkWidget *scrolled_window;
    GtkWidget *vbox_pref;
    GtkWidget *paddinggrid;
    GtkTreeViewColumn *column;
    GtkCellRenderer *cell;
    GtkTreeStore *reconcile_model;
    GtkTreeSelection *reconcile_selection;
    GtkWidget *label;
    gint i;
    gfloat alignment[] = {
	COLUMN_LEFT, COLUMN_CENTER, COLUMN_CENTER,
	COLUMN_RIGHT, COLUMN_RIGHT
    };
    gchar *titles[] = {
	_("Account"), _("Init date"), _("Final date"),
	_("Init balance"), _("Final balance")
    };
    GtkWidget *table_selection;
    GtkWidget *button;
    gint width_entry = 80;
	GrisbiWinEtat *w_etat;

	w_etat = (GrisbiWinEtat *) grisbi_win_get_w_etat ();
    vbox_pref = new_vbox_with_title_and_icon ( _("Reconciliation"),
					       "gsb-reconciliation-32.png" );

    gsb_automem_radiobutton3_new_with_title ( vbox_pref,
                        _("Select the end date of reconciliation: "),
                        _("Start Date + one month"),
                        _("Today's date"),
                        NULL,
                        &w_etat->reconcile_end_date,
                        G_CALLBACK ( gsb_reconcile_config_end_date_changed ),
                        NULL,
                        GTK_ORIENTATION_HORIZONTAL );

    paddinggrid = utils_prefs_paddinggrid_new_with_title (vbox_pref, _("List of reconciliations"));
	gtk_widget_set_vexpand (paddinggrid, TRUE);

    /* set the list */
    scrolled_window = utils_prefs_scrolled_window_new ( NULL, GTK_SHADOW_IN, SW_COEFF_UTIL_PG, 200);
    gtk_grid_attach (GTK_GRID (paddinggrid), scrolled_window, 0, 0, 3, 3);

    /* need to create first the table to set it in the arg of the changed signal of selection */
    table_selection = gtk_grid_new ();
    gtk_grid_set_row_spacing (GTK_GRID (table_selection), 6);
    gtk_grid_set_column_spacing (GTK_GRID (table_selection), 6);

    /* create the model */
    reconcile_model = gtk_tree_store_new ( NUM_RECONCILIATION_COLUMNS,
					   G_TYPE_STRING,    /* Name account or reconciliation */
					   G_TYPE_STRING,    /* init date  */
					   G_TYPE_STRING,    /* final date  */
					   G_TYPE_STRING,    /* init balance  */
					   G_TYPE_STRING,    /* final balance  */
					   G_TYPE_INT,       /* Account number */
					   G_TYPE_INT,       /* Bold or regular text */
					   G_TYPE_INT,		 /* reconciliation number */
					   GDK_TYPE_RGBA);

	reconcile_treeview = gtk_tree_view_new_with_model ( GTK_TREE_MODEL (reconcile_model) );
	gtk_widget_set_name (reconcile_treeview, "tree_view");
    g_object_unref (G_OBJECT(reconcile_model));
    gtk_tree_selection_set_mode ( gtk_tree_view_get_selection (GTK_TREE_VIEW (reconcile_treeview)),
				  GTK_SELECTION_SINGLE );
    gtk_container_add ( GTK_CONTAINER (scrolled_window), reconcile_treeview );

    reconcile_selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (reconcile_treeview));
    g_signal_connect (reconcile_selection,
                      "changed",
                      G_CALLBACK (gsb_reconcile_config_select),
                      table_selection);

    /* Name */
    for (i=RECONCILIATION_NAME_COLUMN ; i<RECONCILIATION_ACCOUNT_COLUMN ; i++)
    {
	cell = gtk_cell_renderer_text_new ();
	g_object_set ( G_OBJECT (cell),
		       "xalign", alignment[i],
		       NULL );
	column = gtk_tree_view_column_new ();
	gtk_tree_view_column_set_sizing ( column,
					  GTK_TREE_VIEW_COLUMN_AUTOSIZE );
	gtk_tree_view_column_set_alignment ( column,
					     alignment[i] );
	gtk_tree_view_column_pack_end ( column, cell, TRUE );
	gtk_tree_view_column_set_title ( column, titles[i] );
	gtk_tree_view_column_set_attributes (column, cell,
					     "text", i,
					     "weight", RECONCILIATION_WEIGHT_COLUMN,
						 "cell-background-rgba", RECONCILIATION_BACKGROUND_COLOR,
					     NULL);
	gtk_tree_view_column_set_expand ( column, TRUE );
	gtk_tree_view_column_set_resizable ( column,
					     TRUE );
	gtk_tree_view_append_column ( GTK_TREE_VIEW(reconcile_treeview), column);
    }

    /* Various remaining settings */
    gsb_reconcile_config_fill();

    /* Set the reconcile_sort */
    button = gsb_automem_checkbutton_new (_("Sort by descending date the reconciliations"),
                                          &w_etat->reconcile_sort,
                                          G_CALLBACK (gsb_reconcile_config_sort_reconcile),
                                          NULL);
    gtk_widget_set_margin_top (button, MARGIN_TOP);
    gtk_grid_attach (GTK_GRID (paddinggrid), button, 0, 3, 1, 1);

	button = gtk_button_new_with_label (_("Collapse row"));
	gtk_widget_set_sensitive (button, FALSE);
	g_signal_connect (G_OBJECT (button),
					  "clicked",
					  G_CALLBACK (gsb_reconcile_button_collapse_row_clicked),
					  reconcile_selection);
	gtk_grid_attach (GTK_GRID (paddinggrid), button, 1, 3, 1, 1);

	/* set signal here because data is button */
    g_signal_connect (reconcile_treeview,
                      "row-expanded",
                      G_CALLBACK (gsb_reconcile_treeview_row_expanded),
                      button);

    g_signal_connect (reconcile_treeview,
                      "row-collapsed",
                      G_CALLBACK (gsb_reconcile_treeview_row_collapsed),
                      button);

    /* set the modifying part under the list */
    paddinggrid = utils_prefs_paddinggrid_new_with_title (vbox_pref,_("Selected reconcile") );

    /* for that we make a table 2x3 but with the names 4x3,
     * the table has been set before to accept as arg on the changed selection */
    gtk_grid_attach (GTK_GRID (paddinggrid), table_selection, 0, 0, 1, 1);

    /* set the name */
	label = gtk_label_new ( _("Reconciliation reference: ") );
	utils_labels_set_alignment ( GTK_LABEL (label), 0, 0.5);
	gtk_label_set_justify ( GTK_LABEL (label), GTK_JUSTIFY_LEFT );
	gtk_grid_attach (GTK_GRID (table_selection), label, 0, 0, 1, 1);

	reconcile_name_entry = gsb_autofunc_entry_new ( NULL,
			G_CALLBACK (gsb_reconcile_config_update_line), reconcile_treeview,
			G_CALLBACK (gsb_data_reconcile_set_name), 0 );
    gtk_widget_set_size_request ( reconcile_name_entry, width_entry, -1 );
	gtk_grid_attach (GTK_GRID (table_selection), reconcile_name_entry, 1, 0, 1, 1);

	/* set the initial date */
	label = gtk_label_new ( _("Initial date: ") );
	utils_labels_set_alignment ( GTK_LABEL (label), 0, 0.5);
	gtk_label_set_justify ( GTK_LABEL (label), GTK_JUSTIFY_LEFT );
	gtk_grid_attach (GTK_GRID (table_selection), label, 0, 1, 1, 1);

	reconcile_init_date_entry = gsb_autofunc_date_new ( NULL,
			G_CALLBACK (gsb_reconcile_config_update_line), reconcile_treeview,
			G_CALLBACK (gsb_data_reconcile_set_init_date), 0 );
    gtk_widget_set_size_request ( reconcile_init_date_entry, width_entry, -1 );
	gtk_grid_attach (GTK_GRID (table_selection), reconcile_init_date_entry, 1, 1, 1, 1);

    /* set the final date */
	label = gtk_label_new ( _("Final date: ") );
	utils_labels_set_alignment ( GTK_LABEL (label), 0, 0.5);
	gtk_label_set_justify ( GTK_LABEL (label), GTK_JUSTIFY_LEFT );
	gtk_grid_attach (GTK_GRID (table_selection), label, 0, 2, 1, 1);

	reconcile_final_date_entry = gsb_autofunc_date_new ( NULL,
			G_CALLBACK (gsb_reconcile_config_update_line), reconcile_treeview,
			G_CALLBACK (gsb_data_reconcile_set_final_date), 0 );
    gtk_widget_set_size_request ( reconcile_final_date_entry, width_entry, -1 );
	gtk_grid_attach (GTK_GRID (table_selection), reconcile_final_date_entry, 1, 2, 1, 1);

    /* set the delete button */
	delete_reconcile_button = gtk_button_new_with_label (_("Delete the reconcile"));
    gtk_button_set_relief ( GTK_BUTTON (delete_reconcile_button), GTK_RELIEF_NORMAL);
	g_signal_connect ( G_OBJECT (delete_reconcile_button), "clicked",
			G_CALLBACK (gsb_reconcile_config_delete),
			reconcile_treeview );
	gtk_grid_attach (GTK_GRID (table_selection), delete_reconcile_button, 2, 0, 2, 1);

	/* set the initial balance */
	label = gtk_label_new ( _("Initial balance: ") );
	utils_labels_set_alignment ( GTK_LABEL (label), 0, 0.5);
	gtk_label_set_justify ( GTK_LABEL (label), GTK_JUSTIFY_LEFT );
	gtk_grid_attach (GTK_GRID (table_selection), label, 2, 1, 1, 1);

	reconcile_init_balance_entry = gsb_autofunc_real_new ( null_real,
			G_CALLBACK (gsb_reconcile_config_update_line), reconcile_treeview,
			G_CALLBACK (gsb_data_reconcile_set_init_balance), 0 );
    gtk_widget_set_size_request ( reconcile_init_balance_entry, width_entry, -1 );
	gtk_grid_attach (GTK_GRID (table_selection), reconcile_init_balance_entry, 3, 1, 1, 1);

    /* set the final balance */
	label = gtk_label_new ( _("Final balance: ") );
	utils_labels_set_alignment ( GTK_LABEL (label), 0, 0.5);
	gtk_label_set_justify ( GTK_LABEL (label), GTK_JUSTIFY_LEFT );
	gtk_grid_attach (GTK_GRID (table_selection), label, 2, 2, 1, 1);

	reconcile_final_balance_entry = gsb_autofunc_real_new ( null_real,
			G_CALLBACK (gsb_reconcile_config_update_line), reconcile_treeview,
			G_CALLBACK (gsb_data_reconcile_set_final_balance), 0 );
    gtk_widget_set_size_request ( reconcile_final_balance_entry, width_entry, -1 );
    gtk_grid_attach (GTK_GRID (table_selection), reconcile_final_balance_entry, 3, 2, 1, 1);

	/* at the beginning, the table is unsensitive */
	gtk_widget_set_sensitive ( table_selection, FALSE );

    /* set the button to find non-associated transactions */
	button = gtk_button_new_with_label (
                        _("Find all marked transactions not associated with a reconciliation"));
	gtk_button_set_relief ( GTK_BUTTON (button), GTK_RELIEF_NORMAL );
    utils_widget_set_padding (button, 0, MARGIN_TOP);
	g_signal_connect ( G_OBJECT (button),
                      "clicked",
                      G_CALLBACK (gsb_reconcile_config_find_alone_transactions),
                      NULL );
    gtk_grid_attach (GTK_GRID (paddinggrid), button, 0, 1, 1, 1);

    gtk_widget_show_all (vbox_pref);
	utils_set_tree_store_background_color (reconcile_treeview, RECONCILIATION_BACKGROUND_COLOR);

	if ( !gsb_data_account_get_accounts_amount () )
    {
	gtk_widget_set_sensitive ( vbox_pref, FALSE );
    }

    return vbox_pref;
}
Esempio n. 17
0
/*----------导入功能up----------------------------------------------------------------*/
void create_view(GtkWidget *container,gpointer data)//容器管理的主界面
{
	GtkTreeViewColumn *column22;
	GtkTreeViewColumn *column33;
	GtkTreeViewColumn *column44;
	GtkWidget *window;
	//GtkWidget *combox_images;
	GtkBuilder *builder;
	GtkTreeIter iter;
	GtkWidget *button11;
	GtkWidget *button22;
	GtkWidget *button33;
	GtkWidget *button44;
	GtkWidget *button55;
	GtkWidget *button66;
	GtkWidget *button77;
	GtkWidget *button88;
	GtkWidget *button99;
	GtkWidget *button110;
	
	GtkCellRenderer *cell11;
	GtkListStore *list11;
	
	GtkCellRenderer *cell;
	GtkTreeSelection *selection;
	static int j;
	docker_contain();
	builder=gtk_builder_new ();
	gtk_builder_add_from_file (builder,CONTAINER_MANAGE_FILE,NULL);
	window=GTK_WIDGET(gtk_builder_get_object (builder,CONTAINER_MANAGE_WINDOW));
	gtk_window_set_title (window,_("contians manage"));
	gtk_widget_set_name(window, "nfs_container_mange_window");
	button11=GTK_WIDGET(gtk_builder_get_object (builder,"button1"));
	button22=GTK_WIDGET(gtk_builder_get_object (builder,"button2"));
	button33=GTK_WIDGET(gtk_builder_get_object (builder,"button3"));
	button44=GTK_WIDGET(gtk_builder_get_object (builder,"button4"));
	button55=GTK_WIDGET(gtk_builder_get_object (builder,"button5"));
	button66=GTK_WIDGET(gtk_builder_get_object (builder,"button6"));
	button77=GTK_WIDGET(gtk_builder_get_object (builder,"button7"));
	button88=GTK_WIDGET(gtk_builder_get_object (builder,"button8"));
	button99=GTK_WIDGET(gtk_builder_get_object (builder,"button9"));
	button110=GTK_WIDGET(gtk_builder_get_object (builder,"button10"));
	
	column22=GTK_WIDGET(gtk_builder_get_object (builder,"treeviewcolumn1"));
	column33=GTK_WIDGET(gtk_builder_get_object (builder,"treeviewcolumn2"));
	column44=GTK_WIDGET(gtk_builder_get_object (builder,"treeviewcolumn3"));
	gtk_tree_view_column_set_title (column22,_("Mirror image"));
	cell=gtk_cell_renderer_text_new ();
	gtk_tree_view_column_pack_start (column22, cell,FALSE);
	gtk_tree_view_column_set_attributes(column22,cell,"text",0,NULL);
	
	gtk_tree_view_column_set_title (column33,"ID");
	cell=gtk_cell_renderer_text_new ();
	gtk_tree_view_column_pack_start (column33,cell,FALSE);
	gtk_tree_view_column_set_attributes(column33,cell,"text",1,NULL);
	
	gtk_tree_view_column_set_title (column44,_("name_colum"));
	cell=gtk_cell_renderer_text_new ();
	gtk_tree_view_column_pack_start (column44,cell,FALSE);
	gtk_tree_view_column_set_attributes(column44,cell,"text",2,NULL);
	
	gtk_button_set_label (GTK_BUTTON(button11),_("starting contain and enter"));
	
	gtk_button_set_label (GTK_BUTTON(button22),_("stop contian"));
         gtk_button_set_label (GTK_BUTTON(button33),_("create gurd contian"));
         gtk_button_set_label (GTK_BUTTON(button44),_("create contian"));
         gtk_button_set_label (GTK_BUTTON(button55),_("export"));
	
	gtk_button_set_label (GTK_BUTTON(button66),_("ls starting contain"));
	gtk_button_set_label (GTK_BUTTON(button77),_("ls gurd contain"));
	gtk_button_set_label (GTK_BUTTON(button88),_("dele on contian"));
	gtk_button_set_label (GTK_BUTTON(button99),_("dele mul contians"));
	gtk_button_set_label (GTK_BUTTON(button110),_("import"));
	
	tree_view=GTK_WIDGET(gtk_builder_get_object (builder,"treeview1"));
	list11=gtk_list_store_new (4, G_TYPE_STRING,G_TYPE_STRING, G_TYPE_STRING,G_TYPE_STRING);
	gtk_tree_view_set_model (GTK_TREE_VIEW(tree_view),GTK_TREE_MODEL(list11));
	selection=gtk_tree_view_get_selection (GTK_TREE_VIEW(tree_view));

	

	
	//mod=gtk_tree_view_get_model (GTK_TREE_VIEW(tree_view));
	g_signal_connect(G_OBJECT(tree_view),"cursor-changed",G_CALLBACK(clicked_row11),selection);
	//g_signal_connect(G_OBJECT(selection),"changed",G_CALLBACK(clicked_row11),selection);
	g_signal_connect(G_OBJECT(button11),"clicked",G_CALLBACK(button11_treeview_fun),selection);
	g_signal_connect(G_OBJECT(button88),"clicked",G_CALLBACK(button88_treeview_fun),selection);
	g_signal_connect(G_OBJECT(button44),"clicked",G_CALLBACK(button44_treeview_fun),selection);
	g_signal_connect(G_OBJECT(button33),"clicked",G_CALLBACK(button33_treeview_fun),selection);
	g_signal_connect(G_OBJECT(button99),"clicked",G_CALLBACK(button99_treeview_fun),selection);
	g_signal_connect(G_OBJECT(button66),"clicked",G_CALLBACK(button33_fun),"docker ps");
	g_signal_connect(G_OBJECT(button22),"clicked",G_CALLBACK(button22_treeview_fun),selection);
	g_signal_connect(G_OBJECT(button110),"clicked",G_CALLBACK(import_selcet_file),window);
	g_signal_connect(G_OBJECT(button55),"clicked",G_CALLBACK(export_selcet_file),selection);
	g_signal_connect(G_OBJECT(button77),"clicked",G_CALLBACK(button77_lsgurd_fun),window);
	
		for(j=0;j<contains_num;j++){
	gtk_list_store_append (list11,&iter);
	gtk_list_store_set (list11, &iter, 0,&a[j].image,-1);
	gtk_list_store_set (list11, &iter, 1,&a[j].id,-1);
	gtk_list_store_set (list11, &iter, 2,&a[j].name,-1);
		}
	
	g_object_unref (builder);
	
	gtk_widget_show_all (window);
	//return tree_view;

}
Esempio n. 18
0
static void
ephy_toolbar_constructed (GObject *object)
{
  EphyToolbarPrivate *priv = EPHY_TOOLBAR (object)->priv;
  GtkActionGroup *action_group;
  GtkAction *action;
  GtkToolItem *back_forward, *location_stop_reload, *tool_item;
  GtkWidget *tool_button, *box, *location, *toolbar;
  GtkSizeGroup *size;

  G_OBJECT_CLASS (ephy_toolbar_parent_class)->constructed (object);

  toolbar = GTK_WIDGET (object);

  /* Create a GtkSizeGroup to sync the height of the location entry, and
   * the stop/reload button. */
  size = gtk_size_group_new (GTK_SIZE_GROUP_VERTICAL);

  /* Set the MENUBAR style class so it's possible to drag the app
   * using the toolbar. */
  gtk_style_context_add_class (gtk_widget_get_style_context (toolbar),
                               GTK_STYLE_CLASS_MENUBAR);

  /* Back and Forward */
  back_forward = gtk_tool_item_new ();
  box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);

  /* Back */
  tool_button = ephy_middle_clickable_button_new ();
  /* FIXME: apparently we need an image inside the button for the action
   * icon to appear. */
  gtk_button_set_image (GTK_BUTTON (tool_button), gtk_image_new ());
  action_group = ephy_window_get_toolbar_action_group (priv->window);
  action = gtk_action_group_get_action (action_group, "NavigationBack");
  gtk_activatable_set_related_action (GTK_ACTIVATABLE (tool_button),
                                      action);
  gtk_button_set_label (GTK_BUTTON (tool_button), NULL);
  gtk_container_add (GTK_CONTAINER (box), GTK_WIDGET (tool_button));

  /* Forward */
  tool_button = ephy_middle_clickable_button_new ();
  /* FIXME: apparently we need an image inside the button for the action
   * icon to appear. */
  gtk_button_set_image (GTK_BUTTON (tool_button), gtk_image_new ());
  action = gtk_action_group_get_action (action_group, "NavigationForward");
  gtk_activatable_set_related_action (GTK_ACTIVATABLE (tool_button),
                                      action);
  gtk_button_set_label (GTK_BUTTON (tool_button), NULL);
  gtk_container_add (GTK_CONTAINER (box), GTK_WIDGET (tool_button));

  gtk_style_context_add_class (gtk_widget_get_style_context (box),
                               "raised");
  gtk_style_context_add_class (gtk_widget_get_style_context (box),
                               "linked");

  gtk_container_add (GTK_CONTAINER (back_forward), box);
  gtk_container_add (GTK_CONTAINER (toolbar), GTK_WIDGET (back_forward));
  gtk_widget_show_all (GTK_WIDGET (back_forward));
  gtk_widget_set_margin_right (GTK_WIDGET (back_forward), 12);

  /* Location and Reload/Stop */
  location_stop_reload = gtk_tool_item_new ();
  box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);

  /* Location */
  priv->entry = location = ephy_location_entry_new ();
  gtk_box_pack_start (GTK_BOX (box), location,
                      TRUE, TRUE, 0);
  gtk_style_context_add_class (gtk_widget_get_style_context (box),
                               "location-entry");

  /* Reload/Stop */
  tool_button = gtk_button_new ();
  /* FIXME: apparently we need an image inside the button for the action
   * icon to appear. */
  gtk_button_set_image (GTK_BUTTON (tool_button), gtk_image_new ());
  action = gtk_action_group_get_action (action_group, "ViewCombinedStopReload");
  gtk_activatable_set_related_action (GTK_ACTIVATABLE (tool_button),
                                      action);
  gtk_container_add (GTK_CONTAINER (box), GTK_WIDGET (tool_button));

  gtk_container_add (GTK_CONTAINER (location_stop_reload), box);
  gtk_container_child_set (GTK_CONTAINER (toolbar),
                           GTK_WIDGET (location_stop_reload),
                           "expand", TRUE,
                           NULL);
  
  gtk_container_add (GTK_CONTAINER (toolbar), GTK_WIDGET (location_stop_reload));

  gtk_size_group_add_widget (size, tool_button);
  gtk_size_group_add_widget (size, location);
  g_object_unref (size);

  gtk_widget_set_margin_right (GTK_WIDGET (location_stop_reload), 12);
  gtk_widget_show_all (GTK_WIDGET (location_stop_reload));

  /* Page Menu */
  tool_item = gtk_tool_item_new ();
  tool_button = gtk_button_new ();
  gtk_widget_set_name (GTK_WIDGET (tool_button), "ephy-page-menu-button");
  /* FIXME: apparently we need an image inside the button for the action
   * icon to appear. */
  gtk_button_set_image (GTK_BUTTON (tool_button), gtk_image_new ());
  action = gtk_action_group_get_action (action_group, "PageMenu");
  gtk_activatable_set_related_action (GTK_ACTIVATABLE (tool_button),
                                      action);
  gtk_container_add (GTK_CONTAINER (tool_item), tool_button);
  gtk_container_add (GTK_CONTAINER (toolbar), GTK_WIDGET (tool_item));
  gtk_widget_show_all (GTK_WIDGET (tool_item));
}
Esempio n. 19
0
// widget layout
// sortTypeSelection
// |--background
//    |--alignment
//       |--vbox1
//          |--sortLabel
//          |--vbox2 
//             |--vbox3_1
//                |--sortTypeLabel
//                |--hbox
//                   |--fileNameButton
//                   |--fileExtButton
//                   |--fileSizeButton
//                   |--dateButton
//             |--vbox3_2
//                |--sortTagLabel
//                |--hbox
//                   |--titleButton
//                   |--descButton
static GtkWidget *create_sort_type_widget(void)
{
    int        i;
    GtkWidget *sortTypeSelection;       // use it to combine buttons to be radio buttons 
    GtkWidget *background;
    GtkWidget *alignment;
    GtkWidget *vbox1;
    GtkWidget *sortLabel;
    GtkWidget *vbox2;
    GtkWidget *vbox3_1;
    GtkWidget *sortTypeLabel;
    GtkWidget *hbox1;
    GtkWidget *vbox3_2;
    GtkWidget *sortTagLabel;
    GtkWidget *hbox2;
    GtkWidget *button;
    GtkToggleButton *button_tbl[eButtonUndefined + 1];

    // background
    background = gtk_event_box_new();
    gtk_widget_set_name(background, "sort_type_background");
    gtk_widget_set_size_request(background, SORT_WND_SORTTYPE_BK_WIDTH, SORT_WND_SROTTYPE_BK_HEIGHT);
    // alignment
    alignment = gtk_alignment_new(0.0, 0.0, 0.0, 0.0);
    gtk_alignment_set_padding(GTK_ALIGNMENT(alignment),
                              SORT_WND_TOP_PADDING, SORT_WND_BOTTOM_PADDING,
                              SORT_WND_LEFT_PADDING, SORT_WND_RIGHT_PADDING);
    gtk_container_add(GTK_CONTAINER(background), alignment);
    // vbox1
    vbox1 = gtk_vbox_new(FALSE, SORT_WND_SPACING_V * 3);
    gtk_container_add(GTK_CONTAINER(alignment), vbox1);
    // sortLabel
    sortLabel = gtk_label_new("");
    gtk_widget_set_name(sortLabel, "sort_wnd_text_bold");
    gtk_misc_set_alignment(GTK_MISC(sortLabel), 0.0, 0.5);
    gtk_label_set_ellipsize(GTK_LABEL(sortLabel), PANGO_ELLIPSIZE_END);
    gtk_label_set_justify(GTK_LABEL(sortLabel), GTK_JUSTIFY_LEFT);
    gtk_box_pack_start(GTK_BOX(vbox1), sortLabel, FALSE, FALSE, 0);
    // vbox2
    vbox2 = gtk_vbox_new(FALSE, SORT_WND_SPACING_V * 3);
    gtk_box_pack_start(GTK_BOX(vbox1), vbox2, FALSE, FALSE, 0);
    // vbox3_1
    vbox3_1 = gtk_vbox_new(FALSE, SORT_WND_SPACING_V * 2);
    gtk_box_pack_start(GTK_BOX(vbox2), vbox3_1, FALSE, FALSE, 0);
    // sortTypeLabel
    sortTypeLabel = gtk_label_new("");
    gtk_widget_set_name(sortTypeLabel, "sort_wnd_text_normal");
    gtk_misc_set_alignment(GTK_MISC(sortTypeLabel), 0.0, 0.5);
    gtk_label_set_ellipsize(GTK_LABEL(sortTypeLabel), PANGO_ELLIPSIZE_END);
    gtk_label_set_justify(GTK_LABEL(sortTypeLabel), GTK_JUSTIFY_LEFT);
    gtk_box_pack_start(GTK_BOX(vbox3_1), sortTypeLabel, FALSE, FALSE, 0);
    // hbox1
    hbox1 = gtk_hbox_new(FALSE, SORT_WND_SPACING_H);
    gtk_box_pack_start(GTK_BOX(vbox3_1), hbox1, FALSE, FALSE, 0);
    // vbox3_2
    vbox3_2 = gtk_vbox_new(FALSE, SORT_WND_SPACING_V * 2);
    gtk_box_pack_start(GTK_BOX(vbox2), vbox3_2, FALSE, FALSE, 0);
    // sortTagLabel
    sortTagLabel = gtk_label_new("");
    gtk_widget_set_name(sortTagLabel, "sort_wnd_text_normal");
    gtk_misc_set_alignment(GTK_MISC(sortTagLabel), 0.0, 0.5);
    gtk_label_set_ellipsize(GTK_LABEL(sortTagLabel), PANGO_ELLIPSIZE_END);
    gtk_label_set_justify(GTK_LABEL(sortTagLabel), GTK_JUSTIFY_LEFT);
    gtk_box_pack_start(GTK_BOX(vbox3_2), sortTagLabel, FALSE, FALSE, 0);
    // hbox2
    hbox2 = gtk_hbox_new(FALSE, SORT_WND_SPACING_H);
    gtk_box_pack_start(GTK_BOX(vbox3_2), hbox2, FALSE, FALSE, 0);
    // create buttons
    for (i = 0 ; i < eButtonUndefined ; i++)
    {
        button = ergtk_toggle_button_new_with_label("");
        button_tbl[i] = GTK_TOGGLE_BUTTON(button);
        gtk_widget_set_size_request(button, SORT_WND_BUTTON_WIDTH, SORT_WND_BUTTON_HEIGHT);
        switch (i)
        {
            case eFileNameButton:
            case eFileExtButton:
            case eFileSizeButton:
            case eDateButton:
                gtk_box_pack_start(GTK_BOX(hbox1), button, FALSE, FALSE, 0);
                break;
            case eTitleButton:
            case eDescButton:
                gtk_box_pack_start(GTK_BOX(hbox2), button, FALSE, FALSE, 0);
                break;
            default:
                break;
        }
    }
    button_tbl[eButtonUndefined] = NULL;
    // add buttons to selection group
    sortTypeSelection = ergtk_selection_group_new(button_tbl);
    ergtk_selection_group_set_details(ERGTK_SELECTION_GROUP(sortTypeSelection), 1, 1);
    gtk_container_add(GTK_CONTAINER(sortTypeSelection), background);

    // show widgets
    gtk_widget_show_all(sortTypeSelection);
    // set global values
    g_sort_wnd.sortLabel = sortLabel;
    g_sort_wnd.sortTypeLabel = sortTypeLabel;
    g_sort_wnd.sortTypeSelection = sortTypeSelection;
    g_sort_wnd.sortTagLabel = sortTagLabel;
    // signals functions
    g_signal_connect(G_OBJECT(sortTypeSelection), "selection_update", G_CALLBACK(on_sort_type_selection_update), NULL);

    // return
    return sortTypeSelection;
}
Esempio n. 20
0
static GtkWidget *create_dialog(void)
{
	GtkWidget *dialog;
	GtkWidget *header_image;
	GtkWidget *header_label;
	GtkWidget *label_info;
	GtkWidget *codename_label;
	GtkWidget *builddate_label;
	GtkWidget *url_button;
	GtkWidget *cop_label;
	GtkWidget *label;
	GtkWidget *license_textview;
	GtkWidget *notebook;
	GtkWidget *box;
	GtkWidget *credits_scrollwin;
	GtkWidget *table;
	GtkWidget *license_scrollwin;
	GtkWidget *info_box;
	GtkWidget *header_hbox;
	GtkWidget *header_eventbox;
	GtkTextBuffer* tb;
	gchar *license_text = NULL;
	gchar buffer[512];
	gchar buffer2[128];
	guint i, row = 0;
	gchar *build_date;

	dialog = gtk_dialog_new();

	/* configure dialog */
	gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(main_widgets.window));
	gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT);
	gtk_window_set_title(GTK_WINDOW(dialog), _("About Geany"));
	gtk_window_set_icon_name(GTK_WINDOW(dialog), "geany");
	gtk_widget_set_name(dialog, "GeanyDialog");
	gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE);
	gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE);
	g_signal_connect(dialog, "key-press-event", G_CALLBACK(gb_on_key_pressed), NULL);

	/* create header */
	header_eventbox = gtk_event_box_new();
	gtk_widget_show(header_eventbox);
	header_hbox = gtk_hbox_new(FALSE, 12);
	gtk_container_set_border_width(GTK_CONTAINER(header_hbox), 4);
	gtk_widget_show(header_hbox);
	gtk_container_add(GTK_CONTAINER(header_eventbox), header_hbox);
	header_image = gtk_image_new_from_icon_name("geany", GTK_ICON_SIZE_DIALOG);
	gtk_box_pack_start(GTK_BOX(header_hbox), header_image, FALSE, FALSE, 0);
	header_label = gtk_label_new(NULL);
	gtk_label_set_use_markup(GTK_LABEL(header_label), TRUE);
	/* print the subversion revision generated by ./configure if it is available */
	g_snprintf(buffer, sizeof(buffer), HEADER, main_get_version_string());
	gtk_label_set_markup(GTK_LABEL(header_label), buffer);
	gtk_widget_show(header_label);
	gtk_box_pack_start(GTK_BOX(header_hbox), header_label, FALSE, FALSE, 0);
	header_eventbox_style_set(header_eventbox);
	header_label_style_set(header_label);
	g_signal_connect_after(header_eventbox, "style-set", G_CALLBACK(header_eventbox_style_set), NULL);
	g_signal_connect_after(header_label, "style-set", G_CALLBACK(header_label_style_set), NULL);
	gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), header_eventbox, FALSE, FALSE, 0);

	/* create notebook */
	notebook = gtk_notebook_new();
	gtk_widget_show(notebook);
	gtk_container_set_border_width(GTK_CONTAINER(notebook), 2);
	gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(dialog))), notebook, TRUE, TRUE, 0);

	/* create "Info" tab */
	info_box = gtk_vbox_new(FALSE, 0);
	gtk_container_set_border_width(GTK_CONTAINER(info_box), 6);
	gtk_widget_show(info_box);

	label_info = gtk_label_new(NULL);
	gtk_label_set_justify(GTK_LABEL(label_info), GTK_JUSTIFY_CENTER);
	gtk_label_set_selectable(GTK_LABEL(label_info), TRUE);
	gtk_label_set_use_markup(GTK_LABEL(label_info), TRUE);
	g_snprintf(buffer, sizeof(buffer), INFO, _("A fast and lightweight IDE"));
	gtk_label_set_markup(GTK_LABEL(label_info), buffer);
	gtk_misc_set_padding(GTK_MISC(label_info), 2, 11);
	gtk_widget_show(label_info);
	gtk_box_pack_start(GTK_BOX(info_box), label_info, FALSE, FALSE, 0);

	/* Codename label */
	codename_label = gtk_label_new(NULL);
	gtk_label_set_justify(GTK_LABEL(codename_label), GTK_JUSTIFY_CENTER);
	gtk_label_set_selectable(GTK_LABEL(codename_label), TRUE);
	gtk_label_set_use_markup(GTK_LABEL(codename_label), TRUE);
	gtk_label_set_markup(GTK_LABEL(codename_label), CODENAME);
	gtk_misc_set_padding(GTK_MISC(codename_label), 2, 8);
	gtk_widget_show(codename_label);
	gtk_box_pack_start(GTK_BOX(info_box), codename_label, FALSE, FALSE, 0);

	/* build date label */
	builddate_label = gtk_label_new(NULL);
	gtk_label_set_justify(GTK_LABEL(builddate_label), GTK_JUSTIFY_CENTER);
	gtk_label_set_selectable(GTK_LABEL(builddate_label), TRUE);
	gtk_label_set_use_markup(GTK_LABEL(builddate_label), TRUE);
	build_date = utils_parse_and_format_build_date(__DATE__);
	g_snprintf(buffer2, sizeof(buffer2), _("(built on or after %s)"), build_date);
	g_free(build_date);
	g_snprintf(buffer, sizeof(buffer), BUILDDATE, buffer2);
	gtk_label_set_markup(GTK_LABEL(builddate_label), buffer);
	gtk_misc_set_padding(GTK_MISC(builddate_label), 2, 2);
	gtk_widget_show(builddate_label);
	gtk_box_pack_start(GTK_BOX(info_box), builddate_label, FALSE, FALSE, 0);

	box = gtk_hbutton_box_new();
	url_button = gtk_button_new();
	gtk_button_set_relief(GTK_BUTTON(url_button), GTK_RELIEF_NONE);
	g_signal_connect(url_button, "clicked", G_CALLBACK(homepage_clicked), (gpointer)GEANY_HOMEPAGE);
	label = gtk_label_new(NULL);
	gtk_label_set_text(GTK_LABEL(label), GEANY_HOMEPAGE);
	gtk_widget_show(label);
	gtk_container_add(GTK_CONTAINER(url_button), label);
	gtk_widget_show(url_button);
	gtk_box_pack_start(GTK_BOX(box), url_button, FALSE, FALSE, 0);
	gtk_widget_show(box);
	gtk_box_pack_start(GTK_BOX(info_box), box, FALSE, FALSE, 10);

	/* copyright label */
	cop_label = gtk_label_new(NULL);
	gtk_label_set_justify(GTK_LABEL(cop_label), GTK_JUSTIFY_CENTER);
	gtk_label_set_selectable(GTK_LABEL(cop_label), FALSE);
	gtk_label_set_use_markup(GTK_LABEL(cop_label), TRUE);
	gtk_label_set_markup(GTK_LABEL(cop_label), COPYRIGHT);
	gtk_misc_set_padding(GTK_MISC(cop_label), 2, 10);
	gtk_widget_show(cop_label);
	gtk_box_pack_start(GTK_BOX(info_box), cop_label, FALSE, FALSE, 0);
	/*gtk_container_add(GTK_CONTAINER(info_box), cop_label); */

	label = gtk_label_new(_("Info"));
	gtk_widget_show(label);
	gtk_widget_show_all(info_box);
	gtk_notebook_append_page(GTK_NOTEBOOK(notebook), info_box, label);

	/* create "Credits" tab */
	credits_scrollwin = gtk_scrolled_window_new(NULL, NULL);
	gtk_container_set_border_width(GTK_CONTAINER(credits_scrollwin), 6);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(credits_scrollwin),
		GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);

	table = gtk_table_new(23 + translators_len + prev_translators_len, 3, FALSE);
	gtk_table_set_col_spacings(GTK_TABLE(table), 10);

	row = 0;
	g_snprintf(buffer, sizeof(buffer),
		"<span size=\"larger\" weight=\"bold\">%s</span>", _("Developers"));
	label = gtk_label_new(buffer);
	gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, GTK_FILL, 0, 0, 5);
	gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
	gtk_misc_set_alignment(GTK_MISC(label), 0, 0);
	row++;

	g_snprintf(buffer, sizeof(buffer), "Colomban Wendling - %s", _("maintainer"));
	ROW(buffer, row, 0, 0, 0, 1);
	row++;
	ROW("&lt;[email protected]&gt;", row, 0, 0, 0, 1);
	row++;
	ROW("", row, 0, 0, 0, 0);
	row++;

	g_snprintf(buffer, sizeof(buffer), "Nick Treleaven - %s", _("developer"));
	ROW(buffer, row, 0, 0, 0, 1);
	row++;
	ROW("&lt;[email protected]&gt;", row, 0, 0, 0, 1);
	row++;
	ROW("", row, 0, 0, 0, 0);
	row++;

	g_snprintf(buffer, sizeof(buffer), "Enrico Tröger - %s", _("developer"));
	ROW(buffer, row, 0, 0, 0, 1);
	row++;
	ROW("&lt;[email protected]&gt;", row, 0, 0, 0, 1);
	row++;
	ROW("", row, 0, 0, 0, 0);
	row++;

	g_snprintf(buffer, sizeof(buffer), "Matthew Brush - %s", _("developer"));
	ROW(buffer, row, 0, 0, 0, 1);
	row++;
	ROW("&lt;[email protected]&gt;", row, 0, 0, 0, 1);
	row++;
	ROW("", row, 0, 0, 0, 0);
	row++;

	g_snprintf(buffer, sizeof(buffer), "Frank Lanitz - %s", _("translation maintainer"));
	ROW(buffer, row, 0, 0, 0, 1);
	row++;
	ROW("&lt;[email protected]&gt;", row, 0, 0, 0, 1);
	row++;
	ROW("", row, 0, 0, 0, 0);
	row++;

	g_snprintf(buffer, sizeof(buffer),
		"<span size=\"larger\" weight=\"bold\">%s</span>", _("Translators"));
	label = gtk_label_new(buffer);
	gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
					(GtkAttachOptions) (GTK_FILL),
					(GtkAttachOptions) (0), 0, 5);
	gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
	gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
	row++;

	for (i = 0; i < translators_len; i++)
	{
		ROW(translators[i][0], row, 0, 1, 4, 0);
		ROW(translators[i][1], row, 1, 0, 4, 0);
		row++;
	}

	ROW("", row, 0, 0, 0, 0);
	row++;

	g_snprintf(buffer, sizeof(buffer),
		"<span size=\"larger\" weight=\"bold\">%s</span>", _("Previous Translators"));
	label = gtk_label_new(buffer);
	gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
					(GtkAttachOptions) (GTK_FILL),
					(GtkAttachOptions) (0), 0, 5);
	gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
	gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
	row++;

	for (i = 0; i < prev_translators_len; i++)
	{
		ROW(prev_translators[i][0], row, 0, 1, 4, 0);
		ROW(prev_translators[i][1], row, 1, 0, 4, 0);
		row++;
	}


	ROW("", row, 0, 0, 0, 0);
	row++;

	g_snprintf(buffer, sizeof(buffer),
		"<span size=\"larger\" weight=\"bold\">%s</span>", _("Contributors"));
	label = gtk_label_new(buffer);
	gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
					(GtkAttachOptions) (GTK_FILL),
					(GtkAttachOptions) (0), 0, 5);
	gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
	gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
	row++;

	g_snprintf(buffer, sizeof(buffer),
		_("Some of the many contributors (for a more detailed list, see the file %s):"),
#ifdef G_OS_WIN32
			"Thanks.txt"
#else
			"THANKS"
#endif
		);
	label = geany_wrap_label_new(buffer);
	gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
					(GtkAttachOptions) (GTK_FILL),
					(GtkAttachOptions) (0), 0, 5);
	gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
	gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
	row++;

	label = geany_wrap_label_new(contributors);
	gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
					(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
					(GtkAttachOptions) (0), 0, 5);
	gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
	gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
	row++;

	gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(credits_scrollwin), table);
	gtk_viewport_set_shadow_type(GTK_VIEWPORT(gtk_widget_get_parent(table)), GTK_SHADOW_NONE);
	gtk_widget_show_all(table);
	label = gtk_label_new(_("Credits"));
	gtk_widget_show(label);
	gtk_notebook_append_page(GTK_NOTEBOOK(notebook), credits_scrollwin, label);

	/* create "License" tab */
	license_scrollwin = gtk_scrolled_window_new(NULL, NULL);
	gtk_container_set_border_width(GTK_CONTAINER(license_scrollwin), 6);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(license_scrollwin),
		GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(license_scrollwin), GTK_SHADOW_IN);
	license_textview = gtk_text_view_new();
	gtk_text_view_set_left_margin(GTK_TEXT_VIEW(license_textview), 2);
	gtk_text_view_set_right_margin(GTK_TEXT_VIEW(license_textview), 2);
	gtk_text_view_set_editable(GTK_TEXT_VIEW(license_textview), FALSE);
	gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(license_textview), FALSE);
	gtk_widget_show(license_textview);
	gtk_container_add(GTK_CONTAINER(license_scrollwin), license_textview);
	label = gtk_label_new(_("License"));
	gtk_widget_show(label);

	g_snprintf(buffer, sizeof(buffer), "%s" G_DIR_SEPARATOR_S "GPL-2", app->datadir);

	g_file_get_contents(buffer, &license_text, NULL, NULL);
	if (license_text == NULL)
	{
		license_text = g_strdup(
			_("License text could not be found, please visit http://www.gnu.org/licenses/gpl-2.0.txt to view it online."));
	}
	tb = gtk_text_view_get_buffer(GTK_TEXT_VIEW(license_textview));
	gtk_text_buffer_set_text(tb, license_text, -1);

	g_free(license_text);

	gtk_notebook_append_page(GTK_NOTEBOOK(notebook), license_scrollwin, label);

	gtk_widget_show_all(dialog);
	return dialog;
}
Esempio n. 21
0
GtkWidget *
do_ddl_queries (GtkWidget *do_widget)
{  
	if (!window) {
		GtkWidget *grid;
		GtkWidget *label;
		GtkWidget *wid;
		DemoData *data;
		GtkWidget *bbox;
		GtkWidget *sw, *vp;

                data = g_new0 (DemoData, 1);

		window = gtk_dialog_new_with_buttons ("DDL queries",
						      GTK_WINDOW (do_widget),
						      0,
						      "Close", GTK_RESPONSE_NONE,
						      NULL);
		data->top_window = window;
		
		g_signal_connect (window, "response",
				  G_CALLBACK (gtk_widget_destroy), NULL);
		g_signal_connect (window, "destroy",
				  G_CALLBACK (gtk_widget_destroyed), &window);
		
		grid = gtk_grid_new ();
		gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (window))),
				    grid, TRUE, TRUE, 0);
		gtk_container_set_border_width (GTK_CONTAINER (grid), 5);
		
		label = gtk_label_new ("<b>Tested provider and operation:</b>");
		gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
		gtk_widget_set_halign (label, GTK_ALIGN_START);
		gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 2, 1);
		
		/* provider selection */
		label = gtk_label_new ("Tested provider:");
		gtk_widget_set_halign (label, GTK_ALIGN_START);
		gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1);

		wid = gdaui_provider_selector_new ();
		gdaui_provider_selector_set_provider (GDAUI_PROVIDER_SELECTOR (wid),
								  "SQLite");
		gtk_grid_attach (GTK_GRID (grid), wid, 1, 1, 1, 1);
		data->prov_sel = GDAUI_PROVIDER_SELECTOR (wid);
		g_signal_connect (G_OBJECT (data->prov_sel), "changed", 
				  G_CALLBACK (tested_provider_changed_cb), data);

		/* operation selection */
		label = gtk_label_new ("Tested operation:");
		gtk_widget_set_halign (label, GTK_ALIGN_START);
		gtk_grid_attach (GTK_GRID (grid), label, 0, 2, 1, 1);
		
		wid = gdaui_combo_new ();
		gtk_grid_attach (GTK_GRID (grid), wid, 1, 2, 1, 1);
		g_signal_connect (G_OBJECT (wid), "changed",
				  G_CALLBACK (tested_operation_changed_cb), data);
		data->op_combo = wid;

		/* container for GdauiServerOperation */
		label = gtk_label_new ("<b>GdauiServerOperation widget:</b>");
		gtk_widget_set_halign (label, GTK_ALIGN_START);
		gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
		gtk_grid_attach (GTK_GRID (grid), label, 0, 3, 2, 1);

		sw = gtk_scrolled_window_new (FALSE, 0);
		gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
						GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
		gtk_widget_set_size_request (sw, 600, 450);
		gtk_grid_attach (GTK_GRID (grid), sw, 0, 4, 2, 1);
		vp = gtk_viewport_new (NULL, NULL);
		gtk_widget_set_name (vp, "gdaui-transparent-background");
		gtk_viewport_set_shadow_type (GTK_VIEWPORT (vp), GTK_SHADOW_NONE);
		gtk_container_add (GTK_CONTAINER (sw), vp);
		data->op_container = vp;
		
		/* bottom buttons */
		bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
		gtk_grid_attach (GTK_GRID (grid), bbox, 0, 5, 2, 1);

		wid = gtk_button_new_with_label ("Show named parameters");
		data->show_button = wid;
		gtk_box_pack_start (GTK_BOX (bbox), wid, TRUE, TRUE, 0);
		g_signal_connect (G_OBJECT (wid), "clicked",
				  G_CALLBACK (show_named_parameters), data);

		wid = gtk_button_new_with_label ("Show SQL");
		data->sql_button = wid;
		gtk_box_pack_start (GTK_BOX (bbox), wid, TRUE, TRUE, 0);
		g_signal_connect (G_OBJECT (wid), "clicked",
				  G_CALLBACK (show_sql), data);

		tested_provider_changed_cb (data->prov_sel, data);
		gtk_combo_box_set_active (GTK_COMBO_BOX (data->op_combo), 1);
	}

	gboolean visible;
	g_object_get (G_OBJECT (window), "visible", &visible, NULL);
	if (!visible)
		gtk_widget_show_all (window);
	else {
		gtk_widget_destroy (window);
		window = NULL;
	}

	return window;
}
Esempio n. 22
0
int main( int argc, char *argv[])
{

  GtkWidget *window;
  GtkWidget *vbox;

  GtkWidget *toolbar;
  GtkToolItem *undo;
  GtkToolItem *redo;
  GtkToolItem *sep;
  GtkToolItem *exit;


  gtk_init(&argc, &argv);

  window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
  gtk_window_set_default_size(GTK_WINDOW(window), 250, 200);
  gtk_window_set_title(GTK_WINDOW(window), "undoredo");

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


  toolbar = gtk_toolbar_new();
  gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);

  gtk_container_set_border_width(GTK_CONTAINER(toolbar), 2);

  undo = gtk_tool_button_new_from_stock(GTK_STOCK_UNDO);
  gtk_widget_set_name(GTK_WIDGET(undo), "undo");
  gtk_toolbar_insert(GTK_TOOLBAR(toolbar), undo, -1);

  redo = gtk_tool_button_new_from_stock(GTK_STOCK_REDO);
  gtk_toolbar_insert(GTK_TOOLBAR(toolbar), redo, -1);

  sep = gtk_separator_tool_item_new();
  gtk_toolbar_insert(GTK_TOOLBAR(toolbar), sep, -1); 

  exit = gtk_tool_button_new_from_stock(GTK_STOCK_QUIT);
  gtk_toolbar_insert(GTK_TOOLBAR(toolbar), exit, -1);

  gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 5);


  g_signal_connect(G_OBJECT(undo), "clicked", 
        G_CALLBACK(undo_redo), redo);

  g_signal_connect(G_OBJECT(redo), "clicked", 
        G_CALLBACK(undo_redo), undo);

  g_signal_connect(G_OBJECT(exit), "clicked", 
        G_CALLBACK(gtk_main_quit), NULL);

  g_signal_connect_swapped(G_OBJECT(window), "destroy",
        G_CALLBACK(gtk_main_quit), NULL);

  gtk_widget_show_all(window);

  gtk_main();

  return 0;
}
Esempio n. 23
0
int
main (int argc, char *argv[])
{
  GtkWidget *window;  //Declare une fentre GTK
  GtkWidget *drawing_area; //Declare une zone de dessi
  GtkWidget *vbox;  //Declare un une boite 

  GtkWidget *button; //Declarre un bouton

  gtk_init (&argc, &argv); //Initialise GTK

  window = gtk_window_new (GTK_WINDOW_TOPLEVEL); //Creer uen fenetre GTK 
  gtk_widget_set_name (window, "Un petit programme GTK pour dessiner");

  vbox = gtk_vbox_new (FALSE, 0); //Crer une nouvelle boite
  gtk_container_add (GTK_CONTAINER (window), vbox); //Rajoute la boite a la fenetre
  gtk_widget_show (vbox);  //Affiche la boite

  gtk_signal_connect (GTK_OBJECT (window), "destroy",
                      GTK_SIGNAL_FUNC (quit), NULL);

  /* Create the drawing area */

  drawing_area = gtk_drawing_area_new (); //Crer une zone de dessins
  gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 200, 200); //Initialise la zone de dessins
  gtk_box_pack_start (GTK_BOX (vbox), drawing_area, TRUE, TRUE, 0); //Ajoute la zone de dessin a la boute

  gtk_widget_show (drawing_area); //Affiche la zone de dessin

  
  //Les differents signaux a connecteer
  gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
                      (GtkSignalFunc) expose_event, NULL);
  gtk_signal_connect (GTK_OBJECT(drawing_area),"configure_event",
                      (GtkSignalFunc) configure_event, NULL);

  gtk_signal_connect (GTK_OBJECT (drawing_area), "motion_notify_event",
                      (GtkSignalFunc) motion_notify_event, NULL);
  gtk_signal_connect (GTK_OBJECT (drawing_area), "button_press_event",
                      (GtkSignalFunc) button_press_event, NULL);

  gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK
                         | GDK_LEAVE_NOTIFY_MASK
                         | GDK_BUTTON_PRESS_MASK
                         | GDK_POINTER_MOTION_MASK
                         | GDK_POINTER_MOTION_HINT_MASK);

  button = gtk_button_new_with_label ("Quitter"); //Creer un bouton avec le label Quitter
  gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); //Initialise le bouton et l'ajoute a la boite

  //Ajoute le signal
  gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
                             GTK_SIGNAL_FUNC (gtk_widget_destroy),
                             GTK_OBJECT (window));
  gtk_widget_show (button); //Affiche le bouton

  gtk_widget_show (window); //Affiche la fenetre

  gtk_main (); //Rend la main a l'application

  return 0;
}
Esempio n. 24
0
static void
gedit_view_frame_init (GeditViewFrame *frame)
{
	GeditDocument *doc;
	GtkWidget *sw;
	GdkRGBA transparent = {0, 0, 0, 0};

	frame->priv = GEDIT_VIEW_FRAME_GET_PRIVATE (frame);

	frame->priv->typeselect_flush_timeout = 0;
	frame->priv->wrap_around = TRUE;

	gtk_orientable_set_orientation (GTK_ORIENTABLE (frame),
	                                GTK_ORIENTATION_VERTICAL);

	doc = gedit_document_new ();

	_gedit_document_set_mount_operation_factory (doc,
						     view_frame_mount_operation_factory,
						     frame);

	frame->priv->view = gedit_view_new (doc);
	gtk_widget_set_vexpand (frame->priv->view, TRUE);
	gtk_widget_show (frame->priv->view);

	g_object_unref (doc);

	/* Create the scrolled window */
	sw = gtk_scrolled_window_new (NULL, NULL);

	gtk_container_add (GTK_CONTAINER (sw), frame->priv->view);

	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
					GTK_POLICY_AUTOMATIC,
					GTK_POLICY_AUTOMATIC);

	gtk_widget_show (sw);

	frame->priv->overlay = gedit_animated_overlay_new ();
	gtk_container_add (GTK_CONTAINER (frame->priv->overlay), sw);
	gtk_widget_override_background_color (frame->priv->overlay, 0, &transparent);
	gtk_widget_show (frame->priv->overlay);

	gtk_box_pack_start (GTK_BOX (frame), frame->priv->overlay, TRUE, TRUE, 0);

	/* Add slider */
	frame->priv->slider = gedit_floating_slider_new ();
	gtk_widget_set_name (frame->priv->slider, "search-slider");
	gtk_widget_set_halign (frame->priv->slider, GTK_ALIGN_END);
	gtk_widget_set_valign (frame->priv->slider, GTK_ALIGN_START);

	if (gtk_widget_get_direction (frame->priv->slider) == GTK_TEXT_DIR_LTR)
	{
		gtk_widget_set_margin_right (frame->priv->slider, SEARCH_POPUP_MARGIN);
	}
	else
	{
		gtk_widget_set_margin_left (frame->priv->slider, SEARCH_POPUP_MARGIN);
	}

	g_object_set (G_OBJECT (frame->priv->slider),
	              "easing", GEDIT_THEATRICS_CHOREOGRAPHER_EASING_EXPONENTIAL_IN_OUT,
	              "blocking", GEDIT_THEATRICS_CHOREOGRAPHER_BLOCKING_DOWNSTAGE,
	              "orientation", GTK_ORIENTATION_VERTICAL,
	              NULL);

	gedit_animated_overlay_add_animated_overlay (GEDIT_ANIMATED_OVERLAY (frame->priv->overlay),
	                                             GEDIT_ANIMATABLE (frame->priv->slider));
}
Esempio n. 25
0
gboolean show_desktop_applet_fill(MatePanelApplet* applet)
{
	ShowDesktopData* sdd;
	GtkActionGroup* action_group;
	AtkObject* atk_obj;
	GtkCssProvider *provider;

	mate_panel_applet_set_flags(applet, MATE_PANEL_APPLET_EXPAND_MINOR);

	sdd = g_new0(ShowDesktopData, 1);

	sdd->applet = GTK_WIDGET(applet);

	sdd->image = gtk_image_new();

	switch (mate_panel_applet_get_orient(applet))
	{
		case MATE_PANEL_APPLET_ORIENT_LEFT:
		case MATE_PANEL_APPLET_ORIENT_RIGHT:
			sdd->orient = GTK_ORIENTATION_VERTICAL;
			break;
		case MATE_PANEL_APPLET_ORIENT_UP:
		case MATE_PANEL_APPLET_ORIENT_DOWN:
		default:
			sdd->orient = GTK_ORIENTATION_HORIZONTAL;
			break;
	}

	sdd->size = mate_panel_applet_get_size(MATE_PANEL_APPLET(sdd->applet));

	g_signal_connect(G_OBJECT(sdd->applet), "realize", G_CALLBACK(show_desktop_applet_realized), sdd);

	sdd->button = gtk_toggle_button_new ();

	gtk_widget_set_name (sdd->button, "showdesktop-button");
    provider = gtk_css_provider_new ();
	gtk_css_provider_load_from_data (provider,
					 "#showdesktop-button {\n"
                     "border-width: 0px; \n" /*a border here causes GTK warnings */
					 " padding: 0px;\n"
					 " margin: 0px; }",
					 -1, NULL);

	gtk_style_context_add_provider (gtk_widget_get_style_context (sdd->button),
					GTK_STYLE_PROVIDER (provider),
					GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
					g_object_unref (provider);

	atk_obj = gtk_widget_get_accessible(sdd->button);
	atk_object_set_name (atk_obj, _("Show Desktop Button"));
	g_signal_connect(G_OBJECT(sdd->button), "button_press_event", G_CALLBACK(do_not_eat_button_press), NULL);

	g_signal_connect(G_OBJECT(sdd->button), "toggled", G_CALLBACK(button_toggled_callback), sdd);

	gtk_container_set_border_width(GTK_CONTAINER(sdd->button), 0);
	gtk_container_add(GTK_CONTAINER(sdd->button), sdd->image);
	gtk_container_add(GTK_CONTAINER(sdd->applet), sdd->button);

	g_signal_connect (G_OBJECT(sdd->button), "size_allocate", G_CALLBACK(button_size_allocated), sdd);

	/* FIXME: Update this comment. */
	/* we have to bind change_orient before we do applet_widget_add
	   since we need to get an initial change_orient signal to set our
	   initial oriantation, and we get that during the _add call */
	g_signal_connect(G_OBJECT (sdd->applet), "change_orient", G_CALLBACK (applet_change_orient), sdd);

	mate_panel_applet_set_background_widget(MATE_PANEL_APPLET (sdd->applet), GTK_WIDGET(sdd->applet));

	action_group = gtk_action_group_new("ShowDesktop Applet Actions");
	gtk_action_group_set_translation_domain(action_group, GETTEXT_PACKAGE);
	gtk_action_group_add_actions(action_group, show_desktop_menu_actions, G_N_ELEMENTS (show_desktop_menu_actions), sdd);
	mate_panel_applet_setup_menu_from_resource (MATE_PANEL_APPLET (sdd->applet),
	                                            WNCKLET_RESOURCE_PATH "showdesktop-menu.xml",
	                                            action_group);
	g_object_unref(action_group);

	g_signal_connect(G_OBJECT(sdd->applet), "destroy", G_CALLBACK(applet_destroyed), sdd);

	gtk_drag_dest_set(GTK_WIDGET(sdd->button), 0, NULL, 0, 0);

	g_signal_connect(G_OBJECT(sdd->button), "drag_motion", G_CALLBACK (button_drag_motion), sdd);
	g_signal_connect(G_OBJECT(sdd->button), "drag_leave", G_CALLBACK (button_drag_leave), sdd);

	gtk_widget_show_all(sdd->applet);

	return TRUE;
}
Esempio n. 26
0
// widget hierarchy
// |--background
//    |--alignment
//       |--vbox
//          |--label_timezone_prompt
//          |--label_possible_date[0]
//          |--hbox
//             |--button
//             |--button
//             |--button
//             |--button
//             |--button
//          ...
//          |--label_possible_date[1]
//          |--hbox
//             |--button
//             |--button
//             |--button
//             |--button
//             |--button
//          ...
GtkWidget *create_timezone_selection(void)
{
    GtkWidget* background;
    GtkWidget* alignment;
    GtkWidget* vbox;
    GtkWidget* label;
    GtkWidget* button;

    // background
    background = gtk_event_box_new();
    gtk_widget_set_name(background, "timezone_selection_background");
    gtk_widget_set_size_request(background, TITLE_MIN_WIDTH, TIMEZONE_SELECTION_HEIGHT);

    // alignment
    alignment = gtk_alignment_new(0, 0, 0, 0);
    gtk_alignment_set_padding(GTK_ALIGNMENT(alignment),
                              DATETIME_SCREEN_ITEM_PADDING_TOP,
                              DATETIME_SCREEN_ITEM_PADDING_BOTTOM,
                              DATETIME_SCREEN_ITEM_PADDING_LEFT,
                              DATETIME_SCREEN_ITEM_PADDING_RIGHT);
    gtk_container_add(GTK_CONTAINER(background), alignment);

    // vbox
    vbox = gtk_vbox_new(FALSE, DATETIME_SCREEN_ITEM_SPACING);
    gtk_container_add(GTK_CONTAINER(alignment), vbox);
    
    label = gtk_label_new("");
    gtk_widget_set_name(label, "datetime_screen_info_text");
    gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
    gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
    g_datetime_screen->label_timezone_prompt = label;

    g_utc_time = time(NULL);
    
    // divide the buttons into 2 parts, determine the boundary first
    int i;
    for (i=0; i<TOTAL_TIMEZONES; i++)
    {
        if ((g_utc_time+timezones[i].tzoffset) / 86400 > (g_utc_time+timezones[0].tzoffset) / 86400)
        {
            g_date_boundary = i;
            break;
        }
    }
    
    // draw the first possible date label
    label = gtk_label_new("");
    gtk_widget_set_name(label, "datetime_date_heading_text");
    gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
    gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
    g_datetime_screen->label_possible_date[0] = label;

    // draw the rest part
    int minutes_in_tz;
    char button_text[8];
    GtkWidget* hbox = NULL;
    for (i=0; i<TOTAL_TIMEZONES; i++)
    {
        if (i == g_date_boundary)
        {
            // draw the second possible date label
            label = gtk_label_new("");
            gtk_widget_set_name(label, "datetime_date_heading_text");
            gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
            gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
            g_datetime_screen->label_possible_date[1] = label;
        }
        
        if ((i<g_date_boundary && i%5 == 0) ||
            (i>=g_date_boundary && (i-g_date_boundary)%5 == 0))
        {
            // we should create a new hbox, for we have a new line of buttons
            hbox = gtk_hbox_new(FALSE, TIMEZONE_BUTTON_ITEM_SPACING);
            gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(hbox), FALSE, FALSE, 0);
        }
        
        minutes_in_tz = ((g_utc_time + timezones[i].tzoffset) % 86400) / 60;
        sprintf(button_text, "%02d:%02d", minutes_in_tz / 60, minutes_in_tz % 60);

        button = ergtk_toggle_button_new_with_label(button_text);
        gtk_widget_set_size_request(GTK_WIDGET(button), TZ_BUTTON_WIDTH, TZ_BUTTON_HEIGHT);
        gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(button), FALSE, FALSE, 0);
        g_datetime_screen->button_timezones[i] = GTK_TOGGLE_BUTTON(button);
    }

    g_datetime_screen->button_timezones[TOTAL_TIMEZONES] = NULL;

    gtk_widget_show_all(background);
    return background;
}
Esempio n. 27
0
int
main (int argc, char *argv[])
{
	signal_user_data_t *ud;
	GValue *preset;
	GError *error = NULL;
	GOptionContext *context;

#ifdef ENABLE_NLS
	bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
	bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
	textdomain (GETTEXT_PACKAGE);
#endif

	if (!g_thread_supported())
		g_thread_init(NULL);
	context = g_option_context_new ("- Rip and encode DVD or MPEG file");
	g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
	g_option_context_add_group (context, gtk_get_option_group (TRUE));
#if !defined(_WIN32)
	g_option_context_add_group (context, gst_init_get_option_group ());
#endif
	g_option_context_parse (context, &argc, &argv, &error);
	g_option_context_free(context);

	if (argc > 1 && dvd_device == NULL && argv[1][0] != '-')
	{
		dvd_device = argv[1];
	}
	
	gtk_set_locale ();
	gtk_init (&argc, &argv);
	gtk_rc_parse_string(hud_rcstyle);
	g_type_class_unref(g_type_class_ref(GTK_TYPE_BUTTON));
	g_object_set(gtk_settings_get_default(), "gtk-button-images", TRUE, NULL);
#if !defined(_WIN32)
	notify_init("HandBrake");
#endif
	ghb_register_transforms();
	ghb_resource_init();
	ghb_load_icons();

#if !defined(_WIN32)
	dbus_g_thread_init();
#endif
	ghb_udev_init();

	ghb_write_pid_file();
	ud = g_malloc0(sizeof(signal_user_data_t));
	ud->debug = ghb_debug;
	g_log_set_handler (NULL, G_LOG_LEVEL_DEBUG, debug_log_handler, ud);
	g_log_set_handler ("Gtk", G_LOG_LEVEL_WARNING, warn_log_handler, ud);
	//g_log_set_handler ("Gtk", G_LOG_LEVEL_CRITICAL, warn_log_handler, ud);
	ud->settings = ghb_settings_new();
	ud->builder = create_builder_or_die (BUILDER_NAME);
	// Enable events that alert us to media change events
	watch_volumes (ud);

	//GtkWidget *widget = GHB_WIDGET(ud->builder, "PictureDetelecineCustom");
	//gtk_entry_set_inner_border(widget, 2);

	// Since GtkBuilder no longer assigns object ids to widget names
	// Assign a few that are necessary for style overrides to work
	GtkWidget *widget;
#if defined(_NO_UPDATE_CHECK)
	widget = GHB_WIDGET(ud->builder, "check_updates_box");
	gtk_widget_hide(widget);
#endif

	widget = GHB_WIDGET(ud->builder, "preview_hud");
	gtk_widget_set_name(widget, "preview_hud");
	widget = GHB_WIDGET(ud->builder, "preview_window");
	gtk_widget_set_name(widget, "preview_window");

	// Set up the "hud" control overlay for the preview window
	GtkWidget *draw, *hud, *blender, *align;

	align = GHB_WIDGET(ud->builder, "preview_window_alignment");
	draw = GHB_WIDGET(ud->builder, "preview_image_align");
	hud = GHB_WIDGET(ud->builder, "preview_hud");

	// Set up compositing for hud
	blender = ghb_compositor_new();

	gtk_container_add(GTK_CONTAINER(align), blender);
	ghb_compositor_zlist_insert(GHB_COMPOSITOR(blender), draw, 1, 1);
	ghb_compositor_zlist_insert(GHB_COMPOSITOR(blender), hud, 2, .85);
	gtk_widget_show(blender);

	// Redirect stderr to the activity window
	ghb_preview_init(ud);
	IoRedirect(ud);
	ghb_log( "%s - %s - %s",
		HB_PROJECT_TITLE, HB_PROJECT_BUILD_TITLE, HB_PROJECT_URL_WEBSITE );
	ghb_init_dep_map();

	// Need to connect x264_options textview buffer to the changed signal
	// since it can't be done automatically
	GtkTextView *textview;
	GtkTextBuffer *buffer;
	textview = GTK_TEXT_VIEW(GHB_WIDGET (ud->builder, "x264Option"));
	buffer = gtk_text_view_get_buffer (textview);
	g_signal_connect(buffer, "changed", (GCallback)x264_entry_changed_cb, ud);

	ghb_combo_init(ud);

	g_debug("ud %p\n", ud);
	g_debug("ud->builder %p\n", ud->builder);

	bind_audio_tree_model(ud);
	bind_subtitle_tree_model(ud);
	bind_presets_tree_model(ud);
	bind_queue_tree_model(ud);
	bind_chapter_tree_model(ud);
	// Connect up the signals to their callbacks
	// I wrote my own connector so that I could pass user data
	// to the callbacks.  Builder's standard autoconnect doesn't all this.
	gtk_builder_connect_signals_full (ud->builder, MyConnect, ud);

	// Load all internal settings
	ghb_settings_init(ud);
	// Load the presets files
	ghb_presets_load(ud);
	ghb_prefs_load(ud);

	ghb_prefs_to_ui(ud);

	gint logLevel;
	logLevel = ghb_settings_get_int(ud->settings, "LoggingLevel");
	ghb_backend_init(logLevel);

	if (ghb_settings_get_boolean(ud->settings, "hbfd"))
	{
		ghb_hbfd(ud, TRUE);
	}
	gchar *source = ghb_settings_get_string(ud->settings, "default_source");
	ghb_dvd_set_current(source, ud);
	g_free(source);

	// Parsing x264 options "" initializes x264 widgets to proper defaults
	ghb_x264_parse_options(ud, "");

	// Populate the presets tree view
	ghb_presets_list_init(ud, NULL, 0);
	// Get the first preset name
	if (arg_preset != NULL)
	{
		preset = ghb_parse_preset_path(arg_preset);
		if (preset)
		{
			ghb_select_preset(ud->builder, preset);
			ghb_value_free(preset);
		}
	}
	else
	{
		ghb_select_default_preset(ud->builder);
	}

	// Grey out widgets that are dependent on a disabled feature
	ghb_check_all_depencencies (ud);

	if (dvd_device != NULL)
	{
		// Source overridden from command line option
		ghb_settings_set_string(ud->settings, "scan_source", dvd_device);
		g_idle_add((GSourceFunc)ghb_idle_scan, ud);
	}
	// Reload and check status of the last saved queue
	g_idle_add((GSourceFunc)ghb_reload_queue, ud);

	// Start timer for monitoring libhb status, 500ms
	g_timeout_add (500, ghb_timer_cb, (gpointer)ud);

	// Add dvd devices to File menu
	ghb_volname_cache_init();
	g_thread_create((GThreadFunc)ghb_cache_volnames, ud, FALSE, NULL);

	GtkStatusIcon *si;
	si = GTK_STATUS_ICON(GHB_OBJECT(ud->builder, "hb_status"));

	gtk_status_icon_set_visible(si,
			ghb_settings_get_boolean(ud->settings, "show_status"));

#if GTK_CHECK_VERSION(2, 16, 0)
	gtk_status_icon_set_has_tooltip(si, TRUE);
	g_signal_connect(si, "query-tooltip", 
					status_icon_query_tooltip_cb, ud);
#else
	gtk_status_icon_set_tooltip(si, "HandBrake");
#endif

	// Ugly hack to keep subtitle table from bouncing around as I change
	// which set of controls are visible
	GtkRequisition req;
	gint height;
	
	widget = GHB_WIDGET(ud->builder, "SrtCodeset");
	gtk_widget_size_request( widget, &req );
	height = req.height;
	widget = GHB_WIDGET(ud->builder, "srt_code_label");
	gtk_widget_size_request( widget, &req );
	height += req.height;
	widget = GHB_WIDGET(ud->builder, "subtitle_table");
	gtk_widget_set_size_request(widget, -1, height);
	
	// Everything should be go-to-go.  Lets rock!

	gtk_main ();
	gtk_status_icon_set_visible(si, FALSE);
	ghb_backend_close();
	if (ud->queue)
		ghb_value_free(ud->queue);
	ghb_value_free(ud->settings);
	g_io_channel_unref(ud->activity_log);
	ghb_settings_close();
#if !defined(_WIN32)
	notify_uninit();
#endif
	g_free(ud);

	return 0;
}
Esempio n. 28
0
/**
 * query_console_page_new
 *
 * Returns: a new #GtkWidget
 */
GtkWidget *
query_console_page_new (TConnection *tcnc)
{
	QueryConsolePage *tconsole;

	g_return_val_if_fail (T_IS_CONNECTION (tcnc), NULL);

	tconsole = QUERY_CONSOLE_PAGE (g_object_new (QUERY_CONSOLE_PAGE_TYPE, NULL));

	tconsole->priv->tcnc = g_object_ref (tcnc);
	
	/* header */
        GtkWidget *label;
	gchar *str;
	str = g_strdup_printf ("<b>%s</b>", _("Query editor"));
	label = gdaui_bar_new (str);
	g_free (str);
        gtk_box_pack_start (GTK_BOX (tconsole), label, FALSE, FALSE, 0);
        gtk_widget_show (label);
	tconsole->priv->header = GDAUI_BAR (label);

	/* main contents */
	GtkWidget *vpaned;
	vpaned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
	tconsole->priv->vpaned = NULL;
	gtk_box_pack_start (GTK_BOX (tconsole), vpaned, TRUE, TRUE, 6);	

	/* top paned for the editor */
	GtkWidget *wid, *vbox, *hbox, *bbox, *hpaned, *button;

	hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
	gtk_paned_pack1 (GTK_PANED (vpaned), hbox, TRUE, FALSE);

	hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
	gtk_box_pack_start (GTK_BOX (hbox), hpaned, TRUE, TRUE, 0);

	vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
	gtk_paned_pack1 (GTK_PANED (hpaned), vbox, TRUE, FALSE);

	wid = gtk_label_new ("");
	str = g_strdup_printf ("<b>%s</b>", _("SQL code to execute:"));
	gtk_label_set_markup (GTK_LABEL (wid), str);
	g_free (str);
	gtk_widget_set_halign (wid, GTK_ALIGN_START);
	gtk_widget_set_tooltip_markup (wid, QUERY_EDITOR_TOOLTIP);
	gtk_box_pack_start (GTK_BOX (vbox), wid, FALSE, FALSE, 0);

	wid = query_editor_new ();
	tconsole->priv->editor = QUERY_EDITOR (wid);
	gtk_box_pack_start (GTK_BOX (vbox), wid, TRUE, TRUE, 0);
	g_signal_connect (wid, "changed",
			  G_CALLBACK (editor_changed_cb), tconsole);
	g_signal_connect (wid, "execute-request",
			  G_CALLBACK (editor_execute_request_cb), tconsole);
	
	vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
	tconsole->priv->params_top = vbox;
	gtk_paned_pack2 (GTK_PANED (hpaned), vbox, FALSE, FALSE);
	
	wid = gtk_label_new ("");
	str = g_strdup_printf ("<b>%s</b>", _("Variables' values:"));
	gtk_label_set_markup (GTK_LABEL (wid), str);
	g_free (str);
	gtk_widget_set_halign (wid, GTK_ALIGN_START);
	gtk_box_pack_start (GTK_BOX (vbox), wid, FALSE, FALSE, 0);
	
	GtkWidget *sw;
	sw = gtk_scrolled_window_new (NULL, NULL);
	gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_NONE);
	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
					GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	tconsole->priv->params_form_box = gtk_viewport_new (NULL, NULL);
	gtk_widget_set_name (tconsole->priv->params_form_box, "gdaui-transparent-background");
	gtk_viewport_set_shadow_type (GTK_VIEWPORT (tconsole->priv->params_form_box), GTK_SHADOW_NONE);
	gtk_container_add (GTK_CONTAINER (sw), tconsole->priv->params_form_box);
	gtk_box_pack_start (GTK_BOX (vbox), sw, TRUE, TRUE, 0);
	gtk_widget_set_size_request (tconsole->priv->params_form_box, 250, -1);

	wid = gtk_label_new ("");
	gtk_label_set_markup (GTK_LABEL (wid), VARIABLES_HELP);
	gtk_widget_set_halign (wid, GTK_ALIGN_START);
	gtk_container_add (GTK_CONTAINER (tconsole->priv->params_form_box), wid);
	tconsole->priv->params_form = wid;
	
	bbox = gtk_button_box_new (GTK_ORIENTATION_VERTICAL);
	gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_END);
	gtk_box_pack_start (GTK_BOX (hbox), bbox, FALSE, FALSE, 5);

	button = ui_make_small_button (FALSE, FALSE, _("Clear"),
				       "_Clear", _("Clear the editor's\ncontents"));
	gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
	g_signal_connect (button, "clicked",
			  G_CALLBACK (sql_clear_clicked_cb), tconsole);

	button = ui_make_small_button (TRUE, FALSE, _("Variables"),
				       NULL, _("Show variables needed\nto execute SQL"));
	gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
	tconsole->priv->params_toggle = GTK_TOGGLE_BUTTON (button);
	g_signal_connect (button, "toggled",
			  G_CALLBACK (sql_variables_clicked_cb), tconsole);

	button = ui_make_small_button (FALSE, FALSE, _("Execute"),
				       "_Execute", _("Execute SQL in editor"));
	tconsole->priv->exec_button = button;
	gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
	g_signal_connect (button, "clicked",
			  G_CALLBACK (sql_execute_clicked_cb), tconsole);
	
	button = ui_make_small_button (FALSE, FALSE, _("Indent"),
				       NULL, _("Indent SQL in editor\n"
					       "and make the code more readable\n"
					       "(removes comments)"));
	tconsole->priv->indent_button = button;
	gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
	g_signal_connect (button, "clicked",
			  G_CALLBACK (sql_indent_clicked_cb), tconsole);

	button = ui_make_small_button (FALSE, TRUE, _("Favorite"),
				       NULL, _("Add SQL to favorite"));
	gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
	g_signal_connect (button, "clicked",
			  G_CALLBACK (sql_favorite_clicked_cb), tconsole);

	/* bottom paned for the results and history */
	hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
	gtk_paned_pack2 (GTK_PANED (vpaned), hpaned, TRUE, FALSE);

	/* bottom left */
	vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
	gtk_paned_pack1 (GTK_PANED (hpaned), vbox, FALSE, FALSE);

	wid = gtk_label_new ("");
	str = g_strdup_printf ("<b>%s</b>", _("Execution history:"));
	gtk_label_set_markup (GTK_LABEL (wid), str);
	g_free (str);
	gtk_widget_set_halign (wid, GTK_ALIGN_START);
	gtk_box_pack_start (GTK_BOX (vbox), wid, FALSE, FALSE, 0);

	wid = query_editor_new ();
	tconsole->priv->history = QUERY_EDITOR (wid);
	query_editor_set_mode (tconsole->priv->history, QUERY_EDITOR_HISTORY);
	gtk_widget_set_size_request (wid, 200, -1);
	gtk_box_pack_start (GTK_BOX (vbox), wid, TRUE, TRUE, 6);
	g_signal_connect (wid, "changed",
			  G_CALLBACK (history_changed_cb), tconsole);

	bbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
	gtk_box_pack_start (GTK_BOX (vbox), bbox, FALSE, FALSE, 0);
	gtk_button_box_set_layout (GTK_BUTTON_BOX (bbox), GTK_BUTTONBOX_END);

	button = ui_make_small_button (FALSE, FALSE, _("Copy"),
				       "_Copy", _("Copy selected history\nto editor"));
	gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
	g_signal_connect (button, "clicked",
			  G_CALLBACK (history_copy_clicked_cb), tconsole);
	tconsole->priv->history_copy_button = button;
	gtk_widget_set_sensitive (button, FALSE);

	button = ui_make_small_button (FALSE, FALSE, _("Clear"),
				       "_Clear", _("Clear history"));
	gtk_box_pack_start (GTK_BOX (bbox), button, FALSE, FALSE, 0);
	g_signal_connect (button, "clicked",
			  G_CALLBACK (history_clear_clicked_cb), tconsole);
	tconsole->priv->history_del_button = button;
	gtk_widget_set_sensitive (button, FALSE);

	/* bottom right */
	vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8);
	gtk_paned_pack2 (GTK_PANED (hpaned), vbox, TRUE, FALSE);
	
	wid = gtk_label_new ("");
	str = g_strdup_printf ("<b>%s</b>", _("Execution Results:"));
	gtk_label_set_markup (GTK_LABEL (wid), str);
	g_free (str);
	gtk_widget_set_halign (wid, GTK_ALIGN_START);
	gtk_box_pack_start (GTK_BOX (vbox), wid, FALSE, FALSE, 0);

	wid = query_result_new (tconsole->priv->history);
	tconsole->priv->query_result = wid;
	gtk_box_pack_start (GTK_BOX (vbox), wid, TRUE, TRUE, 0);
	g_signal_connect (wid, "rerun-requested",
			  G_CALLBACK (rerun_requested_cb), tconsole);

	/* show everything */
        gtk_widget_show_all (vpaned);
	gtk_widget_hide (tconsole->priv->params_top);

	/* busy connection handling */
	connection_status_changed_cb (tconsole->priv->tcnc,
				      gda_connection_get_status (t_connection_get_cnc (tconsole->priv->tcnc)),
				      tconsole);

	g_signal_connect (tconsole->priv->tcnc, "status-changed",
			  G_CALLBACK (connection_status_changed_cb), tconsole);

	return (GtkWidget*) tconsole;
}
Esempio n. 29
0
/*
static void cb_scroll_event(GtkAdjustment *adj, GtkWidget *view)
{
	gtk_text_view_place_cursor_onscreen(GTK_TEXT_VIEW(view));
}
*/
MainWin *create_main_window(void)
{
	GtkWidget *window;
	GtkWidget *vbox;
 	GtkWidget *menubar;
 	GtkWidget *sw;
 	GtkWidget *view;
// 	gint size;
//	GtkAdjustment *hadj, *vadj;
	
	MainWin *mw = g_malloc(sizeof(MainWin));
	
	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
//	gtk_window_set_title(GTK_WINDOW(window), PACKAGE_NAME);
	gtk_widget_set_name(window, PACKAGE_NAME);
	
/*
#if GTK_CHECK_VERSION(2, 4, 0)
//	size = gtk_icon_size_lookup(GTK_ICON_SIZE_LARGE_TOOLBAR, &size, NULL);
	icon = gtk_icon_theme_load_icon(
		gtk_icon_theme_get_default(),
		PACKAGE,
		16, // size
		0,  // flags
		NULL);
	gtk_window_set_default_icon(icon);
*/
#if GTK_CHECK_VERSION(2, 6, 0)
	gtk_window_set_default_icon_name(PACKAGE);
#else
 	GdkPixbuf *icon = gdk_pixbuf_new_from_file(
		ICONDIR G_DIR_SEPARATOR_S PACKAGE ".png", NULL);
	gtk_window_set_icon(GTK_WINDOW(window), icon);
	if (icon)
		g_object_unref(icon);
#endif
	
	g_signal_connect(G_OBJECT(window), "delete-event",
		G_CALLBACK(on_file_quit), NULL);
	g_signal_connect_after(G_OBJECT(window), "delete-event",
		G_CALLBACK(gtk_widget_hide_on_delete), NULL);
	
	vbox = gtk_vbox_new(FALSE, 0);
	gtk_container_add(GTK_CONTAINER(window), vbox);
	
	menubar = create_menu_bar(window);
	gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
	
	sw = gtk_scrolled_window_new(NULL, NULL);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
		GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
	gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw),
		GTK_SHADOW_IN);
	gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0);
	
	view = create_text_view();
	gtk_container_add(GTK_CONTAINER(sw), view);
/*	
	hadj = gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(sw));
	vadj = gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(sw));
	g_signal_connect_after(G_OBJECT(hadj), "value-changed",
		G_CALLBACK(cb_scroll_event), view);
	g_signal_connect_after(G_OBJECT(vadj), "value-changed",
		G_CALLBACK(cb_scroll_event), view);
*/		
	mw->window = window;
	mw->menubar = menubar;
	mw->view = view;
	mw->buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view));
	
	return mw;
}
Esempio n. 30
0
static void
create_children (GNCDateEdit *gde)
{
    GtkWidget *frame;
    GtkWidget *hbox;
    GtkWidget *arrow;
    GtkTreeStore *store;
    GtkCellRenderer *cell;

    /* Create the text entry area. */
    gde->date_entry  = gtk_entry_new ();
    gtk_entry_set_width_chars (GTK_ENTRY (gde->date_entry), 11);
    gtk_box_pack_start (GTK_BOX (gde), gde->date_entry, TRUE, TRUE, 0);
    gtk_widget_show (GTK_WIDGET(gde->date_entry));
    g_signal_connect (G_OBJECT (gde->date_entry), "key-press-event",
                      G_CALLBACK (key_press_entry), gde);
    g_signal_connect (G_OBJECT (gde->date_entry), "focus-out-event",
                      G_CALLBACK (date_focus_out_event), gde);

    /* Create the popup button. */
    gde->date_button = gtk_toggle_button_new ();
    g_signal_connect (gde->date_button, "button-press-event",
                      G_CALLBACK(gnc_date_edit_button_pressed), gde);
    g_signal_connect (G_OBJECT (gde->date_button), "toggled",
                      G_CALLBACK (gnc_date_edit_button_toggled), gde);
    gtk_box_pack_start (GTK_BOX (gde), gde->date_button, FALSE, FALSE, 0);

    hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 3);
    gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE);
    gtk_container_add (GTK_CONTAINER (gde->date_button), hbox);
    gtk_widget_show (GTK_WIDGET(hbox));

    /* Calendar label, only shown if the date editor has a time field */
    gde->cal_label = gtk_label_new (_("Calendar"));
    gnc_label_set_alignment (gde->cal_label, 0.0, 0.5);
    gtk_box_pack_start (GTK_BOX (hbox), gde->cal_label, TRUE, TRUE, 0);
    if (gde->flags & GNC_DATE_EDIT_SHOW_TIME)
        gtk_widget_show (GTK_WIDGET(gde->cal_label));

    /* Graphic for the popup button. */
    arrow = gtk_image_new_from_icon_name ("go-down", GTK_ICON_SIZE_BUTTON);

    g_signal_connect (G_OBJECT (arrow), "draw",
                      G_CALLBACK (gnc_draw_arrow_cb), GINT_TO_POINTER(1));

    gtk_box_pack_start (GTK_BOX (hbox), arrow, TRUE, FALSE, 0);
    gtk_widget_show (GTK_WIDGET(arrow));

    gtk_widget_show (GTK_WIDGET(gde->date_button));

    /* Time entry controls. */
    gde->time_entry = gtk_entry_new ();
    gtk_entry_set_max_length (GTK_ENTRY(gde->time_entry), 12);
    gtk_widget_set_size_request (GTK_WIDGET(gde->time_entry), 88, -1);
    gtk_box_pack_start (GTK_BOX (gde), gde->time_entry, TRUE, TRUE, 0);

    store = gtk_tree_store_new(1, G_TYPE_STRING);
    gde->time_combo = GTK_WIDGET(gtk_combo_box_new_with_model(GTK_TREE_MODEL(store)));
    g_object_unref(store);
    /* Create cell renderer. */
    cell = gtk_cell_renderer_text_new();
    /* Pack it to the combo box. */
    gtk_cell_layout_pack_start( GTK_CELL_LAYOUT( gde->time_combo ), cell, TRUE );
    /* Connect renderer to data source */
    gtk_cell_layout_set_attributes( GTK_CELL_LAYOUT( gde->time_combo ), cell, "text", 0, NULL );

    g_signal_connect (G_OBJECT (gde->time_combo), "changed",
                      G_CALLBACK  (set_time), gde);

    gtk_box_pack_start (GTK_BOX (gde), gde->time_combo, FALSE, FALSE, 0);

    /* We do not create the popup menu with the hour range until we are
     * realized, so that it uses the values that the user might supply in a
     * future call to gnc_date_edit_set_popup_range
     */
    g_signal_connect (G_OBJECT (gde), "realize",
                      G_CALLBACK  (fill_time_combo), gde);

    if (gde->flags & GNC_DATE_EDIT_SHOW_TIME)
    {
        gtk_widget_show (GTK_WIDGET(gde->time_entry));
        gtk_widget_show (GTK_WIDGET(gde->time_combo));
    }

    gde->cal_popup = gtk_window_new (GTK_WINDOW_POPUP);
    gtk_widget_set_name (gde->cal_popup, "gnc-date-edit-popup-window");

    gtk_window_set_type_hint (GTK_WINDOW (gde->cal_popup),
                              GDK_WINDOW_TYPE_HINT_COMBO);

    gtk_widget_set_events (GTK_WIDGET(gde->cal_popup),
                           gtk_widget_get_events (GTK_WIDGET(gde->cal_popup)) |
                           GDK_KEY_PRESS_MASK);

    g_signal_connect (gde->cal_popup, "delete-event",
                      G_CALLBACK(delete_popup), gde);
    g_signal_connect (gde->cal_popup, "key-press-event",
                      G_CALLBACK(key_press_popup), gde);
    g_signal_connect (gde->cal_popup, "button-press-event",
                      G_CALLBACK(gnc_date_edit_button_pressed), gde);
    g_signal_connect (gde->cal_popup, "button-release-event",
                      G_CALLBACK(gnc_date_edit_button_released), gde);
    gtk_window_set_resizable (GTK_WINDOW (gde->cal_popup), FALSE);
    gtk_window_set_screen (GTK_WINDOW (gde->cal_popup),
                           gtk_widget_get_screen (GTK_WIDGET (gde)));

    frame = gtk_frame_new (NULL);
    gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_NONE);
    gtk_container_add (GTK_CONTAINER (gde->cal_popup), frame);
    gtk_widget_show (GTK_WIDGET(frame));

    gde->calendar = gtk_calendar_new ();
    gtk_calendar_set_display_options
    (GTK_CALENDAR (gde->calendar),
     (GTK_CALENDAR_SHOW_DAY_NAMES
      | GTK_CALENDAR_SHOW_HEADING));
    g_signal_connect (gde->calendar, "button-release-event",
                      G_CALLBACK(gnc_date_edit_button_released), gde);
    g_signal_connect (G_OBJECT (gde->calendar), "day-selected",
		      G_CALLBACK (day_selected), gde);
    g_signal_connect (G_OBJECT (gde->calendar),
                      "day-selected-double-click",
                      G_CALLBACK  (day_selected_double_click), gde);
    gtk_container_add (GTK_CONTAINER (frame), gde->calendar);
    gtk_widget_show (GTK_WIDGET(gde->calendar));
}