ui::HPaned create_split_views( ui::Widget topleft, ui::Widget topright, ui::Widget botleft, ui::Widget botright ){
auto hsplit = ui::HPaned(ui::New);
hsplit.show();
hsplit.connect( "size_allocate", G_CALLBACK( hpaned_allocate ), &g_hpaned );
hsplit.connect( "notify::position", G_CALLBACK( paned_position ), &g_hpaned );
{
auto vsplit = ui::VPaned(ui::New);
gtk_paned_add1( GTK_PANED( hsplit ), vsplit );
vsplit.show();
vsplit.connect( "size_allocate", G_CALLBACK( vpaned_allocate ), &g_vpaned1 );
vsplit.connect( "notify::position", G_CALLBACK( paned_position ), &g_vpaned1 );
gtk_paned_add1( GTK_PANED( vsplit ), create_framed_widget( topleft ) );
gtk_paned_add2( GTK_PANED( vsplit ), create_framed_widget( topright ) );
}
{
auto vsplit = ui::VPaned(ui::New);
gtk_paned_add2( GTK_PANED( hsplit ), vsplit );
vsplit.show();
vsplit.connect( "size_allocate", G_CALLBACK( vpaned_allocate ), &g_vpaned2 );
vsplit.connect( "notify::position", G_CALLBACK( paned_position ), &g_vpaned2 );
gtk_paned_add1( GTK_PANED( vsplit ), create_framed_widget( botleft ) );
gtk_paned_add2( GTK_PANED( vsplit ), create_framed_widget( botright ) );
}
return hsplit;
}
int main(int argc,char *argv[ ])
{
GtkWidget *window, *paned1, *paned2, *paned3;
GtkWidget *button;
gtk_init(&argc,&argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_signal_connect(GTK_OBJECT(window),"delete_event",G_CALLBACK(gtk_main_quit),NULL);
paned1 = gtk_vpaned_new();
gtk_container_add(GTK_CONTAINER(window), paned1);
paned2 = gtk_hpaned_new();
gtk_paned_add1(GTK_PANED(paned1),paned2);
button = gtk_button_new_with_label("Button1");
gtk_paned_add2(GTK_PANED(paned1),button);
button = gtk_button_new_with_label("Button2");
gtk_paned_add1(GTK_PANED(paned2),button);
paned3 = gtk_vpaned_new();
gtk_paned_add2(GTK_PANED(paned2),paned3);
button = gtk_button_new_with_label("Button3");
gtk_paned_add1(GTK_PANED(paned3),button);
button = gtk_button_new_with_label("Button4");
gtk_paned_add2(GTK_PANED(paned3),button);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
static int hview_init(void)
{
GtkWidget *menubar;
GtkWidget *toolbar;
GtkWidget *statusbar;
GtkWidget *vpaned;
GtkWidget *hpaned;
GtkWidget *main_vbox;
// Create main window ---------------------------------------------------------
main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect(G_OBJECT(main_window), "destroy",
G_CALLBACK(gtk_main_quit),
NULL);
gtk_window_set_title(GTK_WINDOW(main_window), HVIEW_TITLE);
gtk_widget_set_size_request(GTK_WIDGET(main_window),
HVIEW_MAIN_WINDOW_WIDTH,
HVIEW_MAIN_WINDOW_HEIGHT);
//-----------------------------------------------------------------------------
main_vbox = gtk_vbox_new(FALSE, 1);
gtk_container_set_border_width(GTK_CONTAINER(main_vbox), 1);
gtk_container_add(GTK_CONTAINER(main_window), main_vbox);
menubar = hview_get_menubar();
gtk_box_pack_start(GTK_BOX(main_vbox), menubar, FALSE, FALSE, 0);
vpaned = gtk_vpaned_new();
hpaned = gtk_hpaned_new();
// Create scrolled "tree window" and add it to horizontal paned window --------
tree_window = hview_get_tree_window();
gtk_paned_add1(GTK_PANED(hpaned), tree_window);
//-----------------------------------------------------------------------------
// Create scrolled "detail window" and add it to hpaned window ----------------
detail_window = hview_get_detail_window();
gtk_paned_add2(GTK_PANED(hpaned), detail_window);
//-----------------------------------------------------------------------------
// Create scrolled "log window" and add it with hpaned window to vertical paned
log_window = hview_get_log_window();
gtk_text_view_set_editable(GTK_TEXT_VIEW(log_view), FALSE);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(log_view), FALSE);
hview_print(HVIEW_NAME_VERSION);
gtk_paned_add1(GTK_PANED(vpaned), hpaned);
gtk_paned_add2(GTK_PANED(vpaned), log_window);
//-----------------------------------------------------------------------------
gtk_box_pack_start(GTK_BOX(main_vbox), vpaned, TRUE, TRUE, 0);
gtk_widget_show_all(main_window);
return 0;
}
static void
create_window(void)
{
GtkWidget *vbox, *hbox;
shell = g_new0(Shell, 1);
shell->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_icon(GTK_WINDOW(shell->window),
icon_cache_get_pixbuf("logo.png"));
gtk_window_set_title(GTK_WINDOW(shell->window), "System Information");
gtk_widget_set_size_request(shell->window, 600, 400);
g_signal_connect(G_OBJECT(shell->window), "destroy", destroy_me, NULL);
vbox = gtk_vbox_new(FALSE, 0);
gtk_widget_show(vbox);
gtk_container_add(GTK_CONTAINER(shell->window), vbox);
shell->vbox = vbox;
menu_init(shell);
hbox = gtk_hbox_new(FALSE, 5);
gtk_widget_show(hbox);
gtk_box_pack_end(GTK_BOX(vbox), hbox, FALSE, FALSE, 3);
shell->progress = gtk_progress_bar_new();
gtk_widget_set_size_request(shell->progress, 70, 10);
gtk_widget_hide(shell->progress);
gtk_box_pack_end(GTK_BOX(hbox), shell->progress, FALSE, FALSE, 0);
shell->status = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(shell->status), 0.0, 0.5);
gtk_widget_show(shell->status);
gtk_box_pack_start(GTK_BOX(hbox), shell->status, FALSE, FALSE, 0);
shell->hpaned = gtk_hpaned_new();
gtk_widget_show(shell->hpaned);
gtk_box_pack_end(GTK_BOX(vbox), shell->hpaned, TRUE, TRUE, 0);
gtk_paned_set_position(GTK_PANED(shell->hpaned), 210);
shell->vpaned = gtk_vpaned_new();
gtk_widget_show(shell->vpaned);
gtk_paned_add2(GTK_PANED(shell->hpaned), shell->vpaned);
shell->notebook = gtk_notebook_new();
gtk_paned_add2(GTK_PANED(shell->vpaned), shell->notebook);
gtk_widget_show(shell->window);
while (gtk_events_pending())
gtk_main_iteration();
}
void EClassTree::populateWindow() {
// Create the overall vbox
_dialogVBox = gtk_vbox_new(FALSE, 12);
gtk_container_add(GTK_CONTAINER(getWindow()), _dialogVBox);
GtkWidget* paned = gtk_hpaned_new();
gtk_box_pack_start(GTK_BOX(_dialogVBox), paned, TRUE, TRUE, 0);
// Pack tree view
gtk_paned_add1(GTK_PANED(paned), createEClassTreeView());
// Pack spawnarg treeview
gtk_paned_add2(GTK_PANED(paned), GTK_WIDGET(createPropertyTreeView()));
// Pack in dialog buttons
gtk_box_pack_start(GTK_BOX(_dialogVBox), createButtons(), FALSE, FALSE, 0);
// Set the default size of the window
GtkWindow* mainWindow = GlobalMainFrame().getTopLevelWindow();
GdkRectangle rect = gtkutil::MultiMonitor::getMonitorForWindow(mainWindow);
gtk_window_set_default_size(
GTK_WINDOW(getWindow()), gint(rect.width * 0.8f), gint(rect.height * 0.8f)
);
gtk_paned_set_position(GTK_PANED(paned), static_cast<gint>(rect.width * 0.25f));
}
int main(int argc, char** argv)
{
GtkWidget *window;
GtkWidget *scrolled;
GtkWidget *text;
GtkWidget *paned;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_widget_set_size_request(window, 400, 300);
g_signal_connect(GTK_OBJECT(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
paned = gtk_hpaned_new();
gtk_container_add(GTK_CONTAINER(window), paned);
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_paned_add1(GTK_PANED(paned), scrolled);
text = gtk_text_view_new();
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled), text);
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_paned_add2(GTK_PANED(paned), scrolled);
text = gtk_text_view_new();
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled), text);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
int main(int argc,char *argv[ ])
{
GtkWidget *window;
GtkWidget *scrolled;
GtkWidget *text;
GtkWidget *paned;
gtk_init(&argc,&argv);
window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request(window,200,200);
gtk_signal_connect(GTK_OBJECT(window),"destroy",G_CALLBACK(gtk_main_quit),NULL);
paned=gtk_hpaned_new();/*ǤǤǵÇ}ÇåÇïÇÚ¡¼ÇäǻǫǤÆãǹÇèÇÇdz¡¼/
gtk_container_add(GTK_CONTAINER(window),paned);/*ǵǥǩÇäǻǫǤÆãǹÇèÇÇdz¡¼ÇÞÇÉ¡¼ÆãÇÑ¡¼/
gtk_widget_show(paned);
scrolled=gtk_scrolled_window_new(NULL,NULL);/*ǤǤǵÇ}Ç¡¼Ç¿Ç¤ÆãǹÇèÇÇdz¡¼/
gtk_paned_add1(GTK_PANED(paned),scrolled);/*ǵǥǡ¼Ç¿Ç¤ÆãǹÇèÇÇdz¡¼ÇÞÇÉ¡¼ÇµÇ©ÇäǻǫǤÆãǹÇèÇÇdz¡¼ÇÄÇ塼ÆãǹÇè*/
gtk_widget_show(scrolled);
text=gtk_text_view_new( );
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled),text);
gtk_widget_show(text);
scrolled=gtk_scrolled_window_new(NULL,NULL);
gtk_paned_add2(GTK_PANED(paned),scrolled);
gtk_widget_show(scrolled);
text=gtk_text_view_new();
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled),text);
gtk_widget_show(text);
gtk_widget_show(window);
gtk_main();
return 0;
}
void create_Window()
{
bdk_window.fenster = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_signal_connect(GTK_OBJECT(bdk_window.fenster), "destroy", GTK_SIGNAL_FUNC(gtk_main_quit),NULL);
//g_signal_connect (G_OBJECT (fenster), "delete_event", G_CALLBACK (delete_event), NULL);
gtk_window_set_title (GTK_WINDOW(bdk_window.fenster), "Bilddatenkompression(BDK) Tool");
gtk_widget_set_size_request (GTK_WIDGET(bdk_window.fenster), 600, 600);
/* Make a vbox to put the three menus in */
bdk_window.main_vbox = gtk_vbox_new (FALSE, 1);
gtk_container_set_border_width (GTK_CONTAINER (bdk_window.main_vbox), 1);
gtk_container_add (GTK_CONTAINER (bdk_window.fenster), bdk_window.main_vbox);
create_menubar_menu();
create_toolbar_menu();
bdk_window.image = gtk_image_new_from_file("C:\\Dokumente und Einstellungen\\uwe_work\\Eigene Dateien\\Eigene Bilder\\Battlestar\\battlestargalpic_01.jpg");
bdk_window.scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (bdk_window.scrolled_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (bdk_window.scrolled_window), bdk_window.image);
bdk_window.hpaned = gtk_hpaned_new();
create_view_and_model();
gtk_paned_add1(GTK_PANED(bdk_window.hpaned), bdk_window.view);
gtk_paned_add2(GTK_PANED(bdk_window.hpaned), bdk_window.scrolled_window);
gtk_box_pack_start (GTK_BOX (bdk_window.main_vbox), bdk_window.hpaned, TRUE, TRUE, 0);
}
int main(int argc, char *argv[])
{
GtkWidget *window, *hpaned, *button1, *button2;
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "Panes");
gtk_container_set_border_width(GTK_CONTAINER(window), 10);
gtk_widget_set_size_request(window, 225, 150);
hpaned = gtk_hpaned_new();
button1 = gtk_button_new_with_label("Resize");
button2 = gtk_button_new_with_label("Me!");
g_signal_connect_swapped(G_OBJECT(button1), "clicked",
G_CALLBACK(gtk_widget_destroy),
(gpointer) window);
g_signal_connect_swapped(G_OBJECT(button2), "clicked",
G_CALLBACK(gtk_widget_destroy),
(gpointer) window);
gtk_paned_add1(GTK_PANED(hpaned), button1);
gtk_paned_add2(GTK_PANED(hpaned), button2);
gtk_container_add(GTK_CONTAINER(window), hpaned);
gtk_widget_show_all(window);
gtk_main();
return 0;
}
int
main (int argc, char *argv[])
{
GtkWidget *window;
GtkWidget *vpaned;
GtkWidget *list;
GtkWidget *text;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Paned Windows");
gtk_signal_connect (GTK_OBJECT (window), "destroy",
GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
gtk_container_border_width (GTK_CONTAINER (window), 10);
/* vpaned widget을 만들어서 toplevel 윈도에 더한다. */
vpaned = gtk_vpaned_new ();
gtk_container_add (GTK_CONTAINER(window), vpaned);
gtk_widget_show (vpaned);
/* 이제 윈도 두 부분의 내용을 만든다. */
list = create_list ();
gtk_paned_add1 (GTK_PANED(vpaned), list);
gtk_widget_show (list);
text = create_text ();
gtk_paned_add2 (GTK_PANED(vpaned), text);
gtk_widget_show (text);
gtk_widget_show (window);
gtk_main ();
return 0;
}
static void phidias_items_classic_init (PhidiasItemsClassic *item)
{
GtkWidget *scroll;
GtkCellRenderer *renderer;
GtkTreeViewColumn *col;
GtkTreeSelection *selection;
item->priv = PHIDIAS_ITEMS_CLASSIC_GET_PRIVATE (item);
item->priv->list = gtk_tree_view_new ();
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (item->priv->list), FALSE);
renderer = gtk_cell_renderer_text_new ();
col = gtk_tree_view_column_new_with_attributes ("Title", renderer, "text", ITEM_INFO_TITLE, NULL);
gtk_tree_view_column_set_cell_data_func (col, renderer, set_line_style, NULL, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (item->priv->list), col);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (item->priv->list));
gtk_tree_selection_set_mode (selection, GTK_SELECTION_SINGLE);
g_signal_connect (selection, "changed", G_CALLBACK (item_selected_cb), item);
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scroll), item->priv->list);
gtk_paned_add1 (GTK_PANED (item), scroll);
item->priv->description = webkit_web_view_new ();
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scroll), item->priv->description);
gtk_paned_add2 (GTK_PANED (item), scroll);
}
static void fm_tab_page_init(FmTabPage *page)
{
GtkPaned* paned = GTK_PANED(page);
FmTabLabel* tab_label;
FmFolderView* folder_view;
GList* focus_chain = NULL;
FmSidePaneMode mode = app_config->side_pane_mode;
page->side_pane = fm_side_pane_new();
fm_side_pane_set_mode(page->side_pane, (mode & FM_SP_MODE_MASK));
/* TODO: add a close button to side pane */
gtk_paned_add1(paned, GTK_WIDGET(page->side_pane));
focus_chain = g_list_prepend(focus_chain, page->side_pane);
/* handlers below will be used when FmMainWin detects new page added */
folder_view = (FmFolderView*)fm_standard_view_new(app_config->view_mode,
update_files_popup,
open_folder_func);
page->folder_view = folder_view;
fm_folder_view_set_selection_mode(folder_view, GTK_SELECTION_MULTIPLE);
page->nav_history = fm_nav_history_new();
gtk_paned_add2(paned, GTK_WIDGET(page->folder_view));
focus_chain = g_list_prepend(focus_chain, page->folder_view);
/* We need this to change tab order to focus folder view before left pane. */
gtk_container_set_focus_chain(GTK_CONTAINER(page), focus_chain);
g_list_free(focus_chain);
gtk_widget_show_all(GTK_WIDGET(page));
if(mode & FM_SP_HIDE)
gtk_widget_hide(GTK_WIDGET(page->side_pane));
/* create tab label */
tab_label = (FmTabLabel*)fm_tab_label_new("");
gtk_label_set_max_width_chars(tab_label->label, app_config->max_tab_chars);
#if ! GTK_CHECK_VERSION(3, 0, 0)
gtk_label_set_ellipsize(tab_label->label, PANGO_ELLIPSIZE_END);
#endif
page->tab_label = tab_label;
g_signal_connect(page->folder_view, "sel-changed",
G_CALLBACK(on_folder_view_sel_changed), page);
/*
g_signal_connect(page->folder_view, "chdir",
G_CALLBACK(on_folder_view_chdir), page);
g_signal_connect(page->folder_view, "loaded",
G_CALLBACK(on_folder_view_loaded), page);
g_signal_connect(page->folder_view, "error",
G_CALLBACK(on_folder_view_error), page);
*/
/* the folder view is already loded, call the "loaded" callback ourself. */
//if(fm_folder_view_is_loaded(folder_view))
// on_folder_view_loaded(folder_view, fm_folder_view_get_cwd(folder_view), page);
}
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_
/* Add a child to the bottom or right pane with default parameters.
* This is equivalent to gtk_paned_pack1(paned, FALSE, FALSE); */
int
clip_GTK_PANEDADD2(ClipMachine * cm)
{
C_widget *cpan = _fetch_cw_arg(cm);
C_widget *cwid = _fetch_cwidget(cm,_clip_spar(cm,2));
CHECKCWID(cpan,GTK_IS_PANED);
CHECKARG2(2,MAP_t,NUMERIC_t); CHECKCWID(cwid,GTK_IS_WIDGET);
gtk_paned_add2(GTK_PANED(cpan->widget), cwid->widget);
return 0;
err:
return 1;
}
extern void populate_window(void)
{
gtk_container_add( GTK_CONTAINER(window), pane );
gtk_paned_add1( GTK_PANED(pane), lpane );
gtk_paned_add2( GTK_PANED(pane), rgrid );
gtk_paned_add1( GTK_PANED(lpane), history_scrollbox );
gtk_paned_add2( GTK_PANED(lpane), input_scrollbox );
gtk_container_add( GTK_CONTAINER(history_scrollbox), history_view );
gtk_container_add( GTK_CONTAINER(input_scrollbox), input_view );
gtk_grid_attach( GTK_GRID(rgrid), button_contacts, 0, 0, 1, 1 );
gtk_grid_attach( GTK_GRID(rgrid), button_chats, 1, 0, 1, 1 );
gtk_grid_attach( GTK_GRID(rgrid), button_settings, 2, 0, 1, 1 );
gtk_grid_attach( GTK_GRID(rgrid), label, 0, 1, 3, 1 );
gtk_grid_attach( GTK_GRID(rgrid), list, 0, 1, 3, 1 );
gtk_widget_show(label);
togglestatus = FALSE;
label_was_visible = TRUE;
gtk_grid_attach( GTK_GRID(rgrid), button_add_contact, 0, 2, 3, 1 );
return;
}
/**
* 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 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);
}
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;
}
static void fm_tab_page_init(FmTabPage *page)
{
GtkPaned* paned = GTK_PANED(page);
FmTabLabel* tab_label;
FmFolderView* folder_view;
GList* focus_chain = NULL;
page->side_pane = fm_side_pane_new();
fm_side_pane_set_mode(FM_SIDE_PANE(page->side_pane), app_config->side_pane_mode);
/* TODO: add a close button to side pane */
gtk_paned_add1(paned, page->side_pane);
focus_chain = g_list_prepend(focus_chain, page->side_pane);
page->folder_view = fm_folder_view_new(app_config->view_mode);
folder_view = FM_FOLDER_VIEW(page->folder_view);
fm_folder_view_set_hint_type(folder_view, app_config->hint_type);
fm_folder_view_sort(folder_view, app_config->sort_type, app_config->sort_by);
fm_folder_view_set_selection_mode(folder_view, GTK_SELECTION_MULTIPLE);
page->nav_history = fm_nav_history_new();
gtk_paned_add2(paned, page->folder_view);
focus_chain = g_list_prepend(focus_chain, page->folder_view);
/* We need this to change tab order to focus folder view before left pane. */
gtk_container_set_focus_chain(page, focus_chain);
g_list_free(focus_chain);
gtk_widget_show_all(GTK_WIDGET(page));
/* create tab label */
tab_label = (FmTabLabel*)fm_tab_label_new("");
gtk_label_set_max_width_chars(tab_label->label, app_config->max_tab_chars);
gtk_label_set_ellipsize(tab_label->label, PANGO_ELLIPSIZE_END);
page->tab_label = GTK_WIDGET(tab_label);
g_signal_connect(page->folder_view, "sel-changed",
G_CALLBACK(on_folder_view_sel_changed), page);
g_signal_connect(page->folder_view, "loaded",
G_CALLBACK(on_folder_view_loaded), page);
/* the folder view is already loded, call the "loaded" callback ourself. */
if(fm_folder_view_get_is_loaded(folder_view))
on_folder_view_loaded(folder_view, fm_folder_view_get_cwd(folder_view), page);
}
static void
sunone_invitation_list_init (SunOneInvitationList *object)
{
SunOneInvitationList *list = SUNONE_INVITATION_LIST (object);
SunOneInvitationListPrivate *priv;
GtkWidget *scroll;
int pos;
list->priv = g_new0 (SunOneInvitationListPrivate, 1);
priv = list->priv;
priv->client = gconf_client_get_default ();
priv->model = NULL;
priv->treeview = NULL;
priv->pane = gtk_vpaned_new ();
gtk_box_set_homogeneous (GTK_BOX (list), FALSE);
scroll = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scroll),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scroll),
GTK_SHADOW_IN);
#if USE_ITIP_VIEW
priv->control = sunone_itip_view_new ();
#else
priv->control = bonobo_widget_new_control (INVITATION_CONTROL_IID, NULL);
#endif
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scroll),
priv->control);
gtk_paned_add2 (GTK_PANED (priv->pane), GTK_WIDGET (scroll));
pos = gconf_client_get_int (priv->client,
"/apps/evolution/evolution-jescs/invitationList/panePosition",
NULL);
gtk_paned_set_position (GTK_PANED (priv->pane), pos);
gtk_box_pack_start (GTK_BOX (list), priv->pane, TRUE, TRUE, 0);
}
void relayout_mainbox ()
{
gboolean mvisible = rookie_settings_get_visible (ROOKIE_SIDEPANE_VISIBLE);
gboolean nvisible = rookie_settings_get_visible (ROOKIE_BOTTOMPANE_VISIBLE);
GtkWidget *parent;
GtkWidget *left_widget = nvisible ? vpaned : sw2;
GtkWidget *main_widget = mvisible ? hpaned : left_widget;
parent = gtk_widget_get_parent (vpaned);
if (parent != NULL) {
g_object_ref (vpaned);
gtk_container_remove (GTK_CONTAINER(parent), vpaned);
}
parent = gtk_widget_get_parent (sw2);
if (parent != NULL) {
g_object_ref (sw2);
gtk_container_remove (GTK_CONTAINER(parent), sw2);
}
parent = gtk_widget_get_parent (hpaned);
if (parent != NULL) {
g_object_ref (hpaned);
gtk_container_remove (GTK_CONTAINER(parent), hpaned);
}
if (nvisible) {
gtk_paned_add1 (GTK_PANED (vpaned), sw2);
g_object_unref (sw2);
}
if (mvisible) {
gtk_paned_add2 (GTK_PANED (hpaned), left_widget);
g_object_unref (left_widget);
}
gtk_box_pack_start (GTK_BOX (mainbox), main_widget, TRUE, TRUE, 0);
gtk_widget_show_all (mainbox);
}
int main( int argc,
char *argv[] )
{
GtkWidget *window;
GtkWidget *vpaned;
GtkWidget *list;
GtkWidget *text;
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Paned Windows");
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_main_quit), NULL);
gtk_container_set_border_width (GTK_CONTAINER (window), 10);
gtk_widget_set_size_request (GTK_WIDGET (window), 450, 400);
/* create a vpaned widget and add it to our toplevel window */
vpaned = gtk_vpaned_new ();
gtk_container_add (GTK_CONTAINER (window), vpaned);
gtk_widget_show (vpaned);
/* Now create the contents of the two halves of the window */
list = create_list ();
gtk_paned_add1 (GTK_PANED (vpaned), list);
gtk_widget_show (list);
text = create_text ();
gtk_paned_add2 (GTK_PANED (vpaned), text);
gtk_widget_show (text);
gtk_widget_show (window);
gtk_main ();
return 0;
}
/**
*程序入口
*/
int main(int argc,char *argv[]){
GtkWidget *vBox = NULL;//主布局
GtkWidget *hPanel = NULL; //操作主布局
GtkWidget *rightMainVBox = NULL; //右边主布局
gtk_init(&argc,&argv);
g_print("检查目录%d\n",check_dir());
window = create_main_window();//创建主窗口
set_main_window(window);//同步ui.c的window
hPanel = gtk_hpaned_new(); //创建操作主布局
leftCatalogVBox = gtk_vbox_new(FALSE,0); //新建竖向布局
rightMainVBox = gtk_vbox_new(FALSE,0); //新建竖向布局
//设置主布局
vBox = gtk_vbox_new(FALSE,0); //新建竖向布局
gtk_container_add(GTK_CONTAINER(window),vBox);//向窗口加入主布局--不可视
gtk_box_pack_start(GTK_BOX(vBox),create_menus(),FALSE,FALSE,0); //添加菜单
gtk_box_pack_start(GTK_BOX(vBox),hPanel,TRUE,TRUE,10); //添加面板
gtk_paned_add1(GTK_PANED(hPanel),leftCatalogVBox);// 添加布局
gtk_paned_add2(GTK_PANED(hPanel),rightMainVBox);// 添加布局
gtk_widget_set_size_request(leftCatalogVBox,150,300); //设置左边大小
init_tree_view_catalog();
gtk_box_pack_start(GTK_BOX(rightMainVBox),init_right_main_view(),TRUE,TRUE,0); //显示左边主要内容
gtk_widget_show_all(window); //显示所有组件
init_right_main_view_hide_all(NULL);
gtk_main();
return 0;
}
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;
}
int main(int argc,char *argv[])
{
app.connected = FALSE;
app.is_server = FALSE;
app.finish = FALSE;
windowIO = g_slice_new (InputOutput);
gtk_init(&argc, &argv);
// Main window
app.chat = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_container_set_border_width(GTK_CONTAINER(app.chat), 10);
g_signal_connect(G_OBJECT(app.chat), "delete-event", G_CALLBACK(gtk_main_quit), NULL);
gtk_window_set_default_size(GTK_WINDOW(app.chat), 600, 300);
gtk_window_set_title(GTK_WINDOW(app.chat), "Conversation électronique");
// GUI
app.button = gtk_button_new_with_label ("Terminer Session");
app.button2 = gtk_button_new_with_label ("Demarrer Session");
app.button3 = gtk_button_new_with_label ("Sauvegarde Fichier");
//app.button4 = gtk_button_new_with_label ("Saisir Note");
app.scrolled_window = gtk_scrolled_window_new(NULL, NULL);
windowIO->textview = gtk_text_view_new();
windowIO->entry = gtk_entry_new();
app.chat_right_column = gtk_vbox_new(FALSE, 5);
app.chat_space = gtk_hpaned_new ();
app.container_option = gtk_vpaned_new ();
gtk_text_view_set_editable(GTK_TEXT_VIEW(windowIO->textview), FALSE);
gtk_paned_set_position (GTK_PANED(app.chat_space), 450);
gtk_paned_set_position (GTK_PANED(app.container_option), 250);
gtk_paned_add1 (GTK_PANED(app.chat_space), app.container_option);
gtk_paned_add2 (GTK_PANED(app.chat_space), app.chat_right_column);
gtk_paned_add1 (GTK_PANED(app.container_option), app.scrolled_window);
gtk_paned_add2 (GTK_PANED(app.container_option), windowIO->entry);
gtk_box_pack_start(GTK_BOX(app.chat_right_column), app.button2, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(app.chat_right_column), app.button3, FALSE, FALSE, 10);
//gtk_box_pack_start(GTK_BOX(app.chat_right_column), app.button4, FALSE, FALSE, 20);
gtk_box_pack_end (GTK_BOX(app.chat_right_column), app.button, FALSE, FALSE, 25);
gtk_container_add (GTK_CONTAINER(app.scrolled_window), windowIO->textview);
gtk_container_add (GTK_CONTAINER(app.chat), app.chat_space);
/*g_signal_connect (G_OBJECT (app.button4), "clicked",
G_CALLBACK (save_mark),
NULL);*/
g_signal_connect (G_OBJECT (app.button3), "clicked",
G_CALLBACK (save_file),
NULL);
g_signal_connect (G_OBJECT (app.button2), "clicked",
G_CALLBACK (start_session),
NULL);
g_signal_connect (G_OBJECT (app.button), "clicked",
G_CALLBACK (end_session),
NULL);
g_signal_connect (windowIO->entry, "activate",
G_CALLBACK (enter_text),
NULL);
gtk_widget_show_all(app.chat);
gtk_main();
return 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;
}
UzblTreeTab::UzblTreeTab(char* name)
{
running = true;
currenttab = 0;
totaltabs = 0;
fifocount = 0;
uzblinstances = NULL;
fb = 0;
sessionload = false;
closing = false;
if (name) {
sprintf(fifopath, "/tmp/uzbltreetab-%s", name);
strcpy(tabname, name);
}
else {
sprintf(fifopath, "/tmp/uzbltreetab-%d", rand());
tabname[0] = '\0';
}
mkfifo(fifopath, 0766);
fifofd = open(fifopath, O_NONBLOCK);
window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
char title[1024];
sprintf(title, "uzbltreetab - %s", name);
gtk_window_set_title(window, title);
tabtree = GTK_TREE_VIEW(gtk_tree_view_new());
GtkScrolledWindow* tabscroll = GTK_SCROLLED_WINDOW(gtk_scrolled_window_new(NULL, NULL));
gtk_scrolled_window_set_policy(tabscroll, GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(tabscroll), GTK_WIDGET(tabtree));
gtk_widget_set_can_focus(GTK_WIDGET(tabtree), false);
//gtk_tree_view_set_reorderable(tabtree, true);
tabmodel = gtk_tree_store_new(1, G_TYPE_STRING);
gtk_tree_view_set_model(tabtree, GTK_TREE_MODEL(tabmodel));
GtkTreeIter iter;
GtkCellRenderer* trenderer = gtk_cell_renderer_text_new();
//g_object_set(trenderer, "editable", true, NULL);
gtk_tree_view_insert_column_with_attributes(tabtree, -1, "",
trenderer, "text", 0, NULL);
gtk_tree_view_set_headers_visible(tabtree, false);
//g_signal_connect(trenderer, "edited", G_CALLBACK(cell_edited_callback), this);
g_signal_connect(tabtree, "cursor-changed", G_CALLBACK(row_clicked), this);
notebook = GTK_NOTEBOOK(gtk_notebook_new());
gtk_notebook_set_show_tabs(notebook, false);
gtk_notebook_set_show_border(notebook, false);
pane = GTK_PANED(gtk_hpaned_new());
gtk_paned_add1(pane, GTK_WIDGET(tabscroll));
gtk_paned_add2(pane, GTK_WIDGET(notebook));
gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(pane));
g_signal_connect(window, "destroy", G_CALLBACK(wdestroy), this);
gtk_widget_show_all(GTK_WIDGET(window));
gtk_paned_set_position(pane, 200);
panepos = 200;
//g_timeout_add(1000, updatetabs, this);
g_timeout_add(100, checkfifo, this);
LoadSession();
if (totaltabs == 0)
NewTab("about:blank");
}
Compose * compose_new(Config * config)
{
Compose * compose;
GtkAccelGroup * group;
GtkWidget * vbox;
GtkWidget * toolbar;
GtkToolItem * toolitem;
GtkSizeGroup * sizegroup;
GtkWidget * vpaned;
GtkWidget * vbox2;
GtkWidget * widget;
GtkCellRenderer * renderer;
GtkTreeViewColumn * column;
GtkTreeIter iter;
char const * headers[] = {
"To:", "Cc:", "Bcc:", "Reply-To:", "Newsgroup:",
"Followup-To:" };
size_t i;
if((compose = malloc(sizeof(*compose))) == NULL)
{
compose_error(NULL, strerror(errno), 0);
return NULL;
}
compose->mime = mime_new(NULL);
/* check errors */
if(compose->mime == NULL)
{
free(compose);
return NULL;
}
compose->config = config;
compose->standalone = FALSE;
/* window */
group = gtk_accel_group_new();
compose->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_add_accel_group(GTK_WINDOW(compose->window), group);
#ifndef EMBEDDED
gtk_window_set_default_size(GTK_WINDOW(compose->window), 512, 384);
#else
gtk_window_set_default_size(GTK_WINDOW(compose->window), 200, 300);
#endif
gtk_window_set_title(GTK_WINDOW(compose->window), _("Compose"));
#if GTK_CHECK_VERSION(2, 6, 0)
gtk_window_set_icon_name(GTK_WINDOW(compose->window), "mailer");
#endif
g_signal_connect_swapped(G_OBJECT(compose->window), "delete-event",
G_CALLBACK(_compose_on_closex), compose);
vbox = gtk_vbox_new(FALSE, 0);
/* menubar */
#ifndef EMBEDDED
widget = desktop_menubar_create(_compose_menubar, compose, group);
gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 0);
#endif
/* toolbar */
toolbar = desktop_toolbar_create(_compose_toolbar, compose, group);
gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, TRUE, 0);
/* from */
sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
toolbar = gtk_toolbar_new();
widget = gtk_label_new(_("From: "));
gtk_misc_set_alignment(GTK_MISC(widget), 0.1, 0.5);
gtk_widget_set_size_request(widget, 80, -1);
gtk_size_group_add_widget(sizegroup, widget);
toolitem = gtk_tool_item_new();
gtk_container_add(GTK_CONTAINER(toolitem), widget);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
#if GTK_CHECK_VERSION(2, 24, 0)
compose->from = gtk_combo_box_text_new_with_entry();
#else
compose->from = gtk_combo_box_entry_new_text();
#endif
toolitem = gtk_tool_item_new();
gtk_tool_item_set_expand(toolitem, TRUE);
gtk_container_add(GTK_CONTAINER(toolitem), compose->from);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0);
/* paned */
vpaned = gtk_vpaned_new();
/* headers */
widget = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
compose->h_store = gtk_list_store_new(CHC_COUNT, G_TYPE_STRING,
G_TYPE_STRING, G_TYPE_BOOLEAN);
compose->h_store_filter = gtk_tree_model_filter_new(GTK_TREE_MODEL(
compose->h_store), NULL);
gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER(
compose->h_store_filter),
_compose_on_headers_filter, compose, NULL);
compose->h_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(
compose->h_store_filter));
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(compose->h_view),
FALSE);
gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(compose->h_view), TRUE);
compose->h_headers = gtk_list_store_new(2, G_TYPE_STRING,
G_TYPE_STRING);
for(i = 0; i < sizeof(headers) / sizeof(*headers); i++)
{
gtk_list_store_append(compose->h_headers, &iter);
gtk_list_store_set(compose->h_headers, &iter, 0, headers[i], 1,
headers[i], -1);
}
renderer = gtk_cell_renderer_combo_new();
g_object_set(renderer, "editable", TRUE, "model", compose->h_headers,
"text-column", 1, NULL);
g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK(
_on_header_field_edited), compose);
column = gtk_tree_view_column_new_with_attributes("", renderer, "text",
CHC_HEADER, NULL);
gtk_tree_view_column_set_min_width(column, 80);
gtk_tree_view_append_column(GTK_TREE_VIEW(compose->h_view), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(G_OBJECT(renderer), "editable", TRUE, NULL);
g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK(
_on_header_edited), compose);
column = gtk_tree_view_column_new_with_attributes("", renderer, "text",
CHC_VALUE, NULL);
#if GTK_CHECK_VERSION(2, 4, 0)
gtk_tree_view_column_set_expand(column, TRUE);
#endif
gtk_tree_view_append_column(GTK_TREE_VIEW(compose->h_view), column);
/* default to 8-bits transfers with UTF-8 encoding */
compose_set_header(compose, "Content-Transfer-Encoding:", "8bit",
FALSE);
compose_set_header(compose, "Content-Type:",
"text/plain; charset=UTF-8", FALSE);
compose_add_field(compose, "To:", NULL);
gtk_container_add(GTK_CONTAINER(widget), compose->h_view);
gtk_paned_add1(GTK_PANED(vpaned), widget);
/* paned */
vbox2 = gtk_vbox_new(FALSE, 0);
/* subject */
toolbar = gtk_toolbar_new();
widget = gtk_label_new(_("Subject: "));
gtk_misc_set_alignment(GTK_MISC(widget), 0.1, 0.5);
gtk_size_group_add_widget(sizegroup, widget);
toolitem = gtk_tool_item_new();
gtk_container_add(GTK_CONTAINER(toolitem), widget);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
compose->subject = gtk_entry_new();
toolitem = gtk_tool_item_new();
gtk_tool_item_set_expand(toolitem, TRUE);
gtk_container_add(GTK_CONTAINER(toolitem), compose->subject);
gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1);
gtk_box_pack_start(GTK_BOX(vbox2), toolbar, FALSE, TRUE, 0);
/* view */
widget = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
compose->view = _new_text_view(compose);
compose_set_font(compose, _compose_get_font(compose));
gtk_container_add(GTK_CONTAINER(widget), compose->view);
gtk_box_pack_start(GTK_BOX(vbox2), widget, TRUE, TRUE, 0);
gtk_paned_add2(GTK_PANED(vpaned), vbox2);
gtk_box_pack_start(GTK_BOX(vbox), vpaned, TRUE, TRUE, 0);
/* attachments */
compose->a_window = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(compose->a_window),
GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);
compose->a_store = gtk_list_store_new(CAC_COUNT, G_TYPE_STRING,
G_TYPE_STRING, GDK_TYPE_PIXBUF);
compose->a_view = gtk_icon_view_new_with_model(GTK_TREE_MODEL(
compose->a_store));
gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(compose->a_view),
CAC_ICON);
gtk_icon_view_set_selection_mode(GTK_ICON_VIEW(compose->a_view),
GTK_SELECTION_MULTIPLE);
gtk_icon_view_set_text_column(GTK_ICON_VIEW(compose->a_view),
CAC_BASENAME);
gtk_container_add(GTK_CONTAINER(compose->a_window), compose->a_view);
gtk_widget_show_all(compose->a_view);
gtk_widget_set_no_show_all(compose->a_window, TRUE);
gtk_box_pack_start(GTK_BOX(vbox), compose->a_window, FALSE, TRUE, 0);
/* statusbar */
compose->statusbar = gtk_statusbar_new();
compose->statusbar_id = 0;
gtk_box_pack_start(GTK_BOX(vbox), compose->statusbar, FALSE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(compose->window), vbox);
/* about dialog */
compose->ab_window = NULL;
/* signature */
compose_append_signature(compose);
compose_set_modified(compose, FALSE);
compose_scroll_to_offset(compose, 0);
/* display */
gtk_widget_grab_focus(compose->view);
gtk_widget_show_all(vbox);
gtk_widget_show(compose->window);
return compose;
}
