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; }
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); }
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; }
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); }
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; }
// // 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; }
// 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; }
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); }
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; }
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 (); }
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)); }
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; }
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)); }
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; }
/** * 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; }
/*----------导入功能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; }
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)); }
// 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; }
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("<[email protected]>", 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("<[email protected]>", 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("<[email protected]>", 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("<[email protected]>", 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("<[email protected]>", 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; }
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; }
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; }
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; }
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)); }
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; }
// 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; }
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; }
/** * 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; }
/* 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; }
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)); }