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;
}
