GtkWidget *
statusbar_new(void)
{
GtkWidget *status_hbox;
/* Status hbox */
status_hbox = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 1, FALSE);
gtk_container_set_border_width(GTK_CONTAINER(status_hbox), 0);
/* info (main) statusbar */
info_bar_new();
/* packets statusbar */
packets_bar_new();
/* profile statusbar */
profile_bar_new();
/* expert info indicator */
status_expert_new();
/* Capture comments indicator */
status_capture_comment_new();
/* Pane for the statusbar */
status_pane_left = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);
gtk_widget_show(status_pane_left);
status_pane_right = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);
gtk_widget_show(status_pane_right);
return status_hbox;
}
/**************************************************************** MAIN WINDOW */
static void
bmd_activate (GtkApplication *app, gpointer data)
{
bmd_widgets *a = (bmd_widgets *) data;
// create a window with title, default size and icons
a->window = gtk_application_window_new (app);
gtk_window_set_application (GTK_WINDOW (a->window), GTK_APPLICATION (app));
gtk_window_set_position (GTK_WINDOW (a->window), GTK_WIN_POS_CENTER);
gtk_window_set_title (GTK_WINDOW (a->window), "Book Management Demo");
gtk_window_set_default_size (GTK_WINDOW (a->window), XSIZE, YSIZE);
gtk_window_set_default_icon_from_file ("bmd_icon.png", NULL);
a->box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (a->window), a->box);
/* moved the creation of the menu to a dedicated function */
bmd_construct_menu (app, (gpointer) a);
a->paned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start (GTK_BOX (a->box), a->paned, TRUE, TRUE, 0);
bmd_construct_editablecells (app, (gpointer) a);
bmd_construct_imagedemo (app, (gpointer) a);
gtk_widget_show_all (GTK_WIDGET (a->window));
}
static void
add_notebook (GeditMultiNotebook *mnb,
GtkWidget *notebook,
gboolean main_container)
{
gtk_widget_set_hexpand (notebook, TRUE);
gtk_widget_set_vexpand (notebook, TRUE);
if (main_container)
{
gtk_container_add (GTK_CONTAINER (mnb), notebook);
mnb->priv->notebooks = g_list_append (mnb->priv->notebooks,
notebook);
}
else
{
GtkWidget *paned;
GtkWidget *parent;
GtkAllocation allocation;
GtkWidget *active_notebook = mnb->priv->active_notebook;
gint active_nb_pos;
paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_widget_show (paned);
/* First we remove the active container from its parent to make
this we add a ref to it*/
g_object_ref (active_notebook);
parent = gtk_widget_get_parent (active_notebook);
gtk_widget_get_allocation (active_notebook, &allocation);
gtk_container_remove (GTK_CONTAINER (parent), active_notebook);
gtk_container_add (GTK_CONTAINER (parent), paned);
gtk_paned_pack1 (GTK_PANED (paned), active_notebook, TRUE, FALSE);
g_object_unref (active_notebook);
gtk_paned_pack2 (GTK_PANED (paned), notebook, FALSE, FALSE);
/* We need to set the new paned in the right place */
gtk_paned_set_position (GTK_PANED (paned),
allocation.width / 2);
active_nb_pos = g_list_index (mnb->priv->notebooks,
active_notebook);
mnb->priv->notebooks = g_list_insert (mnb->priv->notebooks,
notebook,
active_nb_pos + 1);
}
gtk_widget_show (notebook);
connect_notebook_signals (mnb, notebook);
g_signal_emit (G_OBJECT (mnb), signals[NOTEBOOK_ADDED], 0, notebook);
}
extern void create_left_pane(void)
{
lpane = gtk_paned_new(GTK_ORIENTATION_VERTICAL);
gtk_paned_set_position( GTK_PANED(lpane), 450 );
gtk_widget_show(lpane);
return;
}
extern void create_main_pane(void)
{
pane = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);
gtk_paned_set_position( GTK_PANED(pane), 350 );
gtk_widget_show(pane);
return;
}
static void
pragha_application_construct_window (PraghaApplication *pragha)
{
gchar *icon_uri = NULL;
/* Main window */
pragha->mainwindow = gtk_application_window_new (GTK_APPLICATION (pragha));
icon_uri = g_build_filename (PIXMAPDIR, "pragha.png", NULL);
pragha->pixbuf_app = gdk_pixbuf_new_from_file (icon_uri, NULL);
g_free (icon_uri);
if (!pragha->pixbuf_app)
g_warning("Unable to load pragha png");
else
gtk_window_set_icon (GTK_WINDOW(pragha->mainwindow),
pragha->pixbuf_app);
gtk_window_set_title(GTK_WINDOW(pragha->mainwindow), _("Pragha Music Player"));
/* Get all widgets instances */
pragha->menu_ui_manager = pragha_menubar_new ();
pragha->toolbar = pragha_toolbar_new ();
pragha->infobox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
pragha->pane1 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
pragha->pane2 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
pragha->sidebar1 = pragha_sidebar_new ();
pragha->sidebar2 = pragha_sidebar_new ();
pragha->library = pragha_library_pane_new ();
pragha->playlist = pragha_playlist_new ();
pragha->statusbar = pragha_statusbar_get ();
pragha->scanner = pragha_scanner_new();
pragha->status_icon = pragha_status_icon_new (pragha);
pragha_menubar_connect_signals (pragha->menu_ui_manager, pragha);
/* Contruct the window. */
pragha_window_new (pragha);
}
GtkWidget * gwrgtk_hpaned_new()
{
GtkWidget * w = NULL;
// ........................................................................
#if GWR_GTK_VERSION_GE(3,2)
w = gtk_paned_new( GTK_ORIENTATION_HORIZONTAL );
#else
w = gtk_hpaned_new();
#endif
return w;
}
static GtkWidget* CreateMainContainer_(void)
{
GtkWidget* container = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);
GtkWidget* leftPane = GStreamerSink_Create();
GtkWidget* rightPane = LeaderBoardsUi_Create();
gtk_paned_add1(GTK_PANED(container), leftPane);
gtk_paned_add2(GTK_PANED(container), rightPane);
return container;
} // CreateMainContainer_
GtkWidget* the_toolbox(void) {
GtkTextBuffer *text_buffer;
GtkWidget *text_pane = setup_card_text_pane(&text_buffer);
gtk_widget_set_size_request(text_pane, 250, -1);
GtkWidget *list_pane = setup_card_list_pane(text_buffer);
gtk_widget_set_size_request(list_pane, 400, -1);
GtkWidget *paned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);
gtk_paned_pack1(GTK_PANED(paned), list_pane, TRUE, FALSE);
gtk_paned_pack2(GTK_PANED(paned), text_pane, FALSE, FALSE);
return paned;
}
static void
pragha_application_construct_window (PraghaApplication *pragha)
{
/* Main window */
pragha->mainwindow = gtk_application_window_new (GTK_APPLICATION (pragha));
gtk_window_set_icon_name (GTK_WINDOW(pragha->mainwindow), "pragha");
/* Get all widgets instances */
pragha->menu_ui_manager = pragha_menubar_new ();
pragha->menu_ui = pragha_gmenu_toolbar_new (pragha);
pragha->toolbar = pragha_toolbar_new ();
pragha->infobox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
pragha->pane1 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
pragha->main_stack = gtk_stack_new ();
pragha->pane2 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
pragha->sidebar1 = pragha_sidebar_new ();
pragha->sidebar2 = pragha_sidebar_new ();
pragha->library = pragha_library_pane_new ();
pragha->playlist = pragha_playlist_new ();
pragha->statusbar = pragha_statusbar_get ();
pragha->scanner = pragha_scanner_new();
pragha->status_icon = pragha_status_icon_new (pragha);
pragha_menubar_connect_signals (pragha->menu_ui_manager, pragha);
/* Contruct the window. */
pragha_window_new (pragha);
gtk_window_set_title (GTK_WINDOW(pragha->mainwindow),
_("Pragha Music Player"));
}
//====================Main Window====================//
void mainWindowInit (void)
{
mw.window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (mw.window), 500, 320);
gtk_window_set_title (GTK_WINDOW (mw.window), "Hello World!\n");
gtk_container_set_border_width (GTK_CONTAINER (mw.window), 10);
mw.button = gtk_button_new_with_label ("New Page.");
mw.textEditor[mw.tabCount] = gtk_text_view_new ();
gtk_text_view_set_accepts_tab (GTK_TEXT_VIEW (mw.textEditor[mw.tabCount]), TRUE);
mw.notebook = gtk_notebook_new ();
gtk_notebook_append_page (GTK_NOTEBOOK (mw.notebook), mw.textEditor[mw.tabCount], NULL);
mw.overallPaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
mw.leftPaned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
mw.rightPaned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_paned_set_position (GTK_PANED (mw.overallPaned), 50);
gtk_paned_set_position (GTK_PANED (mw.leftPaned), 50);
gtk_paned_set_position (GTK_PANED (mw.rightPaned), 50);
gtk_paned_pack1 (GTK_PANED (mw.rightPaned), mw.notebook, TRUE, TRUE);
gtk_paned_pack2 (GTK_PANED (mw.rightPaned), mw.button, TRUE, TRUE);
gtk_paned_pack1 (GTK_PANED (mw.overallPaned), mw.leftPaned, TRUE, TRUE);
gtk_paned_pack2 (GTK_PANED (mw.overallPaned), mw.rightPaned, TRUE, TRUE);
gtk_widget_set_size_request (mw.leftPaned, 50, -1);
gtk_widget_set_size_request (mw.rightPaned, 50, -1);
gtk_container_add (GTK_CONTAINER (mw.window), mw.overallPaned);
g_signal_connect (mw.button, "pressed", G_CALLBACK (mw.newDocument), NULL);
g_signal_connect (mw.window, "delete-event", G_CALLBACK (mw.cw.init), NULL);
g_signal_connect (mw.window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
gtk_widget_show_all (mw.window);
}
static void
activate (GtkApplication *app,
gpointer user_data)
{
GtkWidget *window;
GtkWidget *frame;
GtkWidget *drawing_area;
GtkWidget *chooser_button;
window = gtk_application_window_new (app);
gtk_window_set_title (GTK_WINDOW (window), "Drawing Area");
g_signal_connect (window, "destroy", G_CALLBACK (close_window), NULL);
gtk_container_set_border_width (GTK_CONTAINER (window), 8);
frame = gtk_paned_new(GTK_ORIENTATION_VERTICAL);
gtk_container_add (GTK_CONTAINER (window), frame);
chooser_button = gtk_file_chooser_button_new("Select problem...", GTK_FILE_CHOOSER_ACTION_OPEN);
drawing_area = gtk_drawing_area_new ();
/* set a minimum size */
gtk_widget_set_size_request (drawing_area, 800, 800);
gtk_paned_add1(GTK_PANED(frame), drawing_area);
gtk_paned_add2(GTK_PANED(frame), chooser_button);
/* Signals used to handle the backing surface */
g_signal_connect (drawing_area, "draw",
G_CALLBACK (draw_cb), NULL);
g_signal_connect (drawing_area,"configure-event",
G_CALLBACK (configure_event_cb), NULL);
g_signal_connect(drawing_area, "button_press_event",
G_CALLBACK(button_press_event_cb), NULL);
g_signal_connect(chooser_button, "file-set",
G_CALLBACK(set_file), chooser_button);
/* Ask to receive events the drawing area doesn't normally
* subscribe to. In particular, we need to ask for the
* button press and motion notify events that want to handle.
*/
gtk_widget_set_events (drawing_area, gtk_widget_get_events (drawing_area)
| GDK_BUTTON_PRESS_MASK
| GDK_POINTER_MOTION_MASK);
gtk_widget_show_all (window);
}
/**
* schema_browser_perspective_new
*
* Creates new #BrowserPerspective widget which
*/
BrowserPerspective *
schema_browser_perspective_new (BrowserWindow *bwin)
{
TConnection *tcnc;
BrowserPerspective *bpers;
SchemaBrowserPerspective *perspective;
gboolean fav_supported;
bpers = (BrowserPerspective*) g_object_new (TYPE_SCHEMA_BROWSER_PERSPECTIVE, NULL);
perspective = (SchemaBrowserPerspective*) bpers;
tcnc = browser_window_get_connection (bwin);
fav_supported = t_connection_get_favorites (tcnc) ? TRUE : FALSE;
perspective->priv->bwin = bwin;
/* contents */
GtkWidget *paned, *wid, *nb;
paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
if (fav_supported) {
wid = favorite_selector_new (tcnc);
g_signal_connect (wid, "selection-changed",
G_CALLBACK (fav_selection_changed_cb), bpers);
gtk_paned_add1 (GTK_PANED (paned), wid);
gtk_paned_set_position (GTK_PANED (paned), DEFAULT_FAVORITES_SIZE);
perspective->priv->favorites = wid;
}
nb = browser_perspective_create_notebook (bpers);
perspective->priv->notebook = nb;
gtk_paned_add2 (GTK_PANED (paned), nb);
wid = objects_index_new (tcnc);
g_signal_connect (wid, "selection-changed",
G_CALLBACK (objects_index_selection_changed_cb), bpers);
gtk_notebook_append_page (GTK_NOTEBOOK (nb), wid,
ui_make_tab_label_with_icon (_("Index"), "help-about", FALSE, NULL));
gtk_notebook_set_tab_reorderable (GTK_NOTEBOOK (nb), wid, TRUE);
gtk_notebook_set_group_name (GTK_NOTEBOOK (nb), "schema-browser");
gtk_notebook_set_menu_label (GTK_NOTEBOOK (nb), wid,
ui_make_tab_label_with_icon (_("Index"), "help-about", FALSE, NULL));
gtk_box_pack_start (GTK_BOX (bpers), paned, TRUE, TRUE, 0);
gtk_widget_show_all (paned);
if (perspective->priv->favorites && !perspective->priv->favorites_shown)
gtk_widget_hide (perspective->priv->favorites);
return bpers;
}
static GtkWidget *
mug_query_area (MugData * mugdata)
{
GtkWidget *queryarea, *paned, *scrolled;
#ifdef HAVE_GTK3
queryarea = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
paned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
#else
queryarea = gtk_vbox_new (FALSE, 2);
paned = gtk_vpaned_new ();
#endif /*!HAVE_GTK3*/
mugdata->mlist = mug_msg_list_view_new
(mu_runtime_path(MU_RUNTIME_PATH_XAPIANDB));
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (scrolled), mugdata->mlist);
gtk_paned_add1 (GTK_PANED (paned), scrolled);
mugdata->msgview = mug_msg_view_new ();
mug_msg_view_set_note (MUG_MSG_VIEW(mugdata->msgview),
"<h1>Welcome to <i>mug</i>!</h1><hr>"
"<tt>mug</tt> is an experimental UI for <tt>mu</tt>, which will "
"slowly evolve into something useful.<br><br>Enjoy the ride.");
g_signal_connect (G_OBJECT (mugdata->mlist), "msg-selected",
G_CALLBACK (on_msg_selected), mugdata);
g_signal_connect (G_OBJECT (mugdata->mlist), "error-occured",
G_CALLBACK (on_list_view_error), mugdata);
gtk_paned_add2 (GTK_PANED (paned), mugdata->msgview);
mugdata->querybar = mug_querybar ();
g_signal_connect (G_OBJECT (mugdata->querybar), "query-changed",
G_CALLBACK (on_query_changed), mugdata);
gtk_box_pack_start (GTK_BOX (queryarea),
mugdata->querybar, FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX (queryarea), paned, TRUE, TRUE, 2);
gtk_widget_show_all (queryarea);
return queryarea;
}
static GtkWidget *
mug_query_area (MugData * mugdata)
{
GtkWidget *queryarea;
GtkWidget *paned;
GtkWidget *scrolled;
#ifdef HAVE_GTK3
queryarea = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
paned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
#else
queryarea = gtk_vbox_new (FALSE, 2);
paned = gtk_vpaned_new ();
#endif /*!HAVE_GTK3 */
mugdata->mlist = mug_msg_list_view_new
(mu_runtime_path(MU_RUNTIME_PATH_XAPIANDB));
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (scrolled), mugdata->mlist);
gtk_paned_add1 (GTK_PANED (paned), scrolled);
mugdata->msgview = mug_msg_view_new ();
mug_msg_view_set_msg (MUG_MSG_VIEW (mugdata->msgview), NULL);
g_signal_connect (G_OBJECT (mugdata->mlist), "msg-selected",
G_CALLBACK (on_msg_selected), mugdata);
g_signal_connect (G_OBJECT (mugdata->mlist), "error-occured",
G_CALLBACK (on_list_view_error), mugdata);
gtk_paned_add2 (GTK_PANED (paned), mugdata->msgview);
mugdata->querybar = mug_querybar ();
g_signal_connect (G_OBJECT (mugdata->querybar), "query-changed",
G_CALLBACK (on_query_changed), mugdata);
gtk_box_pack_start (GTK_BOX (queryarea),
mugdata->querybar, FALSE, FALSE, 2);
gtk_box_pack_start (GTK_BOX (queryarea), paned, TRUE, TRUE, 2);
gtk_widget_show_all (queryarea);
return queryarea;
}
int
main(int argc, char **argv)
{
gtk_init(&argc, &argv);
GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request(window, 800, 500);
g_signal_connect(window, "delete_event", G_CALLBACK(on_delete_event), NULL);
GtkWidget *hpaned = gtk_paned_new(GTK_ORIENTATION_HORIZONTAL);
gtk_paned_set_position(GTK_PANED(hpaned), 400);
GtkWidget *frotz = chimara_glk_new();
chimara_glk_set_css_from_string(CHIMARA_GLK(frotz),
"buffer.normal { font-family: 'Lucida Sans'; font-size: 12; }"
"grid.normal { font-family: 'Lucida Console'; font-size: 12; }");
g_signal_connect(frotz, "started", G_CALLBACK(on_started), "Frotz");
g_signal_connect(frotz, "stopped", G_CALLBACK(on_stopped), "Frotz");
GtkWidget *nitfol = chimara_glk_new();
chimara_glk_set_css_from_string(CHIMARA_GLK(frotz),
"buffer.normal { font-family: 'Bitstream Charter'; font-size: 12; }"
"grid.normal { font-family: 'Luxi Mono'; font-size: 12; }");
g_signal_connect(nitfol, "started", G_CALLBACK(on_started), "Nitfol");
g_signal_connect(nitfol, "stopped", G_CALLBACK(on_stopped), "Nitfol");
gtk_paned_pack1(GTK_PANED(hpaned), frotz, TRUE, TRUE);
gtk_paned_pack2(GTK_PANED(hpaned), nitfol, TRUE, TRUE);
gtk_container_add(GTK_CONTAINER(window), hpaned);
gtk_widget_show_all(window);
if(!chimara_glk_run(CHIMARA_GLK(frotz), "../interpreters/frotz/.libs/frotz.so", argc, argv, NULL))
return 1;
if(!chimara_glk_run(CHIMARA_GLK(nitfol), "../interpreters/nitfol/.libs/nitfol.so", argc, argv, NULL))
return 1;
gtk_main();
chimara_glk_stop(CHIMARA_GLK(frotz));
chimara_glk_stop(CHIMARA_GLK(nitfol));
return 0;
}
static void
text_grid (void)
{
GtkWidget *window;
GtkWidget *grid;
GtkWidget *paned1;
GtkWidget *box;
GtkWidget *label;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Height-for-Width");
paned1 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_container_add (GTK_CONTAINER (window), paned1);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_paned_pack1 (GTK_PANED (paned1), box, TRUE, FALSE);
gtk_paned_pack2 (GTK_PANED (paned1), gtk_label_new ("Space"), TRUE, FALSE);
grid = gtk_grid_new ();
gtk_orientable_set_orientation (GTK_ORIENTABLE (grid), GTK_ORIENTATION_VERTICAL);
gtk_container_add (GTK_CONTAINER (box), gtk_label_new ("Above"));
gtk_container_add (GTK_CONTAINER (box), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
gtk_container_add (GTK_CONTAINER (box), grid);
gtk_container_add (GTK_CONTAINER (box), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
gtk_container_add (GTK_CONTAINER (box), gtk_label_new ("Below"));
label = gtk_label_new ("Some text that may wrap if it has to");
gtk_label_set_width_chars (GTK_LABEL (label), 10);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1);
gtk_grid_attach (GTK_GRID (grid), test_widget ("1", "red"), 1, 0, 1, 1);
gtk_grid_attach (GTK_GRID (grid), test_widget ("2", "blue"), 0, 1, 1, 1);
label = gtk_label_new ("Some text that may wrap if it has to");
gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
gtk_label_set_width_chars (GTK_LABEL (label), 10);
gtk_grid_attach (GTK_GRID (grid), label, 1, 1, 1, 1);
gtk_widget_show_all (window);
}
GtkWidget* GetSplitterWidget(wxOrientation orient)
{
static GtkWidget* widgets[2];
const GtkOrientation gtkOrient =
orient == wxHORIZONTAL ? GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL;
GtkWidget*& widget = widgets[gtkOrient];
if (widget == NULL)
{
#ifdef __WXGTK3__
widget = gtk_paned_new(gtkOrient);
#else
if (orient == wxHORIZONTAL)
widget = gtk_hpaned_new();
else
widget = gtk_vpaned_new();
#endif
gtk_container_add(GetContainer(), widget);
gtk_widget_realize(widget);
}
return widget;
}
GtkWidget *gtk_paned_new_with_handle(GtkOrientation orientation)
{
GtkWidget *pnd = gtk_paned_new(orientation);
GtkStyleContext *context = gtk_widget_get_style_context(pnd);
GtkCssProvider *cssprv = gtk_css_provider_new();
GdkRGBA clrSel = {0.,0.,0.,0.};
char css[2048];
gtk_style_context_lookup_color(context, "bg_color", &clrSel);
if (orientation == GTK_ORIENTATION_HORIZONTAL)
{
sprintf(css, "* {\n -GtkPaned-handle-size: 3; \n } \n .pane-separator.horizontal {\n background-image: -gtk-gradient (linear, left top, left bottom, from (%s), color-stop (0.5, shade (%s, 0.95)), to (%s)); \n -unico-centroid-texture: url(\"%s\");\n }\n", gdk_rgba_to_string(&clrSel), gdk_rgba_to_string(&clrSel), gdk_rgba_to_string(&clrSel), imgOrzHnd);
}
else
{
sprintf(css, "* {\n -GtkPaned-handle-size: 3; \n } \n \n .pane-separator.vertical {\n background-image: -gtk-gradient (linear, left top, right top, from (%s), color-stop (0.5, shade (%s, 0.95)), to (%s)); \n -unico-centroid-texture: url(\"%s\");\n }\n", gdk_rgba_to_string(&clrSel), gdk_rgba_to_string(&clrSel), gdk_rgba_to_string(&clrSel), imgVrtHnd);
}
gtk_style_context_remove_provider(context, GTK_STYLE_PROVIDER (cssprv));
gtk_style_context_add_provider(context, GTK_STYLE_PROVIDER (cssprv), GTK_STYLE_PROVIDER_PRIORITY_USER);
gtk_css_provider_load_from_data(cssprv, css, -1, NULL);
g_object_unref(cssprv);
return pnd;
}
bool attach()
{
GRefPtr<WebKitWebViewBase> inspectorView = webkit_web_inspector_get_web_view(m_inspector);
if (m_inspectorWindow) {
gtk_container_remove(GTK_CONTAINER(m_inspectorWindow), GTK_WIDGET(inspectorView.get()));
gtk_widget_destroy(m_inspectorWindow);
m_inspectorWindow = 0;
}
GtkWidget* pane;
if (gtk_bin_get_child(GTK_BIN(m_parentWindow)) == GTK_WIDGET(m_webView)) {
GRefPtr<WebKitWebView> inspectedView = m_webView;
gtk_container_remove(GTK_CONTAINER(m_parentWindow), GTK_WIDGET(m_webView));
pane = gtk_paned_new(GTK_ORIENTATION_VERTICAL);
gtk_paned_add1(GTK_PANED(pane), GTK_WIDGET(m_webView));
gtk_container_add(GTK_CONTAINER(m_parentWindow), pane);
gtk_widget_show_all(pane);
} else
pane = gtk_bin_get_child(GTK_BIN(m_parentWindow));
gtk_paned_set_position(GTK_PANED(pane), webkit_web_inspector_get_attached_height(m_inspector));
gtk_paned_add2(GTK_PANED(pane), GTK_WIDGET(inspectorView.get()));
return InspectorTest::attach();
}
GtkWidget *
pgd_find_create_widget (PopplerDocument *document)
{
PgdFindDemo *demo;
GtkWidget *vbox, *hbox;
GtkWidget *button;
GtkWidget *swindow;
GtkWidget *checkbutton;
GtkTreeModel *model;
GtkWidget *treeview;
GtkCellRenderer *renderer;
GtkWidget *hpaned;
GtkTreeSelection *selection;
demo = g_new0 (PgdFindDemo, 1);
demo->doc = g_object_ref (document);
demo->n_pages = poppler_document_get_n_pages (document);
demo->selected_page = -1;
demo->options = POPPLER_FIND_DEFAULT;
hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_paned_set_position (GTK_PANED (hpaned), 300);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
demo->entry = gtk_entry_new ();
gtk_box_pack_start (GTK_BOX (hbox), demo->entry, FALSE, TRUE, 0);
gtk_widget_show (demo->entry);
demo->progress = gtk_progress_bar_new ();
gtk_progress_bar_set_ellipsize (GTK_PROGRESS_BAR (demo->progress),
PANGO_ELLIPSIZE_END);
gtk_box_pack_start (GTK_BOX (hbox), demo->progress, TRUE, TRUE, 0);
gtk_widget_show (demo->progress);
button = gtk_button_new_with_label ("Find");
gtk_widget_set_sensitive (button, FALSE);
g_signal_connect (G_OBJECT (button), "clicked",
G_CALLBACK (pgd_find_button_clicked),
(gpointer)demo);
g_signal_connect_swapped (G_OBJECT (demo->entry), "changed",
G_CALLBACK (pgd_find_button_sensitivity_cb),
(gpointer)button);
gtk_box_pack_end (GTK_BOX (hbox), button, FALSE, FALSE, 0);
gtk_widget_show (button);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 6);
gtk_widget_show (hbox);
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
checkbutton = gtk_check_button_new_with_label ("Case sensitive");
g_signal_connect (checkbutton, "toggled",
G_CALLBACK (pgd_find_case_sensitive_toggled),
demo);
gtk_box_pack_start (GTK_BOX (hbox), checkbutton, FALSE, FALSE, 0);
gtk_widget_show (checkbutton);
checkbutton = gtk_check_button_new_with_label ("Backwards");
g_signal_connect (checkbutton, "toggled",
G_CALLBACK (pgd_find_backwards_toggled),
demo);
gtk_box_pack_start (GTK_BOX (hbox), checkbutton, FALSE, FALSE, 0);
gtk_widget_show (checkbutton);
checkbutton = gtk_check_button_new_with_label ("Whole words only");
g_signal_connect (checkbutton, "toggled",
G_CALLBACK (pgd_find_whole_words_toggled),
demo);
gtk_box_pack_start (GTK_BOX (hbox), checkbutton, FALSE, FALSE, 0);
gtk_widget_show (checkbutton);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
swindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swindow),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
model = pgd_find_create_model ();
treeview = gtk_tree_view_new_with_model (model);
g_object_unref (model);
demo->treeview = treeview;
gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview), TRUE);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
g_signal_connect (selection, "changed",
G_CALLBACK (pgd_find_selection_changed),
demo);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
TITLE_COLUMN, "Matches",
renderer,
"text", TITLE_COLUMN,
NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
X1_COLUMN, "X1",
renderer,
"text", X1_COLUMN,
"visible", VISIBLE_COLUMN,
NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
Y1_COLUMN, "Y1",
renderer,
"text", Y1_COLUMN,
"visible", VISIBLE_COLUMN,
NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
X2_COLUMN, "X2",
renderer,
"text", X2_COLUMN,
"visible", VISIBLE_COLUMN,
NULL);
renderer = gtk_cell_renderer_text_new ();
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (treeview),
Y2_COLUMN, "Y2",
renderer,
"text", Y2_COLUMN,
"visible", VISIBLE_COLUMN,
NULL);
gtk_container_add (GTK_CONTAINER (swindow), treeview);
gtk_widget_show (treeview);
gtk_paned_add1 (GTK_PANED (hpaned), swindow);
gtk_widget_show (swindow);
demo->darea = gtk_drawing_area_new ();
g_signal_connect (demo->darea, "draw",
G_CALLBACK (pgd_find_viewer_drawing_area_draw),
demo);
swindow = gtk_scrolled_window_new (NULL, NULL);
#if GTK_CHECK_VERSION(3, 7, 8)
gtk_container_add(GTK_CONTAINER(swindow), demo->darea);
#else
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (swindow), demo->darea);
#endif
gtk_widget_show (demo->darea);
gtk_paned_add2 (GTK_PANED (hpaned), swindow);
gtk_widget_show (swindow);
gtk_box_pack_start (GTK_BOX (vbox), hpaned, TRUE, TRUE, 0);
gtk_widget_show (hpaned);
g_object_weak_ref (G_OBJECT (vbox),
(GWeakNotify)pgd_find_free,
(gpointer)demo);
return vbox;
}
void i_fileinfo_gui( const gchar * filename_uri )
{
static GtkWidget *fileinfowin = NULL;
GtkWidget *fileinfowin_vbox, *fileinfowin_columns_hbox;
GtkWidget *midiinfoboxes_vbox, *miditextboxes_vbox, *miditextboxes_paned;
GtkWidget *title_hbox, *title_icon_image, *title_name_f_label, *title_name_v_entry;
GtkWidget *info_frame, *info_frame_tl, *info_grid;
GtkWidget *text_frame, *text_frame_tl, *text_tv, *text_tv_sw;
GtkWidget *lyrics_frame, *lyrics_tv, *lyrics_tv_sw;
GtkTextBuffer *text_tb, *lyrics_tb;
GtkWidget *footer_hbbox, *footer_bclose;
GdkPixbuf *title_icon_pixbuf;
PangoAttrList *pangoattrlist;
PangoAttribute *pangoattr;
GString *value_gstring;
gchar *title , *filename, *filename_utf8;
gint bpm = 0, wavg_bpm = 0;
midifile_t *mf;
if ( fileinfowin )
return;
mf = g_malloc(sizeof(midifile_t));
/****************** midifile parser ******************/
if ( !i_midi_parse_from_filename( filename_uri , mf ) )
return;
/* midifile is filled with information at this point,
bpm information is needed too */
i_midi_get_bpm( mf , &bpm , &wavg_bpm );
/*****************************************************/
fileinfowin = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_window_set_type_hint( GTK_WINDOW(fileinfowin), GDK_WINDOW_TYPE_HINT_DIALOG );
gtk_window_set_position( GTK_WINDOW(fileinfowin) , GTK_WIN_POS_CENTER );
g_signal_connect( G_OBJECT(fileinfowin) , "destroy" , G_CALLBACK(i_fileinfo_ev_destroy) , mf );
g_signal_connect( G_OBJECT(fileinfowin) , "destroy" , G_CALLBACK(gtk_widget_destroyed) , &fileinfowin );
gtk_container_set_border_width( GTK_CONTAINER(fileinfowin), 10 );
fileinfowin_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10 );
gtk_container_add( GTK_CONTAINER(fileinfowin) , fileinfowin_vbox );
/* pango attributes */
pangoattrlist = pango_attr_list_new();
pangoattr = pango_attr_weight_new( PANGO_WEIGHT_BOLD );
pangoattr->start_index = 0;
pangoattr->end_index = G_MAXINT;
pango_attr_list_insert( pangoattrlist , pangoattr );
/******************
*** TITLE LINE ***/
title_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5 );
gtk_box_pack_start( GTK_BOX(fileinfowin_vbox) , title_hbox , FALSE , FALSE , 0 );
title_icon_pixbuf = gdk_pixbuf_new_from_xpm_data( (const gchar **)amidiplug_xpm_midiicon );
title_icon_image = gtk_image_new_from_pixbuf( title_icon_pixbuf );
g_object_unref( title_icon_pixbuf );
gtk_misc_set_alignment( GTK_MISC(title_icon_image) , 0 , 0 );
gtk_box_pack_start( GTK_BOX(title_hbox) , title_icon_image , FALSE , FALSE , 0 );
title_name_f_label = gtk_label_new( _("Name:") );
gtk_label_set_attributes( GTK_LABEL(title_name_f_label) , pangoattrlist );
gtk_box_pack_start( GTK_BOX(title_hbox) , title_name_f_label , FALSE , FALSE , 0 );
title_name_v_entry = gtk_entry_new();
gtk_editable_set_editable( GTK_EDITABLE(title_name_v_entry) , FALSE );
gtk_widget_set_size_request( GTK_WIDGET(title_name_v_entry) , 200 , -1 );
gtk_box_pack_start(GTK_BOX(title_hbox) , title_name_v_entry , TRUE , TRUE , 0 );
fileinfowin_columns_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2 );
gtk_box_pack_start( GTK_BOX(fileinfowin_vbox) , fileinfowin_columns_hbox , TRUE , TRUE , 0 );
/*********************
*** MIDI INFO BOX ***/
midiinfoboxes_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2 );
/* pick the entire space if both comments and lyrics boxes are not displayed,
pick only required space if at least one of them is displayed */
if (( amidiplug_cfg_ap.ap_opts_comments_extract == 0 ) &&
( amidiplug_cfg_ap.ap_opts_lyrics_extract == 0 ))
gtk_box_pack_start( GTK_BOX(fileinfowin_columns_hbox) , midiinfoboxes_vbox , TRUE , TRUE , 0 );
else
gtk_box_pack_start( GTK_BOX(fileinfowin_columns_hbox) , midiinfoboxes_vbox , FALSE , FALSE , 0 );
info_frame_tl = gtk_label_new( "" );
gtk_label_set_markup( GTK_LABEL(info_frame_tl) , _("<span size=\"smaller\"> MIDI Info </span>") );
gtk_box_pack_start( GTK_BOX(midiinfoboxes_vbox) , info_frame_tl , FALSE , FALSE , 0 );
info_frame = gtk_frame_new( NULL );
gtk_box_pack_start( GTK_BOX(midiinfoboxes_vbox) , info_frame , TRUE , TRUE , 0 );
info_grid = gtk_grid_new();
gtk_grid_set_row_spacing( GTK_GRID(info_grid) , 4 );
gtk_grid_set_column_spacing( GTK_GRID(info_grid) , 10 );
gtk_container_set_border_width( GTK_CONTAINER(info_grid) , 3 );
gtk_container_add( GTK_CONTAINER(info_frame) , info_grid );
value_gstring = g_string_new( "" );
/* midi format */
G_STRING_PRINTF( value_gstring , "type %i" , mf->format );
i_fileinfo_grid_add_entry( _("Format:") , value_gstring->str , info_grid , 0 , pangoattrlist );
/* midi length */
G_STRING_PRINTF( value_gstring , "%i" , (gint)(mf->length / 1000) );
i_fileinfo_grid_add_entry( _("Length (msec):") , value_gstring->str , info_grid , 1 , pangoattrlist );
/* midi num of tracks */
G_STRING_PRINTF( value_gstring , "%i" , mf->num_tracks );
i_fileinfo_grid_add_entry( _("No. of Tracks:") , value_gstring->str , info_grid , 2 , pangoattrlist );
/* midi bpm */
if ( bpm > 0 )
G_STRING_PRINTF( value_gstring , "%i" , bpm ); /* fixed bpm */
else
G_STRING_PRINTF( value_gstring , _("variable") ); /* variable bpm */
i_fileinfo_grid_add_entry( _("BPM:") , value_gstring->str , info_grid , 3 , pangoattrlist );
/* midi weighted average bpm */
if ( bpm > 0 )
G_STRING_PRINTF( value_gstring , "/" ); /* fixed bpm, don't care about wavg_bpm */
else
G_STRING_PRINTF( value_gstring , "%i" , wavg_bpm ); /* variable bpm, display wavg_bpm */
i_fileinfo_grid_add_entry( _("BPM (wavg):") , value_gstring->str , info_grid , 4 , pangoattrlist );
/* midi time division */
G_STRING_PRINTF( value_gstring , "%i" , mf->time_division );
i_fileinfo_grid_add_entry( _("Time Div:") , value_gstring->str , info_grid , 5 , pangoattrlist );
g_string_free( value_gstring , TRUE );
/**********************************
*** MIDI COMMENTS/LYRICS BOXES ***/
miditextboxes_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2 );
gtk_box_pack_start( GTK_BOX(fileinfowin_columns_hbox) , miditextboxes_vbox , TRUE , TRUE , 0 );
text_frame_tl = gtk_label_new( "" );
gtk_label_set_markup( GTK_LABEL(text_frame_tl) ,
_("<span size=\"smaller\"> MIDI Comments and Lyrics </span>") );
gtk_box_pack_start( GTK_BOX(miditextboxes_vbox) , text_frame_tl , FALSE , FALSE , 0 );
miditextboxes_paned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start( GTK_BOX(miditextboxes_vbox) , miditextboxes_paned , TRUE , TRUE , 0 );
text_frame = gtk_frame_new( NULL );
gtk_paned_pack1( GTK_PANED(miditextboxes_paned) , text_frame , TRUE , TRUE );
text_tv = gtk_text_view_new();
gtk_text_view_set_editable( GTK_TEXT_VIEW(text_tv) , FALSE );
gtk_text_view_set_cursor_visible( GTK_TEXT_VIEW(text_tv) , FALSE );
gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW(text_tv) , GTK_WRAP_WORD );
gtk_text_view_set_right_margin( GTK_TEXT_VIEW(text_tv) , 4 );
gtk_text_view_set_left_margin( GTK_TEXT_VIEW(text_tv) , 4 );
gtk_widget_set_size_request( text_tv , 300 , 113 );
text_tv_sw = gtk_scrolled_window_new( NULL , NULL );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(text_tv_sw) ,
GTK_POLICY_AUTOMATIC , GTK_POLICY_ALWAYS );
gtk_container_add( GTK_CONTAINER(text_frame) , text_tv_sw );
gtk_container_add( GTK_CONTAINER(text_tv_sw) , text_tv );
lyrics_frame = gtk_frame_new( NULL );
gtk_paned_pack2( GTK_PANED(miditextboxes_paned) , lyrics_frame , TRUE , TRUE );
lyrics_tv = gtk_text_view_new();
gtk_text_view_set_editable( GTK_TEXT_VIEW(lyrics_tv) , FALSE );
gtk_text_view_set_cursor_visible( GTK_TEXT_VIEW(lyrics_tv) , FALSE );
gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW(lyrics_tv) , GTK_WRAP_WORD );
gtk_text_view_set_right_margin( GTK_TEXT_VIEW(lyrics_tv) , 4 );
gtk_text_view_set_left_margin( GTK_TEXT_VIEW(lyrics_tv) , 4 );
gtk_widget_set_size_request( lyrics_tv , 300 , 113 );
lyrics_tv_sw = gtk_scrolled_window_new( NULL , NULL );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(lyrics_tv_sw) ,
GTK_POLICY_AUTOMATIC , GTK_POLICY_ALWAYS );
gtk_container_add( GTK_CONTAINER(lyrics_frame) , lyrics_tv_sw );
gtk_container_add( GTK_CONTAINER(lyrics_tv_sw) , lyrics_tv );
text_tb = gtk_text_view_get_buffer( GTK_TEXT_VIEW(text_tv) );
lyrics_tb = gtk_text_view_get_buffer( GTK_TEXT_VIEW(lyrics_tv) );
/* call the buffer fill routine if at least one between comments and lyrics is enabled */
if (( amidiplug_cfg_ap.ap_opts_comments_extract > 0 ) ||
( amidiplug_cfg_ap.ap_opts_lyrics_extract > 0 ))
i_fileinfo_text_fill( mf , text_tb , lyrics_tb );
if (( amidiplug_cfg_ap.ap_opts_comments_extract > 0 ) &&
( gtk_text_buffer_get_char_count( text_tb ) == 0 ))
{
GtkTextIter start, end;
GtkTextTag *tag = gtk_text_buffer_create_tag( text_tb , "italicstyle" ,
"style" , PANGO_STYLE_ITALIC , NULL );
/*gtk_text_view_set_justification( GTK_TEXT_VIEW(text_tv) , GTK_JUSTIFY_CENTER );*/
gtk_text_buffer_set_text( text_tb , _("* no comments available in this MIDI file *") , -1 );
gtk_text_buffer_get_iter_at_offset( text_tb , &start , 0 );
gtk_text_buffer_get_iter_at_offset( text_tb , &end , -1 );
gtk_text_buffer_apply_tag( text_tb , tag , &start , &end );
}
if (( amidiplug_cfg_ap.ap_opts_lyrics_extract > 0 ) &&
( gtk_text_buffer_get_char_count( lyrics_tb ) == 0 ))
{
GtkTextIter start, end;
GtkTextTag *tag = gtk_text_buffer_create_tag( lyrics_tb , "italicstyle" ,
"style" , PANGO_STYLE_ITALIC , NULL );
/*gtk_text_view_set_justification( GTK_TEXT_VIEW(lyrics_tv) , GTK_JUSTIFY_CENTER );*/
gtk_text_buffer_set_text( lyrics_tb , _("* no lyrics available in this MIDI file *") , -1 );
gtk_text_buffer_get_iter_at_offset( lyrics_tb , &start , 0 );
gtk_text_buffer_get_iter_at_offset( lyrics_tb , &end , -1 );
gtk_text_buffer_apply_tag( lyrics_tb , tag , &start , &end );
}
/* hide boxes for disabled options (comments and/or lyrics) */
if (( amidiplug_cfg_ap.ap_opts_comments_extract == 0 ) &&
( amidiplug_cfg_ap.ap_opts_lyrics_extract == 0 ))
{
gtk_widget_set_no_show_all( miditextboxes_vbox , TRUE );
gtk_widget_hide( miditextboxes_vbox );
}
else if ( amidiplug_cfg_ap.ap_opts_comments_extract == 0 )
{
gtk_widget_set_no_show_all( text_frame , TRUE );
gtk_widget_hide( text_frame );
}
else if ( amidiplug_cfg_ap.ap_opts_lyrics_extract == 0 )
{
gtk_widget_set_no_show_all( lyrics_frame , TRUE );
gtk_widget_hide( lyrics_frame );
}
/**************
*** FOOTER ***/
footer_hbbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_button_box_set_layout( GTK_BUTTON_BOX(footer_hbbox) , GTK_BUTTONBOX_END );
footer_bclose = gtk_button_new_from_stock( GTK_STOCK_CLOSE );
g_signal_connect( G_OBJECT(footer_bclose) , "clicked" , G_CALLBACK(i_fileinfo_ev_close) , fileinfowin );
gtk_container_add( GTK_CONTAINER(footer_hbbox) , footer_bclose );
gtk_box_pack_start( GTK_BOX(fileinfowin_vbox) , footer_hbbox , FALSE , FALSE , 0 );
/* utf8-ize filename and set window title */
filename = g_filename_from_uri( filename_uri , NULL , NULL );
if ( !filename )
filename = g_strdup( filename_uri );
filename_utf8 = g_strdup(g_filename_to_utf8( filename , -1 , NULL , NULL , NULL ));
if ( !filename_utf8 )
{
/* utf8 fallback */
gchar *chr , *convert_str = g_strdup( filename );
for ( chr = convert_str ; *chr ; chr++ )
{
if ( *chr & 0x80 )
*chr = '?';
}
filename_utf8 = g_strconcat( convert_str , _(" (invalid UTF-8)") , NULL );
g_free(convert_str);
}
title = g_path_get_basename (filename_utf8);
gtk_window_set_title( GTK_WINDOW(fileinfowin) , title);
g_free(title);
/* set the text for the filename header too */
gtk_entry_set_text( GTK_ENTRY(title_name_v_entry) , filename_utf8 );
gtk_editable_set_position( GTK_EDITABLE(title_name_v_entry) , -1 );
g_free(filename_utf8);
g_free(filename);
gtk_widget_grab_focus( GTK_WIDGET(footer_bclose) );
gtk_widget_show_all( fileinfowin );
}
/*
* Public API
*/
GtkWidget *
addressbook_window_new (boost::shared_ptr<Ekiga::ContactCore> core)
{
AddressBookWindow *self = NULL;
boost::signals::connection conn;
GtkWidget *menu_bar = NULL;
GtkWidget *frame = NULL;
GtkWidget *vbox = NULL;
GtkWidget *hpaned = NULL;
GtkCellRenderer *cell = NULL;
GtkTreeViewColumn *column = NULL;
GtkTreeStore *store = NULL;
self = (AddressBookWindow *) g_object_new (ADDRESSBOOK_WINDOW_TYPE, NULL);
self->priv = new AddressBookWindowPrivate (core);
gtk_window_set_title (GTK_WINDOW (self), _("Address Book"));
gtk_window_set_position (GTK_WINDOW (self), GTK_WIN_POS_CENTER);
gtk_window_set_icon_name (GTK_WINDOW (self), "x-office-address-book");
/* Start building the window */
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
/* The menu */
menu_bar = gtk_menu_bar_new ();
self->priv->accel = gtk_accel_group_new ();
gtk_window_add_accel_group (GTK_WINDOW (self), self->priv->accel);
g_object_unref (self->priv->accel);
self->priv->menu_item_core =
gtk_menu_item_new_with_mnemonic (_("Address _Book"));
gtk_menu_shell_append (GTK_MENU_SHELL (menu_bar),
self->priv->menu_item_core);
g_object_ref (self->priv->menu_item_core);
conn = core->updated.connect (boost::bind (&on_core_updated,
(gpointer) self));
self->priv->connections.add (conn);
on_core_updated (self); // This will add static and dynamic actions
self->priv->menu_item_view = gtk_menu_item_new_with_mnemonic (_("_Action"));
gtk_widget_set_sensitive (self->priv->menu_item_view, FALSE);
gtk_menu_shell_append (GTK_MENU_SHELL (menu_bar),
self->priv->menu_item_view);
g_object_ref (self->priv->menu_item_view);
gtk_container_add (GTK_CONTAINER (vbox), menu_bar);
gtk_box_set_child_packing (GTK_BOX (vbox), menu_bar,
FALSE, FALSE, 2, GTK_PACK_START);
gtk_container_add (GTK_CONTAINER (self), vbox);
/* A hpaned to put the list of Books and their content */
hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_container_set_border_width (GTK_CONTAINER (hpaned), 6);
gtk_container_add (GTK_CONTAINER (vbox), hpaned);
gtk_box_set_child_packing (GTK_BOX (vbox), hpaned,
TRUE, TRUE, 0, GTK_PACK_START);
/* The store listing the Books */
frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
store = gtk_tree_store_new (NUM_COLUMNS,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_POINTER,
G_TYPE_OBJECT);
self->priv->tree_view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
g_object_unref (store);
gtk_container_add (GTK_CONTAINER (frame), self->priv->tree_view);
gtk_widget_set_size_request (GTK_WIDGET (self->priv->tree_view), 185, -1);
gtk_paned_pack1 (GTK_PANED (hpaned), frame, TRUE, TRUE);
/* Several renderers for one column */
column = gtk_tree_view_column_new ();
cell = gtk_cell_renderer_pixbuf_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_add_attribute (column, cell,
"icon-name", COLUMN_PIXBUF);
cell = gtk_cell_renderer_text_new ();
gtk_tree_view_column_pack_start (column, cell, FALSE);
gtk_tree_view_column_set_attributes (column, cell,
"text", COLUMN_NAME,
NULL);
gtk_tree_view_column_set_title (column, _("Category"));
gtk_tree_view_column_set_sort_column_id (column, COLUMN_NAME);
gtk_tree_view_column_set_sizing (GTK_TREE_VIEW_COLUMN (column),
GTK_TREE_VIEW_COLUMN_AUTOSIZE);
gtk_tree_view_column_set_resizable (GTK_TREE_VIEW_COLUMN (column), true);
gtk_tree_view_append_column (GTK_TREE_VIEW (self->priv->tree_view),
GTK_TREE_VIEW_COLUMN (column));
self->priv->selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (self->priv->tree_view));
gtk_tree_selection_set_mode (GTK_TREE_SELECTION (self->priv->selection),
GTK_SELECTION_SINGLE);
g_signal_connect (self->priv->selection, "changed",
G_CALLBACK (on_book_selection_changed), self);
g_signal_connect (self->priv->tree_view, "event-after",
G_CALLBACK (on_book_clicked), self);
/* The notebook containing the books */
self->priv->notebook = gtk_notebook_new ();
gtk_notebook_set_show_tabs (GTK_NOTEBOOK (self->priv->notebook), FALSE);
g_signal_connect (self->priv->notebook, "realize",
G_CALLBACK (on_notebook_realize), self);
gtk_paned_pack2 (GTK_PANED (hpaned), self->priv->notebook, TRUE, TRUE);
conn = core->source_added.connect (boost::bind (&on_source_added, _1, (gpointer) self));
self->priv->connections.add (conn);
conn = core->book_updated.connect (boost::bind (&on_book_updated, _1, _2,
(gpointer) self));
self->priv->connections.add (conn);
conn = core->book_added.connect (boost::bind (&on_book_added, _1, _2,
(gpointer) self));
self->priv->connections.add (conn);
conn =
core->book_removed.connect (boost::bind (&on_book_removed, _1, _2,
(gpointer) self));
self->priv->connections.add (conn);
conn = core->questions.connect (boost::bind (&on_handle_questions, _1, (gpointer) self));
self->priv->connections.add (conn);
core->visit_sources (boost::bind (on_visit_sources, _1, (gpointer) self));
return GTK_WIDGET (self);
}
void
browser_dialog_open (const gchar *plug_in_binary)
{
GtkWidget *window;
GtkWidget *main_vbox;
GtkWidget *vbox;
GtkWidget *toolbar;
GtkWidget *paned;
GtkWidget *scrolled;
GtkToolItem *item;
GtkAction *action;
DialogData data = { 720, 560, 240, TRUE, 1.0 };
gimp_ui_init (plug_in_binary, TRUE);
gimp_get_data (GIMP_HELP_BROWSER_DIALOG_DATA, &data);
/* the dialog window */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), _("GIMP Help Browser"));
gtk_window_set_role (GTK_WINDOW (window), plug_in_binary);
gtk_window_set_default_size (GTK_WINDOW (window), data.width, data.height);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_main_quit),
NULL);
window_set_icons (window);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
gtk_container_add (GTK_CONTAINER (window), vbox);
gtk_widget_show (vbox);
ui_manager = ui_manager_new (window);
toolbar = gtk_ui_manager_get_widget (ui_manager, "/help-browser-toolbar");
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS);
gtk_box_pack_start (GTK_BOX (vbox), toolbar, FALSE, FALSE, 0);
gtk_widget_show (toolbar);
item = g_object_new (GTK_TYPE_MENU_TOOL_BUTTON, NULL);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, 0);
gtk_widget_show (GTK_WIDGET (item));
action = gtk_ui_manager_get_action (ui_manager,
"/ui/help-browser-popup/forward");
gtk_activatable_set_related_action (GTK_ACTIVATABLE (item), action);
g_object_notify (G_OBJECT (action), "tooltip");
button_next = GTK_WIDGET (item);
item = g_object_new (GTK_TYPE_MENU_TOOL_BUTTON, NULL);
gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, 0);
gtk_widget_show (GTK_WIDGET (item));
action = gtk_ui_manager_get_action (ui_manager,
"/ui/help-browser-popup/back");
gtk_activatable_set_related_action (GTK_ACTIVATABLE (item), action);
g_object_notify (G_OBJECT (action), "tooltip");
button_prev = GTK_WIDGET (item);
item =
GTK_TOOL_ITEM (gtk_ui_manager_get_widget (ui_manager,
"/help-browser-toolbar/space"));
gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (item), FALSE);
gtk_tool_item_set_expand (item, TRUE);
/* the horizontal paned */
paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (vbox), paned, TRUE, TRUE, 0);
gtk_widget_show (paned);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_paned_add1 (GTK_PANED (paned), scrolled);
gtk_paned_set_position (GTK_PANED (paned), data.paned_position);
sidebar = scrolled;
if (data.show_index)
gtk_widget_show (sidebar);
tree_view = gtk_tree_view_new ();
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE);
gtk_container_add (GTK_CONTAINER (scrolled), tree_view);
gtk_widget_show (tree_view);
gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view), -1,
NULL,
gtk_cell_renderer_text_new (),
"text", 1,
NULL);
g_signal_connect (tree_view, "row-activated",
G_CALLBACK (row_activated),
NULL);
/* HTML view */
main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show (main_vbox);
gtk_paned_pack2 (GTK_PANED (paned), main_vbox, TRUE, TRUE);
scrolled = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request (scrolled, 300, 200);
gtk_box_pack_start (GTK_BOX (main_vbox), scrolled, TRUE, TRUE, 0);
gtk_widget_show (scrolled);
view = webkit_web_view_new ();
webkit_web_view_set_maintains_back_forward_list (WEBKIT_WEB_VIEW (view),
TRUE);
gtk_container_add (GTK_CONTAINER (scrolled), view);
gtk_widget_show (view);
g_signal_connect (view, "realize",
G_CALLBACK (view_realize),
NULL);
g_signal_connect (view, "unrealize",
G_CALLBACK (view_unrealize),
NULL);
g_signal_connect (view, "popup-menu",
G_CALLBACK (view_popup_menu),
NULL);
g_signal_connect (view, "button-press-event",
G_CALLBACK (view_button_press),
NULL);
g_signal_connect (view, "key-press-event",
G_CALLBACK (view_key_press),
NULL);
webkit_web_view_set_zoom_level (WEBKIT_WEB_VIEW (view), data.zoom);
g_signal_connect (view, "title-changed",
G_CALLBACK (title_changed),
window);
g_signal_connect (view, "load-started",
G_CALLBACK (load_started),
NULL);
g_signal_connect (view, "load-finished",
G_CALLBACK (load_finished),
NULL);
gtk_widget_grab_focus (view);
g_signal_connect (window, "unmap",
G_CALLBACK (dialog_unmap),
paned);
update_actions ();
/* Searchbar */
searchbar = build_searchbar ();
gtk_box_pack_start (GTK_BOX (main_vbox), searchbar, FALSE, FALSE, 0);
}
/* engineering_init */
static Engineering * _engineering_init(PhonePluginHelper * helper)
{
Engineering * engineering;
GtkWidget * vbox;
GtkWidget * toolbar;
GtkWidget * paned;
GtkWidget * frame;
GtkWidget * scrolled;
size_t i;
GtkCellRenderer * renderer;
GtkTreeViewColumn * column;
if((engineering = object_new(sizeof(*engineering))) == NULL)
return NULL;
engineering->helper = helper;
engineering->source = 0;
engineering->enci = 0;
engineering->enci_cnt = 0;
/* widgets */
/* window */
engineering->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(engineering->window), 200, 300);
#if GTK_CHECK_VERSION(2, 6, 0)
gtk_window_set_icon_name(GTK_WINDOW(engineering->window),
"stock_compile");
#endif
gtk_window_set_title(GTK_WINDOW(engineering->window),
"Engineering mode");
g_signal_connect_swapped(engineering->window, "delete-event",
G_CALLBACK(_on_engineering_closex), engineering);
#if GTK_CHECK_VERSION(3, 0, 0)
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
#else
vbox = gtk_vbox_new(FALSE, 0);
#endif
/* toolbar */
toolbar = gtk_toolbar_new();
engineering->tb_play = gtk_toggle_tool_button_new_from_stock(
GTK_STOCK_MEDIA_PLAY);
g_signal_connect_swapped(G_OBJECT(engineering->tb_play), "toggled",
G_CALLBACK(_on_engineering_play_toggled), engineering);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), engineering->tb_play, -1);
engineering->tb_fullscreen = gtk_toggle_tool_button_new_from_stock(
GTK_STOCK_FULLSCREEN);
g_signal_connect_swapped(engineering->tb_fullscreen, "toggled",
G_CALLBACK(_on_engineering_fullscreen_toggled),
engineering);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), engineering->tb_fullscreen,
-1);
gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, TRUE, 0);
/* serving cell view */
#if GTK_CHECK_VERSION(3, 0, 0)
paned = gtk_paned_new(GTK_ORIENTATION_VERTICAL);
#else
paned = gtk_vpaned_new();
#endif
frame = gtk_frame_new("Serving cell");
engineering->sc_store = gtk_list_store_new(SC_COL_COUNT,
G_TYPE_STRING, /* SC_COL_FREQUENCY */
G_TYPE_STRING, /* SC_COL_C1 */
G_TYPE_STRING, /* SC_COL_C2 */
G_TYPE_STRING, /* SC_COL_RX_LEVEL */
G_TYPE_STRING, /* SC_COL_STATION_ID */
G_TYPE_STRING, /* SC_COL_CELL_ID */
G_TYPE_STRING, /* SC_COL_TX_LEVEL */
G_TYPE_STRING, /* SC_COL_TIMESLOT_NUMBER */
G_TYPE_STRING, /* SC_COL_LAC */
G_TYPE_STRING); /* SC_COL_TMSI */
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
engineering->sc_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(
engineering->sc_store));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(engineering->sc_view), TRUE);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(
engineering->sc_view)),
GTK_SELECTION_NONE);
/* columns */
for(i = 0; _engineering_sc_columns[i].title != NULL; i++)
{
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(
_engineering_sc_columns[i].title, renderer,
"text", _engineering_sc_columns[i].col, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(engineering->sc_view),
column);
}
gtk_container_add(GTK_CONTAINER(scrolled), engineering->sc_view);
gtk_container_add(GTK_CONTAINER(frame), scrolled);
gtk_container_set_border_width(GTK_CONTAINER(frame), 4);
gtk_paned_add1(GTK_PANED(paned), frame);
/* neighbor cells view */
frame = gtk_frame_new("Neighbor cells");
engineering->nc_store = gtk_list_store_new(NC_COL_COUNT,
G_TYPE_STRING, /* NC_COL_FREQUENCY */
G_TYPE_STRING, /* NC_COL_C1 */
G_TYPE_STRING, /* NC_COL_C2 */
G_TYPE_STRING, /* NC_COL_RXLEV */
G_TYPE_STRING, /* NC_COL_BSIC */
G_TYPE_STRING, /* NC_COL_CELL_ID */
G_TYPE_STRING, /* NC_COL_LAC */
G_TYPE_STRING, /* NC_COL_FRAME_OFFSET */
G_TYPE_STRING, /* NC_COL_CBA */
G_TYPE_STRING, /* NC_COL_CBQ */
G_TYPE_STRING, /* NC_COL_CELL_TYPE_IND */
G_TYPE_STRING); /* NC_COL_RAC */
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
engineering->nc_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(
engineering->nc_store));
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(engineering->nc_view), TRUE);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(
engineering->nc_view)),
GTK_SELECTION_NONE);
/* columns */
for(i = 0; _engineering_nc_columns[i].title != NULL; i++)
{
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(
_engineering_nc_columns[i].title, renderer,
"text", _engineering_nc_columns[i].col, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(engineering->nc_view),
column);
}
gtk_container_add(GTK_CONTAINER(scrolled), engineering->nc_view);
gtk_container_add(GTK_CONTAINER(frame), scrolled);
gtk_container_set_border_width(GTK_CONTAINER(frame), 4);
gtk_container_add(GTK_CONTAINER(engineering->window), vbox);
gtk_paned_add2(GTK_PANED(paned), frame);
gtk_box_pack_start(GTK_BOX(vbox), paned, TRUE, TRUE, 0);
gtk_widget_show_all(engineering->window);
/* trigger */
#if 0 /* FIXME reimplement using an extension to the Hayes modem plug-in */
helper->register_trigger(helper->phone, plugin, "%EM",
_on_engineering_trigger_em);
#endif
return engineering;
}
GtkWidget *
do_css_pixbufs (GtkWidget *do_widget)
{
static GtkWidget *window = NULL;
if (!window)
{
GtkWidget *paned, *container, *child;
GtkStyleProvider *provider;
GtkTextBuffer *text;
GBytes *bytes;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Animated Backgrounds");
gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (do_widget));
gtk_window_set_default_size (GTK_WINDOW (window), 400, 300);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed), &window);
paned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_container_add (GTK_CONTAINER (window), paned);
/* Need a filler so we get a handle */
child = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (paned), child);
text = gtk_text_buffer_new (NULL);
gtk_text_buffer_create_tag (text,
"warning",
"underline", PANGO_UNDERLINE_SINGLE,
NULL);
gtk_text_buffer_create_tag (text,
"error",
"underline", PANGO_UNDERLINE_ERROR,
NULL);
provider = GTK_STYLE_PROVIDER (gtk_css_provider_new ());
container = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (paned), container);
child = gtk_text_view_new_with_buffer (text);
gtk_container_add (GTK_CONTAINER (container), child);
g_signal_connect (text, "changed",
G_CALLBACK (css_text_changed), provider);
bytes = g_resources_lookup_data ("/css_pixbufs/gtk.css", 0, NULL);
gtk_text_buffer_set_text (text, g_bytes_get_data (bytes, NULL), g_bytes_get_size (bytes));
g_bytes_unref (bytes);
g_signal_connect (provider,
"parsing-error",
G_CALLBACK (show_parsing_error),
gtk_text_view_get_buffer (GTK_TEXT_VIEW (child)));
apply_css (window, provider);
}
if (!gtk_widget_get_visible (window))
gtk_widget_show_all (window);
else
gtk_widget_destroy (window);
return window;
}
static int _console(void)
{
/* FIXME allocate dynamically */
static Console console;
PangoFontDescription * desc;
GtkWidget * vbox;
GtkWidget * menuitem;
GtkWidget * menu;
GtkToolItem * toolitem;
GtkWidget * paned;
GtkWidget * widget;
desc = pango_font_description_new();
pango_font_description_set_family(desc, "Monospace");
console.window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(console.window), 400, 300);
gtk_window_set_title(GTK_WINDOW(console.window), "PHP Console");
g_signal_connect_swapped(console.window, "delete-event",
G_CALLBACK(_console_on_closex), NULL);
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
/* menu bar */
widget = gtk_menu_bar_new();
/* menu bar: file */
menuitem = gtk_menu_item_new_with_mnemonic("_File");
gtk_menu_shell_append(GTK_MENU_SHELL(widget), menuitem);
menu = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), menu);
menuitem = gtk_menu_item_new_with_mnemonic("_Run");
g_signal_connect_swapped(menuitem, "activate",
G_CALLBACK(_console_on_execute), &console);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
menuitem = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
menuitem = gtk_menu_item_new_with_mnemonic("C_lear");
g_signal_connect_swapped(menuitem, "activate",
G_CALLBACK(_console_on_clear), &console);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
menuitem = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
menuitem = gtk_menu_item_new_with_mnemonic("_Close");
g_signal_connect_swapped(menuitem, "activate",
G_CALLBACK(_console_on_close), NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
/* menu bar: help */
menuitem = gtk_menu_item_new_with_mnemonic("_Help");
gtk_menu_shell_append(GTK_MENU_SHELL(widget), menuitem);
menu = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), menu);
menuitem = gtk_menu_item_new_with_mnemonic("_About");
g_signal_connect_swapped(menuitem, "activate",
G_CALLBACK(_console_on_about), &console);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, TRUE, 0);
/* toolbar */
widget = gtk_toolbar_new();
toolitem = gtk_tool_button_new_from_stock(GTK_STOCK_EXECUTE);
g_signal_connect_swapped(toolitem, "clicked",
G_CALLBACK(_console_on_execute), &console);
gtk_toolbar_insert(GTK_TOOLBAR(widget), toolitem, -1);
toolitem = gtk_tool_button_new_from_stock(GTK_STOCK_CLEAR);
g_signal_connect_swapped(toolitem, "clicked",
G_CALLBACK(_console_on_clear), &console);
gtk_toolbar_insert(GTK_TOOLBAR(widget), toolitem, -1);
gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, TRUE, 0);
/* paned */
paned = gtk_paned_new(GTK_ORIENTATION_VERTICAL);
widget = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
console.code = gtk_text_view_new();
gtk_widget_override_font(console.code, desc);
gtk_container_add(GTK_CONTAINER(widget), console.code);
gtk_paned_add1(GTK_PANED(paned), widget);
widget = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
console.console = gtk_text_view_new();
gtk_widget_override_font(console.console, desc);
gtk_text_view_set_editable(GTK_TEXT_VIEW(console.console), FALSE);
gtk_container_add(GTK_CONTAINER(widget), console.console);
gtk_paned_add2(GTK_PANED(paned), widget);
gtk_paned_set_position(GTK_PANED(paned), 150);
gtk_box_pack_start(GTK_BOX(vbox), paned, TRUE, TRUE, 0);
/* statusbar */
widget = gtk_statusbar_new();
gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(console.window), vbox);
gtk_widget_show_all(console.window);
return 0;
}
static void
set_up (EmpathyIndividualLinker *self)
{
EmpathyIndividualLinkerPriv *priv;
EmpathyIndividualManager *individual_manager;
GtkWidget *top_vbox;
GtkPaned *paned;
GtkWidget *label, *scrolled_window;
GtkBox *vbox;
EmpathyPersonaView *persona_view;
gchar *tmp;
GtkWidget *alignment;
priv = GET_PRIV (self);
top_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
/* Layout panes */
paned = GTK_PANED (gtk_paned_new (GTK_ORIENTATION_HORIZONTAL));
/* Left column heading */
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 0, 6);
gtk_widget_show (alignment);
vbox = GTK_BOX (gtk_box_new (GTK_ORIENTATION_VERTICAL, 6));
label = gtk_label_new (NULL);
tmp = g_strdup_printf ("<b>%s</b>", _("Select contacts to link"));
gtk_label_set_markup (GTK_LABEL (label), tmp);
g_free (tmp);
gtk_box_pack_start (vbox, label, FALSE, TRUE, 0);
gtk_widget_show (label);
/* Individual selector */
individual_manager = empathy_individual_manager_dup_singleton ();
priv->individual_store = EMPATHY_INDIVIDUAL_STORE (
empathy_individual_store_manager_new (individual_manager));
g_object_unref (individual_manager);
empathy_individual_store_set_show_protocols (priv->individual_store, FALSE);
priv->individual_view = empathy_individual_view_new (priv->individual_store,
EMPATHY_INDIVIDUAL_VIEW_FEATURE_INDIVIDUAL_DRAG |
EMPATHY_INDIVIDUAL_VIEW_FEATURE_INDIVIDUAL_DROP |
EMPATHY_INDIVIDUAL_VIEW_FEATURE_PERSONA_DROP,
EMPATHY_INDIVIDUAL_FEATURE_NONE);
empathy_individual_view_set_show_offline (priv->individual_view, TRUE);
empathy_individual_view_set_show_untrusted (priv->individual_view, FALSE);
g_signal_connect (priv->individual_view, "row-activated",
(GCallback) row_activated_cb, self);
g_signal_connect (priv->individual_view, "drag-motion",
(GCallback) individual_view_drag_motion_cb, self);
g_signal_connect (priv->individual_view, "drag-persona-received",
(GCallback) individual_view_drag_persona_received_cb, self);
/* Add a checkbox column to the selector */
priv->toggle_renderer = gtk_cell_renderer_toggle_new ();
g_signal_connect (priv->toggle_renderer, "toggled",
(GCallback) row_toggled_cb, self);
priv->toggle_column = gtk_tree_view_column_new ();
gtk_tree_view_column_pack_start (priv->toggle_column, priv->toggle_renderer,
FALSE);
gtk_tree_view_column_set_cell_data_func (priv->toggle_column,
priv->toggle_renderer,
(GtkTreeCellDataFunc) contact_toggle_cell_data_func, self, NULL);
gtk_tree_view_insert_column (GTK_TREE_VIEW (priv->individual_view),
priv->toggle_column, 0);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (scrolled_window),
GTK_WIDGET (priv->individual_view));
gtk_widget_show (GTK_WIDGET (priv->individual_view));
gtk_box_pack_start (vbox, scrolled_window, TRUE, TRUE, 0);
gtk_widget_show (scrolled_window);
/* Live search */
priv->search_widget = empathy_live_search_new (
GTK_WIDGET (priv->individual_view));
empathy_individual_view_set_live_search (priv->individual_view,
EMPATHY_LIVE_SEARCH (priv->search_widget));
gtk_box_pack_end (vbox, priv->search_widget, FALSE, TRUE, 0);
gtk_container_add (GTK_CONTAINER (alignment), GTK_WIDGET (vbox));
gtk_paned_pack1 (paned, alignment, TRUE, FALSE);
gtk_widget_show (GTK_WIDGET (vbox));
/* Right column heading */
alignment = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 6, 0);
gtk_widget_show (alignment);
vbox = GTK_BOX (gtk_box_new (GTK_ORIENTATION_VERTICAL, 6));
label = gtk_label_new (NULL);
tmp = g_strdup_printf ("<b>%s</b>", _("New contact preview"));
gtk_label_set_markup (GTK_LABEL (label), tmp);
g_free (tmp);
gtk_box_pack_start (vbox, label, FALSE, TRUE, 0);
gtk_widget_show (label);
/* New individual preview */
priv->preview_widget = empathy_individual_widget_new (priv->new_individual,
EMPATHY_INDIVIDUAL_WIDGET_SHOW_DETAILS);
gtk_box_pack_start (vbox, priv->preview_widget, FALSE, TRUE, 0);
gtk_widget_show (priv->preview_widget);
/* Persona list */
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_SHADOW_IN);
priv->persona_store = empathy_persona_store_new (priv->new_individual);
empathy_persona_store_set_show_protocols (priv->persona_store, TRUE);
persona_view = empathy_persona_view_new (priv->persona_store,
EMPATHY_PERSONA_VIEW_FEATURE_ALL);
empathy_persona_view_set_show_offline (persona_view, TRUE);
g_signal_connect (persona_view, "drag-individual-received",
(GCallback) persona_view_drag_individual_received_cb, self);
gtk_container_add (GTK_CONTAINER (scrolled_window),
GTK_WIDGET (persona_view));
gtk_widget_show (GTK_WIDGET (persona_view));
gtk_box_pack_start (vbox, scrolled_window, TRUE, TRUE, 0);
gtk_widget_show (scrolled_window);
gtk_container_add (GTK_CONTAINER (alignment), GTK_WIDGET (vbox));
gtk_paned_pack2 (paned, alignment, TRUE, FALSE);
gtk_widget_show (GTK_WIDGET (vbox));
gtk_widget_show (GTK_WIDGET (paned));
/* Footer label */
label = gtk_label_new (NULL);
tmp = g_strdup_printf ("<i>%s</i>",
_("Contacts selected in the list on the left will be linked together."));
gtk_label_set_markup (GTK_LABEL (label), tmp);
g_free (tmp);
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (top_vbox), GTK_WIDGET (paned), TRUE, TRUE, 0);
gtk_box_pack_start (GTK_BOX (top_vbox), label, FALSE, TRUE, 0);
/* Add the main vbox to the bin */
gtk_box_pack_start (GTK_BOX (self), GTK_WIDGET (top_vbox), TRUE, TRUE, 0);
gtk_widget_show (GTK_WIDGET (top_vbox));
}
//____________________________________________________
ListDemoWidget::ListDemoWidget( void )
{
// main widget
GtkWidget* mainWidget( gtk_box_new( GTK_ORIENTATION_VERTICAL, 0 ) );
gtk_box_set_spacing( GTK_BOX( mainWidget ), 5 );
setWidget( mainWidget );
// setup
setName( "Lists" );
setComments( "Shows the appearance of lists and trees" );
setIconName( "view-list-tree" );
realize();
// vertical pane
GtkWidget* vpaned( gtk_paned_new( GTK_ORIENTATION_VERTICAL ) );
gtk_widget_show( vpaned );
gtk_box_pack_start( GTK_BOX( mainWidget ), vpaned, true, true, 0 );
// simple list
{
GtkListStore* model( gtk_list_store_new( 1, G_TYPE_STRING ) );
const char* columns[] =
{
"First Item",
"Second Item",
"Third Item"
};
for( unsigned int i=0; i<3; i++ )
{
GtkTreeIter iter;
gtk_list_store_append( model, &iter );
gtk_list_store_set( model, &iter, 0, columns[i], -1 );
}
GtkWidget* treeView( gtk_tree_view_new_with_model( GTK_TREE_MODEL( model ) ) );
gtk_tree_view_set_headers_visible( GTK_TREE_VIEW( treeView ), false );
gtk_widget_show( treeView );
// renderer
GtkCellRenderer *renderer( gtk_cell_renderer_text_new() );
GtkTreeViewColumn *column( gtk_tree_view_column_new_with_attributes( "", renderer, "text", 0, NULL ) );
gtk_tree_view_append_column( GTK_TREE_VIEW( treeView ), column );
// scrolled window
GtkWidget* scrolledWindow( gtk_scrolled_window_new( 0L, 0L ) );
gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( scrolledWindow ), GTK_SHADOW_IN );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolledWindow ), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
gtk_container_add( GTK_CONTAINER( scrolledWindow ), treeView );
gtk_widget_show( scrolledWindow );
gtk_paned_pack1( GTK_PANED( vpaned ), scrolledWindow, true, true );
}
// tree
{
GtkTreeStore* model( gtk_tree_store_new ( 2, G_TYPE_STRING, G_TYPE_STRING ) );
const char* titleColumns[] =
{
"First Item",
"Second Item",
"Third Item"
};
const char* descriptionColumns[] =
{
"First Description",
"Second Description",
"Third Description"
};
const char* subTitleColumns[] =
{
"First Subitem",
"Second Subitem",
"Third Subitem"
};
const char* subDescriptionColumns[] =
{
"First Subitem Description",
"Second Subitem Description",
"Third Subitem Description"
};
for( unsigned int i=0; i<3; i++ )
{
GtkTreeIter iter;
gtk_tree_store_append( model, &iter, 0L );
gtk_tree_store_set( model, &iter, 0, titleColumns[i], 1, descriptionColumns[i], -1 );
// append children
if( i == 1 )
{
for( unsigned int i=0; i<2; i++ )
{
GtkTreeIter subiter;
gtk_tree_store_append( model, &subiter, &iter );
gtk_tree_store_set( model, &subiter, 0, subTitleColumns[i], 1, subDescriptionColumns[i], -1 );
}
} else if( i == 2 ) {
GtkTreeIter subiter;
gtk_tree_store_append( model, &subiter, &iter );
gtk_tree_store_set( model, &subiter, 0, subTitleColumns[2], 1, subDescriptionColumns[2], -1 );
for( unsigned int i=0; i<2; i++ )
{
GtkTreeIter thirditer;
gtk_tree_store_append( model, &thirditer, &subiter );
gtk_tree_store_set( model, &thirditer, 0, subTitleColumns[i], 1, subDescriptionColumns[i], -1 );
}
}
}
GtkWidget* treeView( gtk_tree_view_new_with_model( GTK_TREE_MODEL( model ) ) );
gtk_tree_view_set_headers_visible( GTK_TREE_VIEW( treeView ), true );
gtk_widget_show( treeView );
// renderers
{
GtkCellRenderer *renderer( gtk_cell_renderer_text_new() );
GtkTreeViewColumn *column( gtk_tree_view_column_new_with_attributes( "Title", renderer, "text", 0, NULL ) );
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_append_column( GTK_TREE_VIEW( treeView ), column );
}
{
GtkCellRenderer *renderer( gtk_cell_renderer_text_new() );
GtkTreeViewColumn *column( gtk_tree_view_column_new_with_attributes( "Description", renderer, "text", 1, NULL ) );
gtk_tree_view_column_set_resizable(column, TRUE);
gtk_tree_view_append_column( GTK_TREE_VIEW( treeView ), column );
}
// scrolled window
GtkWidget* scrolledWindow( gtk_scrolled_window_new( 0L, 0L ) );
gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW( scrolledWindow ), GTK_SHADOW_IN );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolledWindow ), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
gtk_container_add( GTK_CONTAINER( scrolledWindow ), treeView );
gtk_widget_show( scrolledWindow );
gtk_paned_pack2( GTK_PANED( vpaned ), scrolledWindow, true, true );
}
}
static void
gst_element_browser_init (GstElementBrowser * browser)
{
GtkDialog *dialog;
GtkWidget *tree;
GtkWidget *table;
GtkWidget *vbox, *hpaned;
GtkWidget *frame;
GtkWidget *longname, *author, *description;
dialog = GTK_DIALOG (browser);
gtk_dialog_add_buttons (dialog,
_("_OK"), GTK_RESPONSE_ACCEPT,
_("_Cancel"), GTK_RESPONSE_CANCEL, NULL);
gtk_dialog_set_default_response (dialog, GTK_RESPONSE_CANCEL);
gtk_window_set_resizable (GTK_WINDOW (dialog), TRUE);
gtk_window_set_default_size (GTK_WINDOW (dialog), 550, 400);
gtk_window_set_title (GTK_WINDOW (dialog), _("Select element..."));
hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (dialog)),
hpaned, TRUE, TRUE, 0);
tree = g_object_new (gst_element_browser_element_tree_get_type (), NULL);
gtk_widget_set_size_request (GTK_WIDGET (tree), 200, -1);
gtk_paned_pack1 (GTK_PANED (hpaned), tree, FALSE, TRUE);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_set_size_request (vbox, 100, -1);
gtk_paned_pack2 (GTK_PANED (hpaned), vbox, TRUE, TRUE);
frame = gtk_frame_new ("Element Details");
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0);
/* create the details table and put a title on it */
table = gtk_grid_new ();
gtk_grid_set_column_spacing (GTK_GRID (table), 5);
/* the long name of the element */
longname = gtk_label_new ("Name:");
gtk_misc_set_alignment (GTK_MISC (longname), 1.0, 0.0);
gtk_grid_attach (GTK_GRID (table), longname, 0, 0, 1, 1);
browser->longname = GTK_WIDGET (g_object_new (GTK_TYPE_LABEL,
"selectable", TRUE,
"wrap", TRUE,
"justify", GTK_JUSTIFY_LEFT, "xalign", 0.0, "yalign", 0.0, NULL));
gtk_widget_set_hexpand (browser->longname, TRUE);
gtk_grid_attach (GTK_GRID (table), browser->longname, 1, 0, 1, 1);
/* the description */
description = gtk_label_new ("Description:");
gtk_misc_set_alignment (GTK_MISC (description), 1.0, 0.0);
gtk_grid_attach (GTK_GRID (table), description, 0, 1, 1, 1);
browser->description = GTK_WIDGET (g_object_new (GTK_TYPE_LABEL,
"selectable", TRUE,
"wrap", TRUE,
"justify", GTK_JUSTIFY_LEFT, "xalign", 0.0, "yalign", 0.0, NULL));
gtk_widget_set_hexpand (browser->description, TRUE);
gtk_grid_attach (GTK_GRID (table), browser->description, 1, 1, 1, 1);
/* the author */
author = gtk_label_new ("Author:");
gtk_misc_set_alignment (GTK_MISC (author), 1.0, 0.0);
gtk_grid_attach (GTK_GRID (table), author, 0, 2, 1, 1);
browser->author = GTK_WIDGET (g_object_new (GTK_TYPE_LABEL,
"selectable", TRUE,
"wrap", TRUE,
"justify", GTK_JUSTIFY_LEFT, "xalign", 0.0, "yalign", 0.0, NULL));
gtk_widget_set_hexpand (browser->author, TRUE);
gtk_grid_attach (GTK_GRID (table), browser->author, 1, 2, 1, 1);
gtk_container_add (GTK_CONTAINER (frame), table);
frame = gtk_frame_new ("Pads");
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
browser->pads = gst_element_browser_caps_tree_new ();
gtk_container_add (GTK_CONTAINER (frame), browser->pads);
frame = gtk_frame_new ("Pad templates");
gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
browser->padtemplates = gst_element_browser_caps_tree_new ();
gtk_container_add (GTK_CONTAINER (frame), browser->padtemplates);
g_signal_connect (G_OBJECT (tree), "element-selected",
G_CALLBACK (on_tree_selection_changed), browser);
g_signal_connect (G_OBJECT (tree), "element-activated",
G_CALLBACK (on_tree_activated), browser);
gtk_widget_show_all (gtk_bin_get_child (GTK_BIN (browser)));
}
