static void on_content_size_changed (GtkWidget *widget, GtkAllocation *allocation, gpointer data) { if (allocation->height < 490) { gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (widget), GTK_POLICY_NEVER, GTK_POLICY_NEVER); } else { gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (widget), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW (widget), 490); } }
static void notebook_page_notify_cb (GtkNotebook *notebook, GParamSpec *spec, GnomeControlCenterPrivate *priv) { int nat_height; GtkWidget *child; child = notebook_get_selected_page (GTK_WIDGET (notebook)); /* make sure the home button is shown on all pages except the overview page */ if (child == priv->scrolled_window || child == priv->search_scrolled) { gtk_widget_hide (W (priv->builder, "home-button")); gtk_widget_show (W (priv->builder, "search-entry")); gtk_widget_hide (W (priv->builder, "lock-button")); gtk_widget_get_preferred_height_for_width (GTK_WIDGET (priv->main_vbox), FIXED_WIDTH, NULL, &nat_height); gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW (priv->scrolled_window), priv->small_screen == SMALL_SCREEN_TRUE ? SMALL_SCREEN_FIXED_HEIGHT : nat_height); } else { gtk_widget_show (W (priv->builder, "home-button")); gtk_widget_hide (W (priv->builder, "search-entry")); /* set the scrolled window small so that it doesn't force the window to be larger than this panel */ gtk_widget_get_preferred_height_for_width (GTK_WIDGET (priv->window), FIXED_WIDTH, NULL, &nat_height); gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW (priv->scrolled_window), MIN_ICON_VIEW_HEIGHT); gtk_window_resize (GTK_WINDOW (priv->window), FIXED_WIDTH, nat_height); } }
static GtkWidget * test_chase (void) { GtkWidget *win; GtkWidget *overlay; GtkWidget *sw; GtkWidget *text; GtkWidget *child; GtkTextBuffer *buffer; gchar *contents; gsize len; win = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (win), "Chase"); overlay = gtk_overlay_new (); gtk_widget_set_events (overlay, GDK_ENTER_NOTIFY_MASK|GDK_LEAVE_NOTIFY_MASK); gtk_container_add (GTK_CONTAINER (win), overlay); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_min_content_width (GTK_SCROLLED_WINDOW (sw), 200); gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW (sw), 200); gtk_container_add (GTK_CONTAINER (overlay), sw); text = gtk_text_view_new (); buffer = gtk_text_buffer_new (NULL); if (!g_file_get_contents ("testoverlay.c", &contents, &len, NULL)) { contents = g_strdup ("Text should go here..."); len = strlen (contents); } gtk_text_buffer_set_text (buffer, contents, len); g_free (contents); gtk_text_view_set_buffer (GTK_TEXT_VIEW (text), buffer); gtk_widget_set_hexpand (text, TRUE); gtk_widget_set_vexpand (text, TRUE); gtk_container_add (GTK_CONTAINER (sw), text); child = gtk_label_new ("Try to enter"); gtk_widget_set_halign (child, GTK_ALIGN_START); gtk_widget_set_valign (child, GTK_ALIGN_END); gtk_overlay_add_overlay (GTK_OVERLAY (overlay), child); g_object_set (child, "margin", 4, NULL); g_signal_connect (overlay, "enter-notify-event", G_CALLBACK (on_enter), child); return win; }
static void on_content_size_changed (GtkWidget *content, GtkAllocation *allocation, GtkWidget *panel) { if (allocation->height < SCROLL_HEIGHT) { gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (panel), GTK_POLICY_NEVER, GTK_POLICY_NEVER); } else { gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (panel), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW (panel), SCROLL_HEIGHT); } }
void ZCGtkTabPanel::addTab(const std::string& name, Widget* w) { std::string mod=convertMnemonic(name); GtkWidget* label=gtk_label_new_with_mnemonic(mod.c_str()); // Put the content in a scrolling pane, in case it's really big // TODO: Maybe do something better about the size GtkWidget* scrollPane=gtk_scrolled_window_new(0, 0); gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(scrollPane), 480); g_signal_connect(scrollPane, "destroy", G_CALLBACK(gtk_widget_destroyed), &scrollPane); ZCGtkWidget* zw=dynamic_cast<ZCGtkWidget*>(w); contents.push_back(zw); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrollPane), zw->get()); gtk_notebook_append_page(GTK_NOTEBOOK(tabPanel), scrollPane, label); }
static void cb_realize_treeview (GtkWidget *list, GtkWidget *sw) { GtkRequisition req; GdkRectangle rect; GtkTreePath *clip = g_object_get_data (G_OBJECT (list), "clip"); gtk_widget_get_preferred_size (GTK_WIDGET (list), &req, NULL); gtk_tree_view_get_background_area (GTK_TREE_VIEW (list), clip, NULL, &rect); gtk_scrolled_window_set_min_content_width (GTK_SCROLLED_WINDOW (sw), req.width); gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW (sw), rect.y); }
/* test that scrolling works as expected */ static GtkWidget * test_scrolling (void) { GtkWidget *win; GtkWidget *overlay; GtkWidget *sw; GtkWidget *text; GtkWidget *child; GtkTextBuffer *buffer; gchar *contents; gsize len; win = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (win), "Scrolling"); overlay = gtk_overlay_new (); gtk_container_add (GTK_CONTAINER (win), overlay); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_min_content_width (GTK_SCROLLED_WINDOW (sw), 200); gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW (sw), 200); gtk_container_add (GTK_CONTAINER (overlay), sw); text = gtk_text_view_new (); buffer = gtk_text_buffer_new (NULL); if (!g_file_get_contents ("testoverlay.c", &contents, &len, NULL)) { contents = g_strdup ("Text should go here..."); len = strlen (contents); } gtk_text_buffer_set_text (buffer, contents, len); g_free (contents); gtk_text_view_set_buffer (GTK_TEXT_VIEW (text), buffer); gtk_widget_set_hexpand (text, TRUE); gtk_widget_set_vexpand (text, TRUE); gtk_container_add (GTK_CONTAINER (sw), text); child = gtk_label_new ("This should be visible"); gtk_widget_set_halign (child, GTK_ALIGN_CENTER); gtk_widget_set_valign (child, GTK_ALIGN_END); gtk_overlay_add_overlay (GTK_OVERLAY (overlay), child); g_object_set (child, "margin", 4, NULL); return win; }
void gui_init(dt_lib_module_t *self) { /* initialize ui widgets */ dt_lib_duplicate_t *d = (dt_lib_duplicate_t *)g_malloc0(sizeof(dt_lib_duplicate_t)); self->data = (void *)d; d->imgid = 0; self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, DT_PIXEL_APPLY_DPI(5)); gtk_widget_set_name(self->widget, "duplicate-ui"); GtkWidget *sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(sw), DT_PIXEL_APPLY_DPI(300)); d->duplicate_box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); GtkWidget *hb = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); GtkWidget *bt = gtk_label_new(_("existing duplicates")); gtk_box_pack_start(GTK_BOX(hb), bt, FALSE, FALSE, 0); bt = dtgtk_button_new(dtgtk_cairo_paint_plusminus, CPF_ACTIVE | CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER, NULL); g_object_set(G_OBJECT(bt), "tooltip-text", _("create a 'virgin' duplicate of the image without any developpement"), (char *)NULL); g_signal_connect(G_OBJECT(bt), "button-press-event", G_CALLBACK(_lib_duplicate_new_clicked_callback), self); gtk_box_pack_end(GTK_BOX(hb), bt, FALSE, FALSE, 0); bt = dtgtk_button_new(dtgtk_cairo_paint_multiinstance, CPF_STYLE_FLAT | CPF_DO_NOT_USE_BORDER, NULL); g_object_set(G_OBJECT(bt), "tooltip-text", _("create a duplicate of the image with same history stack"), (char *)NULL); g_signal_connect(G_OBJECT(bt), "button-press-event", G_CALLBACK(_lib_duplicate_duplicate_clicked_callback), self); gtk_box_pack_end(GTK_BOX(hb), bt, FALSE, FALSE, 0); /* add duplicate list and buttonbox to widget */ gtk_box_pack_start(GTK_BOX(self->widget), hb, FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(sw), d->duplicate_box); gtk_box_pack_start(GTK_BOX(self->widget), sw, FALSE, FALSE, 0); gtk_widget_show_all(self->widget); dt_control_signal_connect(darktable.signals, DT_SIGNAL_DEVELOP_IMAGE_CHANGED, G_CALLBACK(_lib_duplicate_init_callback), self); dt_control_signal_connect(darktable.signals, DT_SIGNAL_DEVELOP_INITIALIZE, G_CALLBACK(_lib_duplicate_init_callback), self); dt_control_signal_connect(darktable.signals, DT_SIGNAL_COLLECTION_CHANGED, G_CALLBACK(_lib_duplicate_init_callback), self); dt_control_signal_connect(darktable.signals, DT_SIGNAL_DEVELOP_MIPMAP_UPDATED, G_CALLBACK(_lib_duplicate_mipmap_updated_callback), (gpointer)self); }
static void on_list_realize (GtkWidget * widget, gpointer user_data) { GtkWidget *parent = gtk_widget_get_parent (widget); GtkRequisition requisition; gint height, max_height; gtk_widget_get_preferred_size (widget, NULL, &requisition); bt_gtk_workarea_size (NULL, &max_height); /* make sure the dialog resize without scrollbar until it would reach half * screen height */ max_height /= 2; GST_DEBUG ("#### crash_recover_list size req %d x %d (max-height=%d)", requisition.width, requisition.height, max_height); height = MIN (requisition.height, max_height); // TODO(ensonic): is the '2' some border or padding gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW (parent), height + 2); }
/* we adjust the scrollable-window size to contain the whole area */ static void on_settings_list_realize (GtkWidget * widget, gpointer user_data) { GtkWidget *parent = GTK_WIDGET (user_data); GtkRequisition requisition; gint height; gint max_height = gdk_screen_get_height (gdk_screen_get_default ()); gtk_widget_get_preferred_size (widget, NULL, &requisition); GST_LOG ("#### list size req %d x %d (max-height=%d)", requisition.width, requisition.height, max_height); height = requisition.height; // constrain the height by screen height if (height > max_height) { // lets hope that 32 gives enough space for window-decoration + panels height = max_height - 32; } // TODO(ensonic): is the '2' some border or padding gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW (parent), height + 4); }
static void setup_list_size_constraint (GtkWidget *widget, GtkWidget *to_size) { #if GTK_CHECK_VERSION (3, 0, 0) GtkRequisition req; int max_height; /* Constrain height to be the tree height up to a max */ max_height = (gdk_screen_get_height (gtk_widget_get_screen (widget))) / 4; // XXX this doesn't work gtk_widget_get_preferred_size (to_size, NULL, &req); gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW (widget), MIN (req.height, max_height)); #else g_signal_connect (G_OBJECT (widget), "size-request", G_CALLBACK (constrain_list_size), to_size); #endif }
/**************************************************************** Bring up the global worklist report. *****************************************************************/ static GtkWidget *create_worklists_report(void) { GtkWidget *shell, *list; GtkWidget *vbox, *label, *sw; GtkCellRenderer *rend; shell = gtk_dialog_new_with_buttons(_("Edit worklists"), NULL, 0, GTK_STOCK_NEW, WORKLISTS_NEW, GTK_STOCK_DELETE, WORKLISTS_DELETE, GTK_STOCK_PROPERTIES, WORKLISTS_PROPERTIES, GTK_STOCK_CLOSE, WORKLISTS_CLOSE, NULL); setup_dialog(shell, toplevel); gtk_window_set_position(GTK_WINDOW(shell), GTK_WIN_POS_MOUSE); g_signal_connect(shell, "response", G_CALLBACK(worklists_response), NULL); g_signal_connect(shell, "destroy", G_CALLBACK(worklists_destroy_callback), NULL); vbox = gtk_grid_new(); gtk_grid_set_row_spacing(GTK_GRID(vbox), 2); gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox), GTK_ORIENTATION_VERTICAL); gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(shell))), vbox); worklists_store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); list = gtk_tree_view_new_with_model(GTK_TREE_MODEL(worklists_store)); gtk_widget_set_hexpand(list, TRUE); gtk_widget_set_vexpand(list, TRUE); g_object_unref(worklists_store); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(list), FALSE); worklists_list = list; rend = gtk_cell_renderer_text_new(); g_object_set(rend, "editable", TRUE, NULL); g_signal_connect(rend, "edited", G_CALLBACK(cell_edited), NULL); gtk_tree_view_insert_column_with_attributes(GTK_TREE_VIEW(list), -1, NULL, rend, "text", 0, NULL); sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(sw), 200); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_ETCHED_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_container_add(GTK_CONTAINER(sw), list); label = g_object_new(GTK_TYPE_LABEL, "use-underline", TRUE, "mnemonic-widget", list, "label", _("_Worklists:"), "xalign", 0.0, "yalign", 0.5, NULL); gtk_container_add(GTK_CONTAINER(vbox), label); gtk_container_add(GTK_CONTAINER(vbox), sw); gtk_widget_show_all(vbox); return shell; }
static GtkWidget * glade_eprop_string_list_create_input (GladeEditorProperty * eprop) { GladeEPropStringList *eprop_string_list = GLADE_EPROP_STRING_LIST (eprop); GtkTreeViewColumn *column; GtkCellRenderer *renderer; GtkWidget *swindow; eprop_string_list->view = gtk_tree_view_new (); column = gtk_tree_view_column_new (); /* Text renderer */ renderer = gtk_cell_renderer_text_new (); g_object_set (G_OBJECT (renderer), "editable", TRUE, "ellipsize", PANGO_ELLIPSIZE_END, NULL); g_signal_connect (G_OBJECT (renderer), "edited", G_CALLBACK (string_edited), eprop); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_attributes (column, renderer, "text", COLUMN_STRING, NULL); gtk_tree_view_column_set_cell_data_func (column, renderer, (GtkTreeCellDataFunc)cell_data_func, eprop, NULL); /* "id" renderer */ renderer = gtk_cell_renderer_text_new (); g_object_set (G_OBJECT (renderer), "editable", TRUE, "ellipsize", PANGO_ELLIPSIZE_END, NULL); g_signal_connect (G_OBJECT (renderer), "edited", G_CALLBACK (id_edited), eprop); gtk_tree_view_column_pack_start (column, renderer, TRUE); gtk_tree_view_column_set_cell_data_func (column, renderer, (GtkTreeCellDataFunc)id_cell_data_func, eprop, NULL); /* i18n icon renderer */ renderer = glade_cell_renderer_icon_new (); g_object_set (G_OBJECT (renderer), "icon-name", "gtk-edit", NULL); g_signal_connect (G_OBJECT (renderer), "activate", G_CALLBACK (i18n_icon_activate), eprop); gtk_tree_view_column_pack_start (column, renderer, FALSE); gtk_tree_view_column_set_cell_data_func (column, renderer, (GtkTreeCellDataFunc)cell_data_func, eprop, NULL); eprop_string_list->model = (GtkTreeModel *)gtk_list_store_new (NUM_COLUMNS, G_TYPE_STRING, G_TYPE_UINT, G_TYPE_BOOLEAN, G_TYPE_STRING); g_signal_connect (G_OBJECT (eprop_string_list->model), "row-deleted", G_CALLBACK (row_deleted), eprop); gtk_tree_view_append_column (GTK_TREE_VIEW (eprop_string_list->view), column); gtk_tree_view_set_model (GTK_TREE_VIEW (eprop_string_list->view), eprop_string_list->model); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (eprop_string_list->view), FALSE); gtk_tree_view_set_reorderable (GTK_TREE_VIEW (eprop_string_list->view), TRUE); g_signal_connect (eprop_string_list->view, "key-press-event", G_CALLBACK (treeview_key_press), eprop); swindow = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW (swindow), get_tree_view_height ()); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (swindow), GTK_SHADOW_IN); gtk_container_add (GTK_CONTAINER (swindow), eprop_string_list->view); gtk_widget_set_hexpand (swindow, TRUE); gtk_widget_show (eprop_string_list->view); gtk_widget_show (swindow); return swindow; }
int main(int argc, char ** argv) { GtkWidget * vbox; GtkWidget * hpaned; GtkWidget * sc_win, * sc_buffer; GtkWidget * menu_bar; GtkWidget * file_menu, * file_item; GtkWidget * generate_menu, * generate_item; GtkWidget * settings_menu, * settings_item; GtkWidget * zoom_box, * zoom_button; int i; //init general colors = (color_t *)malloc(NUM_COLORS * sizeof(color_t)); oldcolors = (color_t *)malloc(OLD_NUM_COLORS * sizeof(color_t)); memset(mdata, 0, BUFFER_COUNT * sizeof(unsigned char *)); memset(icons, 0, BUFFER_COUNT * sizeof(GtkWidget *)); memset(icon_event_boxes, 0, BUFFER_COUNT * sizeof(GtkWidget *)); mdata[current_buffer] = (unsigned char *)malloc(128 * 128); load_colors_plain(colors, "colors"); load_colors_plain(oldcolors, "oldcolors"); newcolors = colors; //save_colors(colors, "colors.bin"); //load_colors(colors, "colors.bin"); srand(time(NULL)); config = config_new(); //init gtk gtk_init(&argc, &argv); //window window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window), "ImageToMap X v" VERSION_NUMBER); g_signal_connect(window, "delete_event", G_CALLBACK(kill_window), NULL); //vbox #ifdef GTK2 vbox = gtk_vbox_new(FALSE, 0); #else vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); #endif gtk_frame_set_shadow_type(GTK_FRAME(vbox), GTK_SHADOW_IN); gtk_container_add(GTK_CONTAINER (window), vbox); gtk_widget_show(vbox); //////menu_bar menu_bar = gtk_menu_bar_new(); gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, TRUE, 0); gtk_widget_show(menu_bar); ////////file_menu file_menu = gtk_menu_new(); //////////file_menu items construct_tool_bar_add(file_menu, "Open", ITEM_SIGNAL_OPEN); construct_tool_bar_add(file_menu, "Open Grid Image", ITEM_SIGNAL_OPEN_GRID_IMAGE); construct_tool_bar_add(file_menu, "Save", ITEM_SIGNAL_SAVE); construct_tool_bar_add(file_menu, "Save Increment", ITEM_SIGNAL_SAVE_INCREMENT); construct_tool_bar_add(file_menu, "Save All", ITEM_SIGNAL_SAVE_ALL); construct_tool_bar_add(file_menu, "Save Raw Map", ITEM_SIGNAL_SAVE_RM); construct_tool_bar_add(file_menu, "Export Image", ITEM_SIGNAL_EXPORT_IMAGE); /* construct_tool_bar_add_deactivate(file_menu, "Render World", ITEM_SIGNAL_WORLD_RENDER_ITEM); */ construct_tool_bar_add(file_menu, "Render World", ITEM_SIGNAL_WORLD_RENDER_ITEM); construct_tool_bar_add(file_menu, "Clean Buffer List", ITEM_SIGNAL_CLEAN); construct_tool_bar_add(file_menu, "Quit", ITEM_SIGNAL_QUIT); /////////file_item file_item = gtk_menu_item_new_with_label("File"); gtk_widget_show(file_item); gtk_menu_item_set_submenu(GTK_MENU_ITEM(file_item), file_menu); gtk_menu_shell_append((GtkMenuShell *)menu_bar, file_item); ////////generate_menu generate_menu = gtk_menu_new(); //////////generate_menu items construct_tool_bar_add(generate_menu, "Mandelbrot", ITEM_SIGNAL_GENERATE_MANDELBROT); construct_tool_bar_add(generate_menu, "Julia", ITEM_SIGNAL_GENERATE_JULIA); construct_tool_bar_add(generate_menu, "Palette", ITEM_SIGNAL_GENERATE_PALETTE); construct_tool_bar_add(generate_menu, "Random Noise", ITEM_SIGNAL_GENERATE_RANDOM_NOISE); construct_tool_bar_add(generate_menu, "From Clipboard", ITEM_SIGNAL_GENERATE_FROM_CLIPBOARD); /////////generate_item generate_item = gtk_menu_item_new_with_label("Generate"); gtk_widget_show(generate_item); gtk_menu_item_set_submenu(GTK_MENU_ITEM(generate_item), generate_menu); gtk_menu_shell_append((GtkMenuShell *)menu_bar, generate_item); ////////settings_menu settings_menu = gtk_menu_new(); ////////settings_item settings_item = gtk_menu_item_new_with_label("Settings"); gtk_widget_show(settings_item); gtk_menu_item_set_submenu(GTK_MENU_ITEM(settings_item), settings_menu); gtk_menu_shell_append((GtkMenuShell *)menu_bar, settings_item); //////////FSD_checkbox FSD_checkbox = gtk_check_menu_item_new_with_label("Floyd–Steinberg dithering"); gtk_menu_shell_append(GTK_MENU_SHELL(settings_menu), FSD_checkbox); gtk_widget_show(FSD_checkbox); //////////YUV_checkbox YUV_checkbox = gtk_check_menu_item_new_with_label("YUV color conversion"); gtk_menu_shell_append(GTK_MENU_SHELL(settings_menu), YUV_checkbox); gtk_widget_show(YUV_checkbox); //////////old_colors_checkbox old_colors_checkbox = gtk_check_menu_item_new_with_label("Old Colors"); gtk_menu_shell_append(GTK_MENU_SHELL(settings_menu), old_colors_checkbox); gtk_widget_show(old_colors_checkbox); g_signal_connect_swapped(old_colors_checkbox, "toggled", G_CALLBACK(old_colors_checkbox_toggle), 0); //drop_down_menu init_drop_down_menu(); //hpaned #ifdef GTK2 hpaned = gtk_hpaned_new(); #else hpaned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL); #endif gtk_widget_set_size_request (hpaned, 220, -1); gtk_box_pack_start(GTK_BOX(vbox), hpaned, TRUE, TRUE, 0); gtk_widget_show(hpaned); ////sc_buffer sc_buffer = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sc_buffer), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); #ifdef GTK2 gtk_widget_set_size_request(sc_buffer, 128 + 32, 512); #else gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(sc_buffer), 128 + 32); gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(sc_buffer), 512); #endif gtk_paned_pack2(GTK_PANED(hpaned), sc_buffer, FALSE, FALSE); gtk_widget_show(sc_buffer); //////list_vbox #ifdef GTK2 list_vbox = gtk_vbox_new(FALSE, 0); #else list_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); #endif #ifdef GTK2 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sc_buffer), list_vbox); #else gtk_container_add(GTK_CONTAINER(sc_buffer), list_vbox); #endif gtk_widget_show(list_vbox); ////sc_win sc_win = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sc_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); #ifdef GTK2 gtk_widget_set_size_request(sc_win, 128 * 4, 128 * 4); gtk_window_resize(GTK_WINDOW(window), 128 * 4 + 200, 128 * 4 + 70); #else gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(sc_win), 128 * 4); gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(sc_win), 128 * 4); #endif gtk_paned_pack1(GTK_PANED(hpaned), sc_win, TRUE, FALSE); gtk_widget_show(sc_win); //////image dimage = gdk_pixbuf_new_from_file("start.png", NULL); image = gtk_image_new(); gtk_image_set_from_pixbuf(GTK_IMAGE(image), dimage); #ifdef GTK2 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sc_win), image); #else gtk_container_add(GTK_CONTAINER(sc_win), image); #endif gtk_widget_show(image); ////zoom_box #ifdef GTK2 zoom_box = gtk_hbox_new(FALSE, 0); #else zoom_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); #endif gtk_box_pack_start(GTK_BOX(vbox), zoom_box, FALSE, FALSE, 0); gtk_widget_show(zoom_box); //////zoom_button (+) zoom_button = gtk_button_new_with_label("+"); gtk_box_pack_start(GTK_BOX(zoom_box), zoom_button, TRUE, TRUE, 2); g_signal_connect(zoom_button, "clicked", G_CALLBACK(button_click2), "button.zoomp"); gtk_widget_show(zoom_button); //////zoom_button (|) zoom_button = gtk_button_new_with_label("|"); gtk_box_pack_start(GTK_BOX(zoom_box), zoom_button, TRUE, TRUE, 2); g_signal_connect(zoom_button, "clicked", G_CALLBACK(button_click2), "button.zoome"); gtk_widget_show(zoom_button); //////zoom_button (-) zoom_button = gtk_button_new_with_label("-"); gtk_box_pack_start(GTK_BOX(zoom_box), zoom_button, TRUE, TRUE, 2); g_signal_connect(zoom_button, "clicked", G_CALLBACK(button_click2), "button.zoomm"); gtk_widget_show(zoom_button); //icon gtk_window_set_icon(GTK_WINDOW(window), create_pixbuf("imagetomap.ico")); //Drag and drop gtk_drag_dest_set(window, GTK_DEST_DEFAULT_ALL, targets, sizeof(targets)/sizeof(*targets), GDK_ACTION_COPY); gtk_drag_dest_add_uri_targets(window); g_signal_connect(window, "drag-drop", G_CALLBACK(drag_drop), NULL); g_signal_connect(window, "drag-motion", G_CALLBACK(drag_motion), NULL); g_signal_connect(window, "drag-data-received", G_CALLBACK(drag_received), NULL); g_signal_connect(window, "drag-leave", G_CALLBACK(drag_leave), NULL); //display window gtk_widget_show (window); gtk_main(); //clean up free(colors); for(i = 0; i < BUFFER_COUNT; i++) free(mdata[i]); config_free(config); return 0; }
gint main (gint argc, gchar **argv) { GtkWidget *window, *main_box, *container, *child; GtkWidget *box, *toolbar; GtkStyleProvider *provider; GtkTextBuffer *css; gtk_init (&argc, &argv); css = gtk_text_buffer_new (NULL); gtk_text_buffer_create_tag (css, "warning", "background", "rgba(255,255,0,0.3)", NULL); gtk_text_buffer_create_tag (css, "error", "background", "rgba(255,0,0,0.3)", NULL); provider = GTK_STYLE_PROVIDER (gtk_css_provider_new ()); gtk_style_context_add_provider_for_screen (gdk_screen_get_default (), provider, GTK_STYLE_PROVIDER_PRIORITY_FORCE); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect (window, "destroy", G_CALLBACK(gtk_main_quit), NULL); g_signal_connect (window, "delete_event", G_CALLBACK (gtk_main_quit), NULL); main_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_add (GTK_CONTAINER (window), main_box); toolbar = gtk_toolbar_new (); gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_TEXT); gtk_box_pack_start (GTK_BOX (main_box), toolbar, FALSE, TRUE, 0); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (main_box), box, FALSE, TRUE, 0); container = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_min_content_width (GTK_SCROLLED_WINDOW (container), 200); gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW (container), 200); gtk_box_pack_start (GTK_BOX (main_box), container, TRUE, TRUE, 0); child = gtk_text_view_new_with_buffer (css); gtk_container_add (GTK_CONTAINER (container), child); g_signal_connect (css, "changed", G_CALLBACK (css_text_changed), provider); gtk_text_buffer_set_text (css, DEFAULT_CSS, -1); g_signal_connect (provider, "parsing-error", G_CALLBACK (show_parsing_error), gtk_text_view_get_buffer (GTK_TEXT_VIEW (child))); container = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (main_box), container, FALSE, TRUE, 0); child = gtk_switch_new (); gtk_switch_set_active (GTK_SWITCH (child), gtk_widget_get_default_direction () == GTK_TEXT_DIR_LTR); g_signal_connect (child, "notify::active", G_CALLBACK (set_orientation), NULL); gtk_box_pack_start (GTK_BOX (container), child, FALSE, FALSE, 0); child = gtk_label_new ("left-to-right"); gtk_box_pack_start (GTK_BOX (container), child, FALSE, FALSE, 0); child = gtk_button_new_with_label ("Add button"); g_signal_connect_swapped (child, "clicked", G_CALLBACK (add_button), box); gtk_box_pack_end (GTK_BOX (container), child, FALSE, FALSE, 0); child = gtk_button_new_with_label ("Add toolbutton"); g_signal_connect_swapped (child, "clicked", G_CALLBACK (add_toolbutton), toolbar); gtk_box_pack_end (GTK_BOX (container), child, FALSE, FALSE, 0); add_toolbutton (GTK_TOOLBAR (toolbar)); add_toolbutton (GTK_TOOLBAR (toolbar)); add_toolbutton (GTK_TOOLBAR (toolbar)); add_toolbutton (GTK_TOOLBAR (toolbar)); add_button (GTK_BOX (box)); add_button (GTK_BOX (box)); add_button (GTK_BOX (box)); add_button (GTK_BOX (box)); gtk_widget_show_all (window); gtk_main (); return 0; }
static gint _cookie_permission_manager_ask_for_policy(CookiePermissionManager *self, MidoriView *inView, SoupMessage *inMessage, GSList *inUnknownCookies) { /* Ask user for policy of unkndown domains in an undistracting way. * The idea is to put the message not in a modal window but into midori's info bar. * Then we'll set up our own GMainLoop to simulate a modal info bar. We need to * connect to all possible signals of info bar, web view and so on to handle user's * decision and to get out of our own GMainLoop. After that webkit resumes processing * data. */ CookiePermissionManagerPrivate *priv=self->priv; GtkWidget *infobar; /* FIXME: Find a way to add "details" widget */ #ifndef NO_INFOBAR_DETAILS GtkWidget *widget; GtkWidget *contentArea; GtkWidget *vbox, *hbox; GtkWidget *expander; GtkListStore *listStore; GtkTreeIter listIter; GtkWidget *scrolled; GtkWidget *list; GtkCellRenderer *renderer; GtkTreeViewColumn *column; #endif gchar *text; gint numberDomains, numberCookies; GSList *sortedCookies, *cookies; WebKitWebView *webkitView; CookiePermissionManagerModalInfobar *modalInfo; /* Get webkit view of midori view */ webkitView=WEBKIT_WEB_VIEW(midori_view_get_web_view(inView)); modalInfo=g_new0(CookiePermissionManagerModalInfobar, 1); /* Create a copy of cookies and sort them */ sortedCookies=_cookie_permission_manager_get_number_domains_and_cookies(self, inUnknownCookies, &numberDomains, &numberCookies); /* FIXME: Find a way to add "details" widget */ #ifndef NO_INFOBAR_DETAILS /* Create list model and fill in data */ listStore=gtk_list_store_new(N_COLUMN, G_TYPE_STRING, /* DOMAIN_COLUMN */ G_TYPE_STRING, /* PATH_COLUMN */ G_TYPE_STRING, /* NAME_COLUMN */ G_TYPE_STRING, /* VALUE_COLUMN */ G_TYPE_STRING /* EXPIRE_DATE_COLUMN */); for(cookies=sortedCookies; cookies; cookies=cookies->next) { SoupCookie *cookie=(SoupCookie*)cookies->data; SoupDate *cookieDate=soup_cookie_get_expires(cookie); if(cookieDate) text=soup_date_to_string(cookieDate, SOUP_DATE_HTTP); else text=g_strdup(_("Till session end")); gtk_list_store_append(listStore, &listIter); gtk_list_store_set(listStore, &listIter, DOMAIN_COLUMN, soup_cookie_get_domain(cookie), PATH_COLUMN, soup_cookie_get_path(cookie), NAME_COLUMN, soup_cookie_get_name(cookie), VALUE_COLUMN, soup_cookie_get_value(cookie), EXPIRE_DATE_COLUMN, text, -1); g_free(text); } #endif /* Create description text */ if(numberDomains==1) { const gchar *cookieDomain=soup_cookie_get_domain((SoupCookie*)sortedCookies->data); if(*cookieDomain=='.') cookieDomain++; if(numberCookies>1) text=g_strdup_printf(_("The website %s wants to store %d cookies."), cookieDomain, numberCookies); else text=g_strdup_printf(_("The website %s wants to store a cookie."), cookieDomain); } else { text=g_strdup_printf(_("Multiple websites want to store %d cookies in total."), numberCookies); } /* Create info bar message and buttons */ infobar=midori_view_add_info_bar(inView, GTK_MESSAGE_QUESTION, text, G_CALLBACK(_cookie_permission_manager_on_infobar_policy_decision), NULL, _("_Accept"), COOKIE_PERMISSION_MANAGER_POLICY_ACCEPT, _("Accept for this _session"), COOKIE_PERMISSION_MANAGER_POLICY_ACCEPT_FOR_SESSION, _("De_ny"), COOKIE_PERMISSION_MANAGER_POLICY_BLOCK, _("Deny _this time"), COOKIE_PERMISSION_MANAGER_POLICY_UNDETERMINED, NULL); g_free(text); /* midori_view_add_info_bar() in version 0.4.8 expects a GObject as user data * but I don't want to create an GObject just for a simple struct. So set object * data by our own */ g_object_set_data_full(G_OBJECT(infobar), "cookie-permission-manager-infobar-data", modalInfo, (GDestroyNotify)g_free); /* FIXME: Find a way to add "details" widget */ #ifndef NO_INFOBAR_DETAILS /* Get content area of infobar */ contentArea=gtk_info_bar_get_content_area(GTK_INFO_BAR(infobar)); /* Create list and set up columns of list */ list=gtk_tree_view_new_with_model(GTK_TREE_MODEL(listStore)); #ifndef HAVE_GTK3 gtk_widget_set_size_request(list, -1, 100); #endif renderer=gtk_cell_renderer_text_new(); column=gtk_tree_view_column_new_with_attributes(_("Domain"), renderer, "text", DOMAIN_COLUMN, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(list), column); renderer=gtk_cell_renderer_text_new(); column=gtk_tree_view_column_new_with_attributes(_("Path"), renderer, "text", PATH_COLUMN, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(list), column); renderer=gtk_cell_renderer_text_new(); column=gtk_tree_view_column_new_with_attributes(_("Name"), renderer, "text", NAME_COLUMN, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(list), column); renderer=gtk_cell_renderer_text_new(); column=gtk_tree_view_column_new_with_attributes(_("Value"), renderer, "text", VALUE_COLUMN, NULL); g_object_set(G_OBJECT(renderer), "ellipsize", PANGO_ELLIPSIZE_END, "width-chars", 30, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(list), column); renderer=gtk_cell_renderer_text_new(); column=gtk_tree_view_column_new_with_attributes(_("Expire date"), renderer, "text", EXPIRE_DATE_COLUMN, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(list), column); scrolled=gtk_scrolled_window_new(NULL, NULL); #ifdef HAVE_GTK3 gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(scrolled), 100); #endif gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(scrolled), list); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN); gtk_container_add(GTK_CONTAINER(expander), scrolled); gtk_widget_show_all(vbox); gtk_container_add(GTK_CONTAINER(contentArea), vbox); /* Set state of expander based on config 'show-details-when-ask' */ gtk_expander_set_expanded(GTK_EXPANDER(expander), midori_extension_get_boolean(priv->extension, "show-details-when-ask")); g_signal_connect_swapped(expander, "notify::expanded", G_CALLBACK(_cookie_permission_manager_when_ask_expander_changed), self); #endif /* Show all widgets of info bar */ gtk_widget_show_all(infobar); /* Connect signals to quit main loop */ g_signal_connect(webkitView, "navigation-policy-decision-requested", G_CALLBACK(_cookie_permission_manager_on_infobar_webview_navigate), infobar); g_signal_connect(infobar, "destroy", G_CALLBACK(_cookie_permission_manager_on_infobar_destroy), modalInfo); /* Let info bar be modal and set response to default */ modalInfo->response=COOKIE_PERMISSION_MANAGER_POLICY_UNDETERMINED; modalInfo->mainLoop=g_main_loop_new(NULL, FALSE); GDK_THREADS_LEAVE(); g_main_loop_run(modalInfo->mainLoop); GDK_THREADS_ENTER(); g_main_loop_unref(modalInfo->mainLoop); modalInfo->mainLoop=NULL; /* Disconnect signal handler to webkit's web view */ g_signal_handlers_disconnect_by_func(webkitView, G_CALLBACK(_cookie_permission_manager_on_infobar_webview_navigate), infobar); /* Store user's decision in database if it is not a temporary block. * We use the already sorted list of cookies to prevent multiple * updates of database for the same domain. This sorted list is a copy * to avoid a reorder of cookies */ if(modalInfo->response!=COOKIE_PERMISSION_MANAGER_POLICY_UNDETERMINED) { const gchar *lastDomain=NULL; /* Iterate through cookies and store decision for each domain once */ for(cookies=sortedCookies; cookies; cookies=cookies->next) { SoupCookie *cookie=(SoupCookie*)cookies->data; const gchar *cookieDomain=soup_cookie_get_domain(cookie); if(*cookieDomain=='.') cookieDomain++; /* Store decision if new domain found while iterating through cookies */ if(!lastDomain || g_ascii_strcasecmp(lastDomain, cookieDomain)!=0) { gchar *sql; gchar *error=NULL; gint success; sql=sqlite3_mprintf("INSERT OR REPLACE INTO policies (domain, value) VALUES ('%q', %d);", cookieDomain, modalInfo->response); success=sqlite3_exec(priv->database, sql, NULL, NULL, &error); if(success!=SQLITE_OK) g_warning(_("SQL fails: %s"), error); if(error) sqlite3_free(error); sqlite3_free(sql); lastDomain=cookieDomain; } } } /* Free up allocated resources */ g_slist_free(sortedCookies); /* Return response */ return(modalInfo->response==COOKIE_PERMISSION_MANAGER_POLICY_UNDETERMINED ? COOKIE_PERMISSION_MANAGER_POLICY_BLOCK : modalInfo->response); }
int main (int argc,char *argv[]) { Persona p; Familia f; open_file(&p,&f); make_tree(&f); set_position(&f); GtkWidget *window; GtkWidget *paned_container_horizontal; GtkWidget *paned_container_vertical; GtkWidget *fixed_container; GtkWidget *list_container; GtkWidget *drawing_area; GtkWidget *scroll_draw_zone; GtkWidget *scroll_tree_zone; GtkWidget *scroll_list_zone; GtkWidget *memberTextArea; GtkWidget *tree_box; GtkWidget *list_box; gtk_init (&argc, &argv); // Configuracion de Ventana main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); window = main_window; config_window(GTK_WINDOW(window),WIDTH,HEIGHT,"Arbol Genealogico",TRUE); // Configuracion de ventana que muestra los datos de las familias // Configuracion de Container paned_container_horizontal = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); paned_container_vertical = gtk_paned_new (GTK_ORIENTATION_VERTICAL); gtk_container_set_border_width (GTK_CONTAINER (window), 0); gtk_container_add (GTK_CONTAINER (window), paned_container_horizontal); fixed_container = gtk_fixed_new(); list_container = gtk_fixed_new(); drawing_area = gtk_drawing_area_new(); gtk_widget_set_size_request (GTK_WIDGET(drawing_area), 2000, 2000); scroll_draw_zone = gtk_scrolled_window_new(NULL, NULL); scroll_list_zone = gtk_scrolled_window_new(NULL, NULL); scroll_tree_zone = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_min_content_width (GTK_SCROLLED_WINDOW(scroll_draw_zone),800); gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW(scroll_draw_zone),600 - 50); gtk_fixed_put(GTK_FIXED(fixed_container), GTK_WIDGET(scroll_draw_zone), 0, 20); gtk_fixed_put(GTK_FIXED(list_container), GTK_WIDGET(scroll_draw_zone), 0, 0); // Se configura la caja que contiene a las familias tree_box = setup_tree("FAMILIAS"); add_family_to_list(tree_box,&f); // Se configura la caja que muestr a las personas list_box = setup_tree("PERSONAS"); add_member_to_list(list_box,&p); gtk_container_add(GTK_CONTAINER(scroll_draw_zone), GTK_WIDGET(drawing_area)); gtk_container_add(GTK_CONTAINER(scroll_tree_zone), GTK_WIDGET(tree_box)); gtk_container_add(GTK_CONTAINER(scroll_list_zone), GTK_WIDGET(list_box)); // Se agregan los elementos a la ventana gtk_paned_add1(GTK_PANED(paned_container_vertical),scroll_tree_zone); gtk_paned_add2(GTK_PANED(paned_container_vertical),scroll_list_zone); gtk_paned_add1(GTK_PANED(paned_container_horizontal),paned_container_vertical); gtk_paned_add2(GTK_PANED(paned_container_horizontal),fixed_container); // se conecta la senial "destroy" con la funcion gtk_main_quit g_signal_connect_swapped(G_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL); g_signal_connect(G_OBJECT(drawing_area), "draw", G_CALLBACK(draw_tree), &f); g_signal_connect(G_OBJECT(tree_box), "row-activated", G_CALLBACK(show_family_info),GTK_WINDOW(window)); g_signal_connect(G_OBJECT(list_box), "row-activated", G_CALLBACK(show_member_info),NULL); // los widget GTK estan escondidos por defecto, con esto los volvemos visibles gtk_widget_show_all (window); gtk_main (); return 0; }
GtkWidget * do_expander (GtkWidget *do_widget) { GtkWidget *toplevel; GtkWidget *area; GtkWidget *expander; GtkWidget *sw; GtkWidget *tv; GtkTextBuffer *buffer; if (!window) { toplevel = gtk_widget_get_toplevel (do_widget); window = gtk_message_dialog_new_with_markup (GTK_WINDOW (toplevel), 0, GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE, "<big><b>%s</b></big>", "Something went wrong"); gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (window), "Here are some more details " "but not the full story."); area = gtk_message_dialog_get_message_area (GTK_MESSAGE_DIALOG (window)); expander = gtk_expander_new ("Details:"); sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW (sw), 100); 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_AUTOMATIC); tv = gtk_text_view_new (); buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (tv)); gtk_text_view_set_editable (GTK_TEXT_VIEW (tv), FALSE); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (tv), GTK_WRAP_WORD); gtk_text_buffer_set_text (GTK_TEXT_BUFFER (buffer), "Finally, the full story with all details. " "And all the inside information, including " "error codes, etc etc. Pages of information, " "you might have to scroll down to read it all, " "or even resize the window - it works !\n" "A second paragraph will contain even more " "innuendo, just to make you scroll down or " "resize the window. Do it already !", -1); gtk_container_add (GTK_CONTAINER (sw), tv); gtk_container_add (GTK_CONTAINER (expander), sw); gtk_box_pack_end (GTK_BOX (area), expander); g_signal_connect (expander, "notify::expanded", G_CALLBACK (expander_cb), window); g_signal_connect (window, "response", G_CALLBACK (response_cb), NULL); } if (!gtk_widget_get_visible (window)) gtk_widget_show (window); else gtk_widget_destroy (window); return window; }
/**************************************************************** Creates spy's building sabotaging dialog *****************************************************************/ static void create_improvements_list(struct player *pplayer, struct city *pcity) { GtkWidget *sw, *label, *vbox, *view; GtkListStore *store; GtkCellRenderer *rend; GtkTreeViewColumn *col; GtkTreeIter it; spy_sabotage_shell = gtk_dialog_new_with_buttons(_("Sabotage Improvements"), NULL, 0, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, _("_Sabotage"), GTK_RESPONSE_ACCEPT, NULL); setup_dialog(spy_sabotage_shell, toplevel); gtk_window_set_position(GTK_WINDOW(spy_sabotage_shell), GTK_WIN_POS_MOUSE); gtk_dialog_set_default_response(GTK_DIALOG(spy_sabotage_shell), GTK_RESPONSE_ACCEPT); label = gtk_frame_new(_("Select Improvement to Sabotage")); gtk_container_add(GTK_CONTAINER(gtk_dialog_get_content_area(GTK_DIALOG(spy_sabotage_shell))), label); vbox = gtk_grid_new(); gtk_orientable_set_orientation(GTK_ORIENTABLE(vbox), GTK_ORIENTATION_VERTICAL); gtk_grid_set_row_spacing(GTK_GRID(vbox), 6); gtk_container_add(GTK_CONTAINER(label), vbox); store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT); view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store)); gtk_widget_set_hexpand(view, TRUE); gtk_widget_set_vexpand(view, TRUE); g_object_unref(store); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(view), FALSE); rend = gtk_cell_renderer_text_new(); col = gtk_tree_view_column_new_with_attributes(NULL, rend, "text", 0, NULL); gtk_tree_view_append_column(GTK_TREE_VIEW(view), col); label = g_object_new(GTK_TYPE_LABEL, "use-underline", TRUE, "mnemonic-widget", view, "label", _("_Improvements:"), "xalign", 0.0, "yalign", 0.5, NULL); gtk_container_add(GTK_CONTAINER(vbox), label); sw = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw), GTK_SHADOW_ETCHED_IN); gtk_container_add(GTK_CONTAINER(sw), view); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(sw), 200); gtk_container_add(GTK_CONTAINER(vbox), sw); /* Now populate the list */ gtk_list_store_append(store, &it); gtk_list_store_set(store, &it, 0, _("City Production"), 1, -1, -1); city_built_iterate(pcity, pimprove) { if (pimprove->sabotage > 0) { gtk_list_store_append(store, &it); gtk_list_store_set(store, &it, 0, city_improvement_name_translation(pcity, pimprove), 1, improvement_number(pimprove), -1); } } city_built_iterate_end; gtk_list_store_append(store, &it); { struct astring str = ASTRING_INIT; /* TRANS: %s is a unit name, e.g., Spy */ astr_set(&str, _("At %s's Discretion"), unit_name_translation(game_unit_by_number(diplomat_id))); gtk_list_store_set(store, &it, 0, astr_str(&str), 1, B_LAST, -1); astr_free(&str); } gtk_dialog_set_response_sensitive(GTK_DIALOG(spy_sabotage_shell), GTK_RESPONSE_ACCEPT, FALSE); gtk_widget_show_all(gtk_dialog_get_content_area(GTK_DIALOG(spy_sabotage_shell))); g_signal_connect(gtk_tree_view_get_selection(GTK_TREE_VIEW(view)), "changed", G_CALLBACK(spy_improvements_callback), NULL); g_signal_connect(spy_sabotage_shell, "response", G_CALLBACK(spy_improvements_response), NULL); sabotage_improvement = -2; gtk_tree_view_focus(GTK_TREE_VIEW(view)); }
void initGUI(int argc, char *argv[]) { gtk_init (&argc, &argv); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size(GTK_WINDOW (window), WINDOW_WIDTH, WINDOW_HEIGHT); gtk_window_set_title (GTK_WINDOW (window), "EECE 412 VPN"); g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); vBox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 1); clientServerModeHBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1); messageHBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1); serverDetailsHBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1); continueButtonsHBox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1); modeLabel = gtk_label_new("Mode:"); modeComboBox = gtk_combo_box_text_new(); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(modeComboBox), "Client"); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(modeComboBox), "Server"); gtk_combo_box_set_active(GTK_COMBO_BOX(modeComboBox), 0); messageLabel = gtk_label_new("Message:"); messageEntry = gtk_entry_new(); serverName = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(serverName), "127.0.0.1"); gtk_entry_set_max_length(GTK_ENTRY(serverName), 15); serverNameLabel = gtk_label_new("Server name:"); serverStatusButton = gtk_toggle_button_new_with_label("Start!"); clientStatusButton = gtk_toggle_button_new_with_label("Connect!"); portNumber = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(portNumber), "12000"); gtk_entry_set_max_length(GTK_ENTRY(portNumber), 5); portNumberLabel = gtk_label_new("Port:"); sharedKey = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(sharedKey), "SHAREDKEY"); sharedKeyLabel = gtk_label_new("Shared key:"); messageSendButton = gtk_button_new_with_label("Send"); continueButton = gtk_button_new_with_label("Continue"); autoContinueButton = gtk_toggle_button_new_with_label("Auto Continue"); scrolledAuthenticationWindow = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(scrolledAuthenticationWindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW(scrolledAuthenticationWindow), 200); scrolledEncryptedTextWindow = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(scrolledEncryptedTextWindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW(scrolledEncryptedTextWindow), 200); scrolledPlaintextWindow = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(scrolledPlaintextWindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW(scrolledPlaintextWindow), 200); authenticationTextLog = gtk_text_view_new(); gtk_text_view_set_editable(GTK_TEXT_VIEW(authenticationTextLog), FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(authenticationTextLog), FALSE); authenticationTextLogLabel = gtk_label_new("Authentication text:"); encryptedTextLog = gtk_text_view_new(); gtk_text_view_set_editable(GTK_TEXT_VIEW(encryptedTextLog), FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(encryptedTextLog), FALSE); encryptedTextLogLabel = gtk_label_new("Encrypted text:"); plainTextLog = gtk_text_view_new(); gtk_text_view_set_editable(GTK_TEXT_VIEW(plainTextLog), FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(plainTextLog), FALSE); plainTextLogLabel = gtk_label_new("Plain text:"); // SIGNALS g_signal_connect (modeComboBox, "changed", G_CALLBACK(onModeChanged), NULL); g_signal_connect (messageSendButton, "clicked", G_CALLBACK(onSendButtonClicked), NULL); g_signal_connect(serverStatusButton, "toggled", G_CALLBACK(onServerStatusChanged), NULL); g_signal_connect(clientStatusButton, "toggled", G_CALLBACK(onClientStatusChanged), NULL); g_signal_connect(continueButton, "clicked", G_CALLBACK(onContinuePressed), NULL); g_signal_connect(autoContinueButton, "toggled", G_CALLBACK(onAutoContinueStatusChanged), NULL); gtk_container_add (GTK_CONTAINER(window), vBox); gtk_box_pack_start (GTK_BOX(clientServerModeHBox), modeLabel, FALSE, TRUE, 1); gtk_box_pack_start (GTK_BOX(clientServerModeHBox), modeComboBox, TRUE, TRUE, 1); gtk_box_pack_start (GTK_BOX(serverDetailsHBox), serverNameLabel, FALSE, FALSE, 1); gtk_box_pack_start (GTK_BOX(serverDetailsHBox), serverName, TRUE, TRUE, 1); gtk_box_pack_start (GTK_BOX(serverDetailsHBox), portNumberLabel, FALSE, FALSE, 1); gtk_box_pack_start (GTK_BOX(serverDetailsHBox), portNumber, TRUE, TRUE, 1); gtk_box_pack_start (GTK_BOX(serverDetailsHBox), sharedKeyLabel, FALSE, FALSE, 1); gtk_box_pack_start (GTK_BOX(serverDetailsHBox), sharedKey, TRUE, TRUE, 1); gtk_box_pack_start (GTK_BOX(serverDetailsHBox), clientStatusButton, FALSE, FALSE, 1); gtk_box_pack_start (GTK_BOX(serverDetailsHBox), serverStatusButton, FALSE, FALSE, 1); gtk_box_pack_start (GTK_BOX(messageHBox), messageLabel, FALSE, FALSE, 1); gtk_box_pack_start (GTK_BOX(messageHBox), messageEntry, TRUE, TRUE, 1); gtk_box_pack_start (GTK_BOX(messageHBox), messageSendButton, FALSE, FALSE, 1); gtk_box_pack_start (GTK_BOX(continueButtonsHBox), continueButton, TRUE, TRUE, 1); gtk_box_pack_start (GTK_BOX(continueButtonsHBox), autoContinueButton, TRUE, TRUE, 1); gtk_container_add (GTK_CONTAINER(vBox), clientServerModeHBox); gtk_container_add (GTK_CONTAINER(vBox), serverDetailsHBox); gtk_container_add (GTK_CONTAINER(vBox), messageHBox); gtk_container_add (GTK_CONTAINER(vBox), continueButtonsHBox); gtk_container_add (GTK_CONTAINER(vBox), authenticationTextLogLabel); gtk_container_add(GTK_CONTAINER(scrolledAuthenticationWindow), authenticationTextLog); gtk_container_add (GTK_CONTAINER(vBox), scrolledAuthenticationWindow); gtk_container_add (GTK_CONTAINER(vBox), encryptedTextLogLabel); gtk_container_add(GTK_CONTAINER(scrolledEncryptedTextWindow), encryptedTextLog); gtk_container_add (GTK_CONTAINER(vBox), scrolledEncryptedTextWindow); gtk_container_add (GTK_CONTAINER(vBox), plainTextLogLabel); gtk_container_add(GTK_CONTAINER(scrolledPlaintextWindow), plainTextLog); gtk_container_add (GTK_CONTAINER(vBox), scrolledPlaintextWindow); gtk_widget_show_all (window); gtk_widget_hide(serverStatusButton); }
void gui_init(dt_lib_module_t *self) { dt_lib_styles_t *d = (dt_lib_styles_t *)malloc(sizeof(dt_lib_styles_t)); self->data = (void *)d; d->edit_button = NULL; self->widget = gtk_box_new(GTK_ORIENTATION_VERTICAL, 5); GtkWidget *w; GtkWidget *scrolled; /* list */ d->list = GTK_TREE_VIEW(gtk_tree_view_new()); gtk_tree_view_set_headers_visible(d->list, FALSE); GtkListStore *liststore = gtk_list_store_new(DT_STYLES_NUM_COLS, G_TYPE_STRING, G_TYPE_STRING); GtkTreeViewColumn *col = gtk_tree_view_column_new(); gtk_tree_view_append_column(GTK_TREE_VIEW(d->list), col); GtkCellRenderer *renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, renderer, TRUE); gtk_tree_view_column_add_attribute(col, renderer, "text", DT_STYLES_COL_NAME); gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(d->list)), GTK_SELECTION_SINGLE); gtk_tree_view_set_model(GTK_TREE_VIEW(d->list), GTK_TREE_MODEL(liststore)); g_object_unref(liststore); g_object_set(G_OBJECT(d->list), "tooltip-text", _("available styles,\ndoubleclick to apply"), (char *)NULL); g_signal_connect(d->list, "row-activated", G_CALLBACK(_styles_row_activated_callback), d); /* filter entry */ w = gtk_entry_new(); d->entry = GTK_ENTRY(w); g_object_set(G_OBJECT(w), "tooltip-text", _("enter style name"), (char *)NULL); g_signal_connect(d->entry, "changed", G_CALLBACK(entry_callback), d); g_signal_connect(d->entry, "activate", G_CALLBACK(entry_activated), d); dt_gui_key_accel_block_on_focus_connect(GTK_WIDGET(d->entry)); scrolled = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(scrolled), DT_PIXEL_APPLY_DPI(150)); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(d->entry), TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(scrolled), TRUE, FALSE, 0); gtk_container_add(GTK_CONTAINER(scrolled), GTK_WIDGET(d->list)); d->duplicate = gtk_check_button_new_with_label(_("create duplicate")); gtk_box_pack_start(GTK_BOX(self->widget), GTK_WIDGET(d->duplicate), TRUE, FALSE, 0); g_signal_connect(d->duplicate, "toggled", G_CALLBACK(duplicate_callback), d); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(d->duplicate), dt_conf_get_bool("ui_last/styles_create_duplicate")); g_object_set(d->duplicate, "tooltip-text", _("creates a duplicate of the image before applying style"), (char *)NULL); GtkWidget *hbox1 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); GtkWidget *hbox2 = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 5); gtk_box_pack_start(GTK_BOX(self->widget), hbox1, TRUE, FALSE, 0); gtk_box_pack_start(GTK_BOX(self->widget), hbox2, TRUE, FALSE, 0); // create GtkWidget *cbutton = gtk_button_new_with_label(_("create")); g_signal_connect(G_OBJECT(cbutton), "clicked", G_CALLBACK(create_clicked), d); g_object_set(G_OBJECT(cbutton), "tooltip-text", _("create styles from history stack of selected images"), (char *)NULL); gtk_box_pack_start(GTK_BOX(hbox1), cbutton, TRUE, TRUE, 0); // edit GtkWidget *widget = gtk_button_new_with_label(_("edit")); d->edit_button = widget; g_signal_connect(widget, "clicked", G_CALLBACK(edit_clicked), d); g_object_set(widget, "tooltip-text", _("edit the selected style in list above"), (char *)NULL); gtk_box_pack_start(GTK_BOX(hbox1), widget, TRUE, TRUE, 0); // delete widget = gtk_button_new_with_label(_("delete")); d->delete_button = widget; g_signal_connect(widget, "clicked", G_CALLBACK(delete_clicked), d); g_object_set(widget, "tooltip-text", _("deletes the selected style in list above"), (char *)NULL); gtk_box_pack_start(GTK_BOX(hbox1), widget, TRUE, TRUE, 0); // import button GtkWidget *importButton = gtk_button_new_with_label(C_("styles", "import")); d->import_button = importButton; g_object_set(importButton, "tooltip-text", _("import style from a style file"), (char *)NULL); g_signal_connect(importButton, "clicked", G_CALLBACK(import_clicked), d); gtk_box_pack_start(GTK_BOX(hbox2), importButton, TRUE, TRUE, 0); // export button GtkWidget *exportButton = gtk_button_new_with_label(_("export")); d->export_button = exportButton; g_object_set(exportButton, "tooltip-text", _("export the selected style into a style file"), (char *)NULL); g_signal_connect(exportButton, "clicked", G_CALLBACK(export_clicked), d); gtk_box_pack_start(GTK_BOX(hbox2), exportButton, TRUE, TRUE, 0); // add entry completion GtkEntryCompletion *completion = gtk_entry_completion_new(); gtk_entry_completion_set_model(completion, gtk_tree_view_get_model(GTK_TREE_VIEW(d->list))); gtk_entry_completion_set_text_column(completion, 0); gtk_entry_completion_set_inline_completion(completion, TRUE); gtk_entry_set_completion(d->entry, completion); /* update filtered list */ _gui_styles_update_view(d); }
/* Object initialization * Create private structure and set up default values */ static void nojs_preferences_init(NoJSPreferences *self) { NoJSPreferencesPrivate *priv; GtkTreeSortable *sortableList; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkWidget *widget; gchar *dialogTitle; GtkWidget *scrolled; GtkWidget *vbox; GtkWidget *hbox; gint width, height; GtkListStore *list; GtkTreeIter listIter; priv=self->priv=NOJS_PREFERENCES_GET_PRIVATE(self); /* Set up default values */ priv->manager=NULL; /* Get content area to add gui controls to */ priv->contentArea=gtk_dialog_get_content_area(GTK_DIALOG(self)); #if GTK_CHECK_VERSION (3, 0, 0) vbox=gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_box_set_homogeneous(GTK_BOX(vbox), FALSE); #else vbox=gtk_vbox_new(FALSE, 0); #endif /* Set up dialog */ dialogTitle=_("Configure NoJS"); gtk_window_set_title(GTK_WINDOW(self), dialogTitle); gtk_window_set_icon_name(GTK_WINDOW(self), GTK_STOCK_PROPERTIES); sokoke_widget_get_text_size(GTK_WIDGET(self), "M", &width, &height); gtk_window_set_default_size(GTK_WINDOW(self), width*52, -1); widget=sokoke_xfce_header_new(gtk_window_get_icon_name(GTK_WINDOW(self)), dialogTitle); if(widget) gtk_box_pack_start(GTK_BOX(priv->contentArea), widget, FALSE, FALSE, 0); gtk_dialog_add_button(GTK_DIALOG(self), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE); /* Set up description */ widget=gtk_label_new(NULL); gtk_label_set_markup(GTK_LABEL(widget), _("Below is a list of all web sites and the policy set for them. " "You can delete policies by marking the entries and clicking on <i>Delete</i>.")); gtk_label_set_line_wrap(GTK_LABEL(widget), TRUE); gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 4); /* Set up domain list */ priv->listStore=gtk_list_store_new(N_COLUMN, G_TYPE_STRING, /* DOMAIN_COLUMN */ G_TYPE_STRING /* POLICY_COLUMN */); sortableList=GTK_TREE_SORTABLE(priv->listStore); gtk_tree_sortable_set_sort_func(sortableList, DOMAIN_COLUMN, (GtkTreeIterCompareFunc)_nojs_preferences_sort_string_callback, GINT_TO_POINTER(DOMAIN_COLUMN), NULL); gtk_tree_sortable_set_sort_func(sortableList, POLICY_COLUMN, (GtkTreeIterCompareFunc)_nojs_preferences_sort_string_callback, GINT_TO_POINTER(POLICY_COLUMN), NULL); gtk_tree_sortable_set_sort_column_id(sortableList, DOMAIN_COLUMN, GTK_SORT_ASCENDING); /* Set up domain addition widgets */ #ifdef HAVE_GTK3 hbox=gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_set_homogeneous(GTK_BOX(hbox), FALSE); #else hbox=gtk_hbox_new(FALSE, 0); #endif priv->addDomainEntry=gtk_entry_new(); gtk_entry_set_max_length(GTK_ENTRY(priv->addDomainEntry), 64); gtk_container_add(GTK_CONTAINER(hbox), priv->addDomainEntry); g_signal_connect_swapped(priv->addDomainEntry, "changed", G_CALLBACK(_nojs_preferences_on_add_domain_entry_changed), self); list=gtk_list_store_new(2, G_TYPE_INT, G_TYPE_STRING); gtk_list_store_append(list, &listIter); gtk_list_store_set(list, &listIter, 0, NOJS_POLICY_ACCEPT, 1, _("Accept"), -1); gtk_list_store_append(list, &listIter); gtk_list_store_set(list, &listIter, 0, NOJS_POLICY_ACCEPT_TEMPORARILY, 1, _("Accept for session"), -1); gtk_list_store_append(list, &listIter); gtk_list_store_set(list, &listIter, 0, NOJS_POLICY_BLOCK, 1, _("Block"), -1); priv->addDomainPolicyCombo=gtk_combo_box_new_with_model(GTK_TREE_MODEL(list)); gtk_combo_box_set_active(GTK_COMBO_BOX(priv->addDomainPolicyCombo), 0); gtk_container_add(GTK_CONTAINER(hbox), priv->addDomainPolicyCombo); renderer=gtk_cell_renderer_text_new(); gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(priv->addDomainPolicyCombo), renderer, TRUE); gtk_cell_layout_add_attribute(GTK_CELL_LAYOUT(priv->addDomainPolicyCombo), renderer, "text", 1); priv->addDomainButton=gtk_button_new_from_stock(GTK_STOCK_ADD); gtk_widget_set_sensitive(priv->addDomainButton, FALSE); gtk_container_add(GTK_CONTAINER(hbox), priv->addDomainButton); g_signal_connect_swapped(priv->addDomainButton, "clicked", G_CALLBACK(_nojs_preferences_on_add_domain_clicked), self); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 5); /* Set up domain list view */ priv->list=gtk_tree_view_new_with_model(GTK_TREE_MODEL(priv->listStore)); #if !GTK_CHECK_VERSION (3, 0, 0) gtk_widget_set_size_request(priv->list, -1, 300); #endif priv->listSelection=gtk_tree_view_get_selection(GTK_TREE_VIEW(priv->list)); gtk_tree_selection_set_mode(priv->listSelection, GTK_SELECTION_MULTIPLE); g_signal_connect_swapped(priv->listSelection, "changed", G_CALLBACK(_nojs_preferences_changed_selection), self); renderer=gtk_cell_renderer_text_new(); column=gtk_tree_view_column_new_with_attributes(_("Domain"), renderer, "text", DOMAIN_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, DOMAIN_COLUMN); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->list), column); renderer=gtk_cell_renderer_combo_new(); g_object_set(G_OBJECT(renderer), "model", list, "text-column", 1, "has-entry", false, "editable", true, NULL); g_signal_connect_swapped(renderer, "editing-started", G_CALLBACK(_nojs_preferences_on_policy_editing_started), self); g_signal_connect_swapped(renderer, "editing-canceled", G_CALLBACK(_nojs_preferences_on_policy_editing_canceled), self); g_signal_connect_swapped(renderer, "edited", G_CALLBACK(_nojs_preferences_on_policy_edited), self); column=gtk_tree_view_column_new_with_attributes(_("Policy"), renderer, "text", POLICY_COLUMN, NULL); gtk_tree_view_column_set_sort_column_id(column, POLICY_COLUMN); gtk_tree_view_append_column(GTK_TREE_VIEW(priv->list), column); scrolled=gtk_scrolled_window_new(NULL, NULL); #if GTK_CHECK_VERSION (3, 0, 0) gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(scrolled), height*10); #endif gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(scrolled), priv->list); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrolled), GTK_SHADOW_IN); gtk_box_pack_start(GTK_BOX(vbox), scrolled, TRUE, TRUE, 5); /* Set up JavaScript domain list management buttons */ #if GTK_CHECK_VERSION (3, 0, 0) hbox=gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_set_homogeneous(GTK_BOX(hbox), FALSE); #else hbox=gtk_hbox_new(FALSE, 0); #endif priv->deleteButton=gtk_button_new_from_stock(GTK_STOCK_DELETE); gtk_widget_set_sensitive(priv->deleteButton, FALSE); gtk_container_add(GTK_CONTAINER(hbox), priv->deleteButton); g_signal_connect_swapped(priv->deleteButton, "clicked", G_CALLBACK(_nojs_preferences_on_delete_selection), self); priv->deleteAllButton=gtk_button_new_with_mnemonic(_("Delete _all")); gtk_button_set_image(GTK_BUTTON(priv->deleteAllButton), gtk_image_new_from_stock(GTK_STOCK_DELETE, GTK_ICON_SIZE_BUTTON)); gtk_widget_set_sensitive(priv->deleteAllButton, FALSE); gtk_container_add(GTK_CONTAINER(hbox), priv->deleteAllButton); g_signal_connect_swapped(priv->deleteAllButton, "clicked", G_CALLBACK(_nojs_preferences_on_delete_all), self); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 5); /* Add "allow-all-sites" checkbox */ priv->allowAllSitesCheckbox=gtk_check_button_new_with_mnemonic(_("A_llow scripts at all sites")); priv->signalAllowAllSitesToggledID=g_signal_connect_swapped(priv->allowAllSitesCheckbox, "toggled", G_CALLBACK(_nojs_preferences_on_allow_all_sites_changed), self); gtk_box_pack_start(GTK_BOX(vbox), priv->allowAllSitesCheckbox, FALSE, TRUE, 5); /* Add "block-unknown-domains" checkbox */ priv->blockUnknownDomainsCheckbox=gtk_check_button_new_with_mnemonic(_("Bloc_k scripts at unknown domains by default")); priv->signalBlockUnknownDomainsToggledID=g_signal_connect_swapped(priv->blockUnknownDomainsCheckbox, "toggled", G_CALLBACK(_nojs_preferences_on_block_unknown_domains_changed), self); gtk_box_pack_start(GTK_BOX(vbox), priv->blockUnknownDomainsCheckbox, FALSE, TRUE, 5); /* Add "check-second-level-only" checkbox */ priv->checkSecondLevelOnlyCheckbox=gtk_check_button_new_with_mnemonic(_("S_et permissions on second-level domain")); priv->signalCheckSecondLevelOnlyToggledID=g_signal_connect_swapped(priv->checkSecondLevelOnlyCheckbox, "toggled", G_CALLBACK(_nojs_preferences_on_check_second_level_only_changed), self); gtk_box_pack_start(GTK_BOX(vbox), priv->checkSecondLevelOnlyCheckbox, FALSE, TRUE, 5); /* Finalize setup of content area */ gtk_box_pack_start(GTK_BOX(priv->contentArea), vbox, TRUE, TRUE, 0); }
int main(int argc, char ** argv) { GtkWidget * vbox; GtkWidget * hpaned; GtkWidget * sc_win, * sc_buffer; GtkWidget * menu_bar; GtkWidget * file_menu, * file_item, * open_item, * save_item, * quit_item, * exp_img_item, * save_raw_data_item; GtkWidget * generate_menu, * generate_item, * mandelbrot_item, * julia_item, * palette_item, * random_noise_item, * from_clipboard_item; GtkWidget * settings_menu, * settings_item; GtkWidget * zoom_box, * zoom_button; //init general colors = (color_t *)malloc(56 * sizeof(color_t)); memset(mdata, 0, BUFFER_COUNT * sizeof(unsigned char *)); memset(icons, 0, BUFFER_COUNT * sizeof(GtkWidget *)); memset(icon_event_boxes, 0, BUFFER_COUNT * sizeof(GtkWidget *)); mdata[current_buffer] = (unsigned char *)malloc(128 * 128); char * templine = malloc(13); FILE * fcolors = fopen("colors", "r"); int i, r, g, b; for(i = 0; fgets(templine, 13, fcolors) == templine; i++) { sscanf(templine, "%i,%i,%i", &r, &g, &b); color_t color = {r, g, b}; colors[i] = color; } free(templine); fclose(fcolors); save_colors(colors, "colors.bin"); //load_colors(colors, "colors.bin"); srand(time(NULL)); config = config_new(); //init gtk gtk_init(&argc, &argv); //window window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(window), "ImageToMap X v" VERSION_NUMBER); g_signal_connect(window, "delete_event", G_CALLBACK(kill_window), NULL); //vbox #ifdef GTK2 vbox = gtk_vbox_new(FALSE, 0); #else vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); #endif gtk_container_add(GTK_CONTAINER (window), vbox); gtk_widget_show(vbox); //////menu_bar menu_bar = gtk_menu_bar_new(); gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, TRUE, 0); gtk_widget_show(menu_bar); ////////file_menu file_menu = gtk_menu_new(); //////////open_item open_item = gtk_menu_item_new_with_label("Open"); gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), open_item); gtk_widget_show(open_item); g_signal_connect_swapped (open_item, "activate", G_CALLBACK (button_click), (gpointer) "button.open"); //////////save_item save_item = gtk_menu_item_new_with_label("Save"); gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), save_item); gtk_widget_show(save_item); g_signal_connect_swapped (save_item, "activate", G_CALLBACK (button_click), (gpointer) "button.save"); //////////save_raw_data_item save_raw_data_item = gtk_menu_item_new_with_label("Save Raw Map"); gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), save_raw_data_item); gtk_widget_show(save_raw_data_item); g_signal_connect_swapped (save_raw_data_item, "activate", G_CALLBACK (button_click), (gpointer) "button.save_rm"); //////////exp_img_item exp_img_item = gtk_menu_item_new_with_label("Export Image"); gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), exp_img_item); gtk_widget_show(exp_img_item); g_signal_connect_swapped(exp_img_item, "activate", G_CALLBACK (button_click), (gpointer) "button.exp_img"); //////////quit_item quit_item = gtk_menu_item_new_with_label("Quit"); gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), quit_item); gtk_widget_show(quit_item); g_signal_connect_swapped (quit_item, "activate", G_CALLBACK(kill_window), (gpointer)"button.quit"); /////////file_item file_item = gtk_menu_item_new_with_label("File"); gtk_widget_show(file_item); gtk_menu_item_set_submenu(GTK_MENU_ITEM(file_item), file_menu); gtk_menu_shell_append((GtkMenuShell *)menu_bar, file_item); ////////generate_menu generate_menu = gtk_menu_new(); //////////mandelbrot_item mandelbrot_item = gtk_menu_item_new_with_label("Mandelbrot"); gtk_menu_shell_append(GTK_MENU_SHELL(generate_menu), mandelbrot_item); gtk_widget_show(mandelbrot_item); g_signal_connect_swapped(mandelbrot_item, "activate", G_CALLBACK(button_click), (gpointer) "button.mandelbrot"); //////////julia_item julia_item = gtk_menu_item_new_with_label("Julia"); gtk_menu_shell_append(GTK_MENU_SHELL(generate_menu), julia_item); gtk_widget_show(julia_item); g_signal_connect_swapped(julia_item, "activate", G_CALLBACK (button_click), (gpointer) "button.julia"); //////////palette_item palette_item = gtk_menu_item_new_with_label("Palette"); gtk_menu_shell_append(GTK_MENU_SHELL(generate_menu), palette_item); gtk_widget_show(palette_item); g_signal_connect_swapped(palette_item, "activate", G_CALLBACK(button_click), (gpointer)"button.palette"); //////////random_noise_item random_noise_item = gtk_menu_item_new_with_label("Random Noise"); gtk_menu_shell_append(GTK_MENU_SHELL(generate_menu), random_noise_item); gtk_widget_show(random_noise_item); g_signal_connect_swapped(random_noise_item, "activate", G_CALLBACK(button_click), (gpointer)"button.random_noise"); //////////from_clipboard_item from_clipboard_item = gtk_menu_item_new_with_label("From Clipboard"); gtk_menu_shell_append(GTK_MENU_SHELL(generate_menu), from_clipboard_item); gtk_widget_show(from_clipboard_item); g_signal_connect_swapped(from_clipboard_item, "activate", G_CALLBACK(button_click), (gpointer)"button.from_clipboard"); /////////generate_item generate_item = gtk_menu_item_new_with_label("Generate"); gtk_widget_show(generate_item); gtk_menu_item_set_submenu(GTK_MENU_ITEM(generate_item), generate_menu); gtk_menu_shell_append((GtkMenuShell *)menu_bar, generate_item); ////////settings_menu settings_menu = gtk_menu_new(); ////////settings_item settings_item = gtk_menu_item_new_with_label("Settings"); gtk_widget_show(settings_item); gtk_menu_item_set_submenu(GTK_MENU_ITEM(settings_item), settings_menu); gtk_menu_shell_append((GtkMenuShell *)menu_bar, settings_item); //////////FSD_checkbox FSD_checkbox = gtk_check_menu_item_new_with_label("Floyd–Steinberg dithering"); gtk_menu_shell_append(GTK_MENU_SHELL(settings_menu), FSD_checkbox); gtk_widget_show(FSD_checkbox); //drop_down_menu init_drop_down_menu(); //hpaned #ifdef GTK2 hpaned = gtk_hpaned_new(); #else hpaned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL); #endif gtk_widget_set_size_request (hpaned, 220, -1); gtk_box_pack_start(GTK_BOX(vbox), hpaned, TRUE, TRUE, 0); gtk_widget_show(hpaned); ////sc_buffer sc_buffer = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sc_buffer), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); #ifdef GTK2 gtk_widget_set_size_request(sc_buffer, 128 + 32, 512); #else gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(sc_buffer), 128 + 32); gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(sc_buffer), 512); #endif gtk_paned_pack2(GTK_PANED(hpaned), sc_buffer, FALSE, FALSE); gtk_widget_show(sc_buffer); //////list_vbox #ifdef GTK2 list_vbox = gtk_vbox_new(FALSE, 0); #else list_vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); #endif gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sc_buffer), list_vbox); gtk_widget_show(list_vbox); ////sc_win sc_win = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sc_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); #ifdef GTK2 gtk_widget_set_size_request(sc_win, 128 * 4, 128 * 4); gtk_window_resize(GTK_WINDOW(window), 128 * 4 + 200, 128 * 4 + 70); #else gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(sc_win), 128 * 4); gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(sc_win), 128 * 4); #endif gtk_paned_pack1(GTK_PANED(hpaned), sc_win, TRUE, FALSE); gtk_widget_show(sc_win); //////image dimage = gdk_pixbuf_new_from_file("start.png", NULL); image = gtk_image_new(); gtk_image_set_from_pixbuf(GTK_IMAGE(image), dimage); gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sc_win), image); gtk_widget_show(image); ////zoom_box #ifdef GTK2 zoom_box = gtk_hbox_new(FALSE, 0); #else zoom_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); #endif gtk_box_pack_start(GTK_BOX(vbox), zoom_box, FALSE, FALSE, 0); gtk_widget_show(zoom_box); //////zoom_button (+) zoom_button = gtk_button_new_with_label("+"); gtk_box_pack_start(GTK_BOX(zoom_box), zoom_button, TRUE, TRUE, 2); g_signal_connect(zoom_button, "clicked", G_CALLBACK(button_click2), "button.zoomp"); gtk_widget_show(zoom_button); //////zoom_button (|) zoom_button = gtk_button_new_with_label("|"); gtk_box_pack_start(GTK_BOX(zoom_box), zoom_button, TRUE, TRUE, 2); g_signal_connect(zoom_button, "clicked", G_CALLBACK(button_click2), "button.zoome"); gtk_widget_show(zoom_button); //////zoom_button (-) zoom_button = gtk_button_new_with_label("-"); gtk_box_pack_start(GTK_BOX(zoom_box), zoom_button, TRUE, TRUE, 2); g_signal_connect(zoom_button, "clicked", G_CALLBACK(button_click2), "button.zoomm"); gtk_widget_show(zoom_button); //icon gtk_window_set_icon(GTK_WINDOW(window), create_pixbuf("imagetomap.ico")); //display window gtk_widget_show (window); gtk_main(); //clean up free(colors); for(i = 0; i < BUFFER_COUNT; i++) free(mdata[i]); config_free(config); return 0; }
void toolbar2___::with__(window___* w, void*shangji,void*ce,deque<string>* p, int addr_fmt, char*buf) { toolbar2_item___* item; if((*p)[1] == toolbar2_tag2_) { init__(w->box2__(), left_icon_item_); item = left_icon_item_; } else if((*p)[1] == toolbar2_tag3_) { init__(w->box2__(), tree_item_); item = tree_item_; } else if((*p)[1] == toolbar2_tag4_) { init__(w->box3__(), right_icon_item_); item = right_icon_item_; } else if((*p)[1] == toolbar2_tag5_) { init__(w->box4__(), bottom_icon_item_); item = bottom_icon_item_; } else if((*p)[1] == toolbar2_tag6_) { init__(w->box3__(), right_tree_item_); item = right_tree_item_; } else { init__(w->box__(), icon_item_); item = icon_item_; } for(size_t i2=2;i2<p->size();i2++){ const string& p2=(*p)[i2]; if(p2 == "选择") { GtkTreeModel *m = item->model__(); GtkTreeIter i; GtkTreePath *path; for(size_t i3 = i2;i3 < p->size() - 1;) { int id2 = 0; if(!set__(i3, p, id2)) return; if(!iter_by_id__(m, id2, &i)) { buzhichi__(i3, p); return; } switch(item->tag_) { case 'i': path = gtk_tree_model_get_path (m, &i); gtk_icon_view_select_path (item->icon_view__(), path); gtk_tree_path_free (path); break; } } return; } if(p2 == "遍历") { if(buzu__(++i2, p)) return; item->for__((*p)[i2], ce, shangji); continue; } if(p2 == "设") { int id = 0; if(!set__(i2, p, id)) return; callback_item___* cbi = callback_item__(id); if(!cbi) { wufa__(p->size(), p); return; } GtkTreeModel *m = item->model__(); GtkTreeIter i; for(i2++; i2 < p->size(); i2++) { const string& p3 = (*p)[i2]; if(p3 == "名") { if(set__(i2, p, cbi->title_)) { if(!iter_by_id__(m, cbi->id_, &i)) { buzhichi__(i2, p); return; } switch(item->tag_) { case 'i': gtk_list_store_set(((icon_item___*)item)->store_, &i, TITLE_COLUMN, cbi->title_.c_str(), -1); continue; } } return; } if(p3 == "提示") {if(set__(i2, p, cbi->tooltip_)) continue; return;} if(p3 == "图标") { string name; if(!set__(i2, p, name)) return; GdkPixbuf *pixbuf = item->get_icon__(name); switch(item->tag_) { case 'i': gtk_list_store_set(((icon_item___*)item)->store_, &i, PIXBUF_COLUMN, pixbuf, -1); break; } g_object_unref (pixbuf); continue; } buzhichi__(i2, p); } break; } if(p2 == "获取") { string code3; if(!set__(i2, p, code3)) return; switch(item->tag_) { case 'i': icon_view_select__(item->icon_view__(), code3.c_str(), shangji, ce); break; } continue; } #ifdef ver_gtk3_ if(p2 == "宽") { if(buzu__(++i2, p)) return; gtk_scrolled_window_set_min_content_width(item->scrolled__(), s2i__((*p)[i2])); continue; } if(p2 == "高") { if(buzu__(++i2, p)) return; gtk_scrolled_window_set_min_content_height(item->scrolled__(), s2i__((*p)[i2])); continue; } #endif if(p2 == "名") { if(buzu__(++i2, p)) return; if(item->label_) { gtk_label_set_markup(GTK_LABEL(item->label_), (*p)[i2].c_str()); } continue; } if(p2 == "钮宽") {if(set__(i2, p, item->btn_width_)) continue; return;} if(p2 == "钮高") {if(set__(i2, p, item->btn_height_)) continue; return;} if(p2 == "名提示") {item->title_tooltip_ = true; continue;} if(p2 == "可拖动") { switch(item->tag_) { case 'i': gtk_icon_view_set_reorderable(item->icon_view__(), true); break; case 't': gtk_tree_view_set_reorderable(item->tree_view__(), true); break; } continue; } if(p2 == "可选择") { int i; if(!set__(i2, p, i)) return; switch(item->tag_) { case 'i': gtk_icon_view_set_selection_mode(item->icon_view__(), (GtkSelectionMode)i); break; } continue; } if(p2 == "无标题") { if(item->tag_ == 'i') { //gtk_icon_view_set_text_column (item->icon_view__(), -1); gtk_icon_view_set_markup_column (item->icon_view__(), -1); continue; } buzhichi__(i2, p); return; } //gtk_icon_view_set_selection_mode (iconview__(), GTK_SELECTION_MULTIPLE); if(p2 == "列头") { if(buzu__(++i2, p)) return; if(item->tag_ == 't') { tree_item___* ti = (tree_item___*)item; gtk_tree_view_column_set_title(ti->col_, (*p)[i2].c_str()); continue; } buzhichi__(i2, p); return; } if(p2 == "删钮") { GtkTreeModel *m = item->model__(); GtkTreeIter i; for(size_t i3 = i2;i3 < p->size() - 1;) { int id2 = 0; if(!set__(i3, p, id2)) return; if(!iter_by_id__(m, id2, &i)) { buzhichi__(i3, p); return; } item->store_del__(&i); } break; } if(p2 == "加钮") { string title, tooltip, code, arg, code2, arg2, code3_2; string set_up; int posi = -1; for(i2++;i2<p->size();i2++){ const string& p3=(*p)[i2]; if(p3 == "名") {if(set__(i2, p, title)) continue; return;} if(p3 == "提示") {if(set__(i2, p, tooltip)) continue; return;} if(p3 == "代码") {if(set__(i2, p, code)) continue; return;} if(p3 == "附") {if(set__(i2, p, arg)) continue; return;} if(p3 == "位置") {if(set__(i2, p, posi)) continue; return;} if(p3 == "缺省代码") {if(set__(i2, p, item->def_code_)) continue; return;} if(p3 == "缺省附") {if(set__(i2, p, item->def_arg_)) continue; return;} if(p3 == "双击代码") {if(set__(i2, p, code2)) continue; return;} if(p3 == "双击附") {if(set__(i2, p, arg2)) continue; return;} if(p3 == "缺省双击代码") {if(set__(i2, p, item->def_code2_)) continue; return;} if(p3 == "缺省双击附") {if(set__(i2, p, item->def_arg2_)) continue; return;} if(p3 == "右击代码") {if(set__(i2, p, code3_2)) continue; return;} if(p3 == "缺省右击代码") {if(set__(i2, p, item->def_code3_2_)) continue; return;} if(p3 == "设置上") {if(set__(i2, p, set_up)) continue; return;} if(p3 == "恢复上") { if(item->tag_ == 't') { string restore_up; if(set__(i2, p, restore_up)) { int err; const char* ret = call4__(ce, restore_up, shangji, 0, NULL, &err); if(err) return; ((tree_item___*)item)->up_ = ret; } } else { buzhichi__(i2, p); } return; } if(p3 == "大小") { if(buzu__(++i2, p)) return; item->btn_width_ = item->btn_height_ = s2i__((*p)[i2]) * 8; continue; } if(p3 == "-") continue; GdkPixbuf *pixbuf = item->get_icon__(p3); callback_item___* si = new callback_item___(title, !code.empty() ? code : item->def_code_, !arg.empty() ? arg : item->def_arg_, tooltip.empty() && item->title_tooltip_ ? title : tooltip); si->add_code__(!code2.empty() ? code2 : item->def_code2_); si->add_arg__(!arg2.empty() ? arg2 : item->def_arg2_); si->add_code__(!code3_2.empty() ? code3_2 : item->def_code3_2_); item->store_add__(si, pixbuf, posi); g_object_unref (pixbuf); if(!set_up.empty()) { if(item->tag_ == 't') { tree_item___* ti = (tree_item___*)item; const char* argv[] = {ti->up_.c_str()}; int err; call4__(ce, set_up, shangji, 1, argv, &err); if(err) return; ti->up_ = ti->last_; } else { buzhichi__(i2, p); return; } set_up.clear(); } code.clear(); arg.clear(); tooltip.clear(); code2.clear(); arg2.clear(); code3_2.clear(); posi = -1; } break; } if(p2 == "清空") { switch(item->tag_) { case 'i': gtk_list_store_clear (((icon_item___*)item)->store_); continue; } } if(p2 == "地址") { if(addr_fmt == 16) l2x__((long)item->scrolled_, buf); else l2s__((long)item->scrolled_, buf); continue; } buzhichi__(i2, p); return; } }
// part_browser_create // // Creates a new part browser. This is only called once per schematic window. GtkWidget * part_browser_create (SchematicView *schematic_view) { Browser *br; GtkBuilder *gui; GError *perror = NULL; char *msg; GtkWidget *w, *view; GtkCellRenderer *cell_text; GtkTreeViewColumn *cell_column; static GtkTargetEntry dnd_types[] = { { "x-application/oregano-part", 0, DRAG_PART_INFO } }; static int dnd_num_types = sizeof (dnd_types) / sizeof (dnd_types[0]); GtkTreePath *path; if ((gui = gtk_builder_new ()) == NULL) { oregano_error (_("Could not create part browser")); return NULL; } else gtk_builder_set_translation_domain (gui, NULL); br = g_new0 (Browser, 1); br->preview = NULL; br->schematic_view = schematic_view; br->hidden = FALSE; schematic_view_set_browser (schematic_view, br); if (gtk_builder_add_from_file (gui, OREGANO_UIDIR "/part-browser.ui", &perror) <= 0) { msg = perror->message; oregano_error_with_title (_("Could not create part browser"), msg); g_error_free (perror); return NULL; } view = GTK_WIDGET (gtk_builder_get_object (gui, "viewport1")); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (view), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW (view), 115); w = goo_canvas_new (); gtk_container_add (GTK_CONTAINER (view), GTK_WIDGET (w)); br->canvas = w; g_signal_connect (w, "realize", (GCallback) preview_realized, br); //gtk_widget_set_size_request (w, PREVIEW_WIDTH, // PREVIEW_HEIGHT + PREVIEW_TEXT_HEIGHT); goo_canvas_set_bounds (GOO_CANVAS (w), 0, 0, PREVIEW_WIDTH, (PREVIEW_HEIGHT + PREVIEW_TEXT_HEIGHT)); br->description = GOO_CANVAS_TEXT (goo_canvas_text_new ( goo_canvas_get_root_item (GOO_CANVAS (br->canvas)), "", 0.0, PREVIEW_HEIGHT - 9.0, 100.0, GOO_CANVAS_ANCHOR_NORTH_WEST, "font", "sans 9", NULL)); // Set up dnd. g_signal_connect (G_OBJECT (br->canvas), "drag_data_get", G_CALLBACK (drag_data_get), br); gtk_drag_source_set (br->canvas, GDK_BUTTON1_MASK | GDK_BUTTON3_MASK, dnd_types, dnd_num_types, GDK_ACTION_MOVE); br->filter_entry = GTK_ENTRY (gtk_builder_get_object (gui, "part_search")); g_signal_connect (G_OBJECT (br->filter_entry), "changed", G_CALLBACK (part_search_change), br); g_signal_connect (G_OBJECT (br->filter_entry), "activate", G_CALLBACK (part_search_activate), br); // Buttons. w = GTK_WIDGET (gtk_builder_get_object (gui, "place_button")); g_signal_connect (G_OBJECT (w), "clicked", G_CALLBACK (place_cmd), br); // Update the libraries option menu br->library = g_list_nth_data (oregano.libraries, 0); part_browser_setup_libs (br, gui); // Parts list. w = GTK_WIDGET (gtk_builder_get_object (gui, "parts_list")); br->list = w; // Create the List Model for TreeView, this is a Real model br->real_model = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_STRING)); cell_text = gtk_cell_renderer_text_new (); cell_column = gtk_tree_view_column_new_with_attributes ( "", cell_text, "text", 0, NULL); // Create the sort model for the items, this sort the real model br->sort_model = gtk_tree_model_sort_new_with_model ( GTK_TREE_MODEL (br->real_model)); gtk_tree_sortable_set_sort_column_id ( GTK_TREE_SORTABLE (br->sort_model), 0, GTK_SORT_ASCENDING); // Create the filter sorted model. This filter items based on user // request for fast item search br->filter_model = gtk_tree_model_filter_new (br->sort_model, NULL); gtk_tree_model_filter_set_visible_func ( GTK_TREE_MODEL_FILTER (br->filter_model), part_list_filter_func, br, NULL); // If we have TreeFilter use it, if not, just use sorting model only if (br->filter_model) gtk_tree_view_set_model (GTK_TREE_VIEW (w), br->filter_model); else gtk_tree_view_set_model (GTK_TREE_VIEW (w), br->sort_model); gtk_tree_view_append_column (GTK_TREE_VIEW (w), cell_column); update_list (br); // Set up TreeView dnd. g_signal_connect (G_OBJECT (w), "drag_data_get", G_CALLBACK (drag_data_get), br); gtk_drag_source_set (w, GDK_BUTTON1_MASK | GDK_BUTTON3_MASK, dnd_types, dnd_num_types, GDK_ACTION_MOVE); g_signal_connect (G_OBJECT (w), "cursor_changed", G_CALLBACK (select_row), br); g_signal_connect (G_OBJECT (w), "row_activated", G_CALLBACK (part_selected), br); br->viewport = GTK_WIDGET (gtk_builder_get_object (gui, "part_browser_vbox")); path = gtk_tree_path_new_first (); gtk_tree_view_set_cursor (GTK_TREE_VIEW (w), path, NULL, FALSE); gtk_tree_path_free (path); gtk_widget_unparent (br->viewport); return br->viewport; }
static GObject * gdict_database_chooser_constructor (GType type, guint n_params, GObjectConstructParam *params) { GObjectClass *parent_class; GObject *object; GdictDatabaseChooser *chooser; GdictDatabaseChooserPrivate *priv; GtkWidget *sw; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkWidget *hbox; parent_class = G_OBJECT_CLASS (gdict_database_chooser_parent_class); object = parent_class->constructor (type, n_params, params); chooser = GDICT_DATABASE_CHOOSER (object); priv = chooser->priv; sw = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_hexpand (sw, TRUE); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN); gtk_scrolled_window_set_min_content_height (GTK_SCROLLED_WINDOW (sw), 200); gtk_scrolled_window_set_max_content_height (GTK_SCROLLED_WINDOW (sw), 400); gtk_box_pack_start (GTK_BOX (chooser), sw, TRUE, TRUE, 0); gtk_widget_show (sw); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes ("databases", renderer, "text", DB_COLUMN_DESCRIPTION, "weight", DB_COLUMN_CURRENT, NULL); priv->treeview = gtk_tree_view_new (); gtk_tree_view_set_model (GTK_TREE_VIEW (priv->treeview), GTK_TREE_MODEL (priv->store)); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (priv->treeview), FALSE); gtk_tree_view_set_activate_on_single_click (GTK_TREE_VIEW (priv->treeview), TRUE); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->treeview), column); g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview)), "changed", G_CALLBACK (selection_changed_cb), chooser); g_signal_connect (priv->treeview, "row-activated", G_CALLBACK (row_activated_cb), chooser); gtk_container_add (GTK_CONTAINER (sw), priv->treeview); gtk_widget_show (priv->treeview); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); priv->buttons_box = hbox; priv->refresh_button = gtk_button_new (); gtk_button_set_image (GTK_BUTTON (priv->refresh_button), gtk_image_new_from_icon_name ("view-refresh-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR)); g_signal_connect (priv->refresh_button, "clicked", G_CALLBACK (refresh_button_clicked_cb), chooser); gtk_box_pack_start (GTK_BOX (hbox), priv->refresh_button, FALSE, FALSE, 0); gtk_widget_show (priv->refresh_button); gtk_widget_set_tooltip_text (priv->refresh_button, _("Reload the list of available databases")); priv->clear_button = gtk_button_new (); gtk_button_set_image (GTK_BUTTON (priv->clear_button), gtk_image_new_from_icon_name ("edit-clear-symbolic", GTK_ICON_SIZE_SMALL_TOOLBAR)); g_signal_connect (priv->clear_button, "clicked", G_CALLBACK (clear_button_clicked_cb), chooser); gtk_box_pack_start (GTK_BOX (hbox), priv->clear_button, FALSE, FALSE, 0); gtk_widget_show (priv->clear_button); gtk_widget_set_tooltip_text (priv->clear_button, _("Clear the list of available databases")); gtk_box_pack_end (GTK_BOX (chooser), hbox, FALSE, FALSE, 0); gtk_widget_show (hbox); return object; }
gboolean completion_create(GtkTreeModel *model, CompletionSelectFunc selfunc, gboolean back) { GtkCellRenderer *renderer; GtkTreeSelection *selection; GtkTreeViewColumn *column; GtkRequisition size; GtkTreePath *path; GtkTreeIter iter; int height, width; /* if there is only one match - don't build the tree view */ if (gtk_tree_model_iter_n_children(model, NULL) == 1) { char *value; path = gtk_tree_path_new_from_indices(0, -1); if (gtk_tree_model_get_iter(model, &iter, path)) { gtk_tree_model_get(model, &iter, COMPLETION_STORE_FIRST, &value, -1); /* call the select function */ selfunc(value); g_free(value); g_object_unref(model); return false; } } comp.selfunc = selfunc; /* prepare the tree view */ comp.win = gtk_scrolled_window_new(NULL, NULL); comp.tree = gtk_tree_view_new(); #ifndef HAS_GTK3 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(comp.win), GTK_POLICY_NEVER, GTK_POLICY_NEVER); #endif gtk_box_pack_end(GTK_BOX(vb.gui.box), comp.win, false, false, 0); gtk_container_add(GTK_CONTAINER(comp.win), comp.tree); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(comp.tree), false); /* we have only on line per item so we can use the faster fixed heigh mode */ gtk_tree_view_set_fixed_height_mode(GTK_TREE_VIEW(comp.tree), true); gtk_tree_view_set_model(GTK_TREE_VIEW(comp.tree), model); g_object_unref(model); VB_WIDGET_OVERRIDE_TEXT(comp.tree, VB_GTK_STATE_NORMAL, &vb.style.comp_fg[VB_COMP_NORMAL]); VB_WIDGET_OVERRIDE_BASE(comp.tree, VB_GTK_STATE_NORMAL, &vb.style.comp_bg[VB_COMP_NORMAL]); VB_WIDGET_OVERRIDE_TEXT(comp.tree, VB_GTK_STATE_SELECTED, &vb.style.comp_fg[VB_COMP_ACTIVE]); VB_WIDGET_OVERRIDE_BASE(comp.tree, VB_GTK_STATE_SELECTED, &vb.style.comp_bg[VB_COMP_ACTIVE]); VB_WIDGET_OVERRIDE_TEXT(comp.tree, VB_GTK_STATE_ACTIVE, &vb.style.comp_fg[VB_COMP_ACTIVE]); VB_WIDGET_OVERRIDE_BASE(comp.tree, VB_GTK_STATE_ACTIVE, &vb.style.comp_bg[VB_COMP_ACTIVE]); /* prepare the selection */ selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(comp.tree)); gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE); gtk_tree_selection_set_select_function(selection, tree_selection_func, NULL, NULL); /* get window dimension */ gtk_window_get_size(GTK_WINDOW(vb.gui.window), &width, &height); /* prepare first column */ column = gtk_tree_view_column_new(); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_append_column(GTK_TREE_VIEW(comp.tree), column); renderer = gtk_cell_renderer_text_new(); g_object_set(renderer, "font-desc", vb.style.comp_font, "ellipsize", PANGO_ELLIPSIZE_MIDDLE, NULL ); gtk_tree_view_column_pack_start(column, renderer, true); gtk_tree_view_column_add_attribute(column, renderer, "text", COMPLETION_STORE_FIRST); gtk_tree_view_column_set_min_width(column, 2 * width/3); /* prepare second column */ #ifdef FEATURE_TITLE_IN_COMPLETION column = gtk_tree_view_column_new(); gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_FIXED); gtk_tree_view_append_column(GTK_TREE_VIEW(comp.tree), column); renderer = gtk_cell_renderer_text_new(); g_object_set(renderer, "font-desc", vb.style.comp_font, "ellipsize", PANGO_ELLIPSIZE_END, NULL ); gtk_tree_view_column_pack_start(column, renderer, true); gtk_tree_view_column_add_attribute(column, renderer, "text", COMPLETION_STORE_SECOND); #endif /* to set the height for the treeview the tree must be realized first */ gtk_widget_show(comp.tree); /* this prevents the first item to be placed out of view if the completion * is shown */ while (gtk_events_pending()) { gtk_main_iteration(); } /* use max 1/3 of window height for the completion */ #ifdef HAS_GTK3 gtk_widget_get_preferred_size(comp.tree, NULL, &size); height /= 3; gtk_scrolled_window_set_min_content_height( GTK_SCROLLED_WINDOW(comp.win), size.height > height ? height : size.height ); #else gtk_widget_size_request(comp.tree, &size); height /= 3; if (size.height > height) { gtk_widget_set_size_request(comp.win, -1, height); } #endif vb.mode->flags |= FLAG_COMPLETION; /* set to -1 to have the cursor on first or last item set in move_cursor */ comp.active = -1; completion_next(back); gtk_widget_show(comp.win); return true; }
int music_build_element_widgets () { int i = 0; for (i = 0; i < 9; i++) { label_music_info[i] = gtk_label_new(NULL); gtk_label_set_width_chars(GTK_LABEL(label_music_info[i]), 15); gtk_label_set_max_width_chars(GTK_LABEL(label_music_info[i]), 150); gtk_label_set_line_wrap(GTK_LABEL(label_music_info[i]), TRUE); } separator_music_info = gtk_separator_new(GTK_ORIENTATION_VERTICAL); for (i = 0; i < 9; i++) { label_music_lyric[i] = gtk_label_new(NULL); gtk_label_set_max_width_chars(GTK_LABEL(label_music_lyric[i]), 305); // gtk_label_set_line_wrap(GTK_LABEL(label_music_lyric[i]), TRUE); } gtk_label_set_selectable(GTK_LABEL(label_music_lyric[4]), TRUE); gtk_label_set_use_underline (GTK_LABEL(label_music_lyric[4]), TRUE); gtk_label_set_use_markup (GTK_LABEL(label_music_lyric[4]), TRUE); gtk_label_set_pattern (GTK_LABEL(label_music_lyric[4]), "________"); separator_music_lyric1 = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL); separator_music_lyric2 = gtk_separator_new (GTK_ORIENTATION_HORIZONTAL); button_music_start_server = gtk_button_new_with_label("启动服务器"); // set_button_music_start_server(button_music_start_server); button_music_exit_server = gtk_button_new_with_label("关闭服务器"); // set_button_music_exit_server(button_music_exit_server); button_music_play = gtk_button_new(); // box_music_play = button_with_image("/usr/share/raspi_remote_control/ui_images/ui_images_music/play.png"); // box_music_pause = button_with_image("/usr/share/raspi_remote_control/ui_images/ui_images_music/pause.png"); image_music_play = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/play.png"); image_music_play_light = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/play_light.png"); image_music_pause = gtk_image_new_from_file ("/usr/share/raspi_remote_control/ui_images/ui_images_music/pause.png"); image_music_pause_light = gtk_image_new_from_file ("/usr/share/raspi_remote_control/ui_images/ui_images_music/pause_light.png"); gtk_button_set_relief(GTK_BUTTON(button_music_play), GTK_RELIEF_NONE); set_button_music_play(button_music_play); button_music_pause = gtk_button_new_with_label("暂停"); // set_button_music_pause(button_music_pause); button_music_unpause = gtk_button_new_with_label("取消暂停"); // set_button_music_unpause(button_music_unpause); // button_music_stop = gtk_button_new_with_label("停止"); button_music_stop = gtk_button_new(); image_music_stop = gtk_image_new_from_file ("/usr/share/raspi_remote_control/ui_images/ui_images_music/stop.png"); image_music_stop_light = gtk_image_new_from_file ("/usr/share/raspi_remote_control/ui_images/ui_images_music/stop_light.png"); gtk_button_set_image(GTK_BUTTON(button_music_stop), image_music_stop); gtk_button_set_relief(GTK_BUTTON(button_music_stop), GTK_RELIEF_NONE); set_button_music_stop(button_music_stop); // button_music_next = gtk_button_new_with_label("下一首"); button_music_next = gtk_button_new(); image_music_next = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/next.png"); image_music_next_light = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/next_light.png"); gtk_button_set_image(GTK_BUTTON(button_music_next), image_music_next); gtk_button_set_relief(GTK_BUTTON(button_music_next), GTK_RELIEF_NONE); set_button_music_next(button_music_next); // button_music_pre = gtk_button_new_with_label("上一首"); button_music_pre = gtk_button_new(); image_music_pre = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/pre.png"); image_music_pre_light = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/pre_light.png"); gtk_button_set_image (GTK_BUTTON(button_music_pre), image_music_pre); gtk_button_set_relief(GTK_BUTTON(button_music_pre), GTK_RELIEF_NONE); set_button_music_pre(button_music_pre); // button_music_volume_up = gtk_button_new_with_label("音量+"); // set_button_music_volume_up(button_music_volume_up); // button_music_volume_silence = gtk_button_new_with_label("静音"); button_music_silence = gtk_button_new(); image_music_silence = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/silence.png"); image_music_silence_light = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/silence_light.png"); image_music_unsilence = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/unsilence.png"); image_music_unsilence_light = gtk_image_new_from_file("/usr/share/raspi_remote_control/ui_images/ui_images_music/unsilence_light.png"); gtk_button_set_image (GTK_BUTTON(button_music_silence), image_music_silence); gtk_button_set_relief(GTK_BUTTON(button_music_silence), GTK_RELIEF_NONE); set_button_music_silence(button_music_silence); button_music_volume = gtk_volume_button_new(); set_button_music_volume( button_music_volume); button_music_reset_list = gtk_button_new_with_label("重设列表"); set_button_music_reset_list(button_music_reset_list); // button_music_choose_path = gtk_button_new_with_label("添加路径"); // set_button_music_choose_path(button_music_choose_path); // music_path_dialog = gtk_file_chooser_widget_new(GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER); music_path_dialog = gtk_file_chooser_dialog_new ("test_title", NULL, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER, "test_button_text", NULL); button_music_choose_path = gtk_file_chooser_button_new_with_dialog (music_path_dialog); gtk_file_chooser_button_set_title (GTK_FILE_CHOOSER_BUTTON(button_music_choose_path), "添加路径"); // gtk_file_chooser_set_select_multiple (music_path_dialog, TRUE); button_music_delete_path = gtk_button_new_with_label("删除当前路径"); set_button_music_delete_path(button_music_delete_path); scale_music_process = gtk_scale_new_with_range (GTK_ORIENTATION_HORIZONTAL, 0, 100, 1); set_scale_music_process(scale_music_process); label_music_cur_time = gtk_label_new ("--:--:--"); label_music_total_time = gtk_label_new ("--:--:--"); switch_music_autonext = gtk_switch_new (); set_switch_music_autonext (); label_music_autonext = gtk_label_new ("AutoNext: "); switch_music_repeat = gtk_switch_new (); set_switch_music_repeat (); label_music_repeat = gtk_label_new ("Repeat: "); switch_music_shuffle = gtk_switch_new (); set_switch_music_shuffle (); label_music_shuffle = gtk_label_new ("Shuffle: "); radio_button_music_mode_shuffle = gtk_radio_button_new (NULL); label_music_mode_shuffle = gtk_label_new ("随机:"); radio_button_music_mode_loop_list = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON (radio_button_music_mode_shuffle)); label_music_mode_loop_list = gtk_label_new ("列表循环:"); radio_button_music_mode_play_list = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON (radio_button_music_mode_shuffle)); label_music_mode_play_list = gtk_label_new ("播放列表:"); radio_button_music_mode_loop_one = gtk_radio_button_new_from_widget (GTK_RADIO_BUTTON (radio_button_music_mode_shuffle)); label_music_mode_loop_one = gtk_label_new ("单曲:"); spinner_music_mode_changing = gtk_spinner_new (); set_radio_button_music_mode (); store_music_dir_list = gtk_tree_store_new(dir_n_columns, G_TYPE_STRING); tree_view_music_dir_list = gtk_tree_view_new_with_model (GTK_TREE_MODEL(store_music_dir_list)); text_renderer_music_dir_list = gtk_cell_renderer_text_new (); column_music_dir_list = gtk_tree_view_column_new_with_attributes (NULL, text_renderer_music_dir_list, "text", dir_name, NULL); gtk_tree_view_column_set_fixed_width(column_music_dir_list, 100); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view_music_dir_list), column_music_dir_list); music_dir_list_sw_adj_h = gtk_adjustment_new(100, 0, 100, 1, 1, 50); music_dir_list_sw = gtk_scrolled_window_new(NULL, music_dir_list_sw_adj_h); gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(music_dir_list_sw), 330); gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(music_dir_list_sw), 100); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(music_dir_list_sw), GTK_SHADOW_NONE); // gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(music_dir_list_sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(music_dir_list_sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(music_dir_list_sw), tree_view_music_dir_list); selection_music_dir_list = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view_music_dir_list)); set_tree_view_music_dir_list (); store_music_list = gtk_tree_store_new(list_n_columns, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING); // char file_index[BUFSIZ]; // printf("music_list_num is: %s\n", music_list_num); // while (i < music_list_num) { // // printf("%d: %s\n", i, music_list[i]); // sprintf(file_index, "%d", i + 1); // gtk_tree_store_append(store_music_list, &iter_music_list, NULL); // gtk_tree_store_set (store_music_list, &iter_music_list, list_index, file_index, list_title, music_list[i], list_total_sec, "03:00", -1); // i++; // } // tree_view_music_list = gtk_tree_view_new_with_model (GTK_TREE_MODEL(store_music_list)); text_renderer_music_list = gtk_cell_renderer_text_new (); column_music_list = gtk_tree_view_column_new_with_attributes (NULL, text_renderer_music_list, "text", list_index, NULL); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view_music_list), column_music_list); gtk_tree_view_column_set_title(column_music_list, "序号"); text_renderer_music_list = gtk_cell_renderer_text_new (); column_music_list = gtk_tree_view_column_new_with_attributes (NULL, text_renderer_music_list, "text", list_title, NULL); gtk_tree_view_column_set_fixed_width(column_music_list, 100); gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view_music_list), column_music_list); // text_renderer_music_list = gtk_cell_renderer_text_new (); // column_music_list = gtk_tree_view_column_new_with_attributes (NULL, text_renderer_music_list, "text", list_total_sec, NULL); // gtk_tree_view_append_column (GTK_TREE_VIEW (tree_view_music_list), column_music_list); music_list_sw_adj_h = gtk_adjustment_new(100, 0, 100, 1, 1, 50); music_list_sw = gtk_scrolled_window_new(NULL, music_list_sw_adj_h); gtk_scrolled_window_set_min_content_height(GTK_SCROLLED_WINDOW(music_list_sw), 370); gtk_scrolled_window_set_min_content_width(GTK_SCROLLED_WINDOW(music_list_sw), 200); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(music_list_sw), GTK_SHADOW_NONE); // gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(music_list_sw), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(music_list_sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(music_list_sw), tree_view_music_list); selection_music_list = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view_music_list)); set_tree_view_music_list (); return 1; }