void MainWindow::updateScrollbarSidebarPosition() {
XOJ_CHECK_TYPE(MainWindow);
GtkWidget * panelMainContents = get("panelMainContents");
GtkWidget * sidebarContents = get("sidebarContents");
GtkWidget * tableXournal = get("tableXournal");
bool scrollbarOnLeft = control->getSettings()->isScrollbarOnLeft();
Layout * layout = this->getLayout();
GtkWidget * v = layout->getScrollbarVertical();
if (gtk_widget_get_parent(v) != NULL) {
gtk_container_remove(GTK_CONTAINER(tableXournal), v);
}
ScrollbarHideType type = this->getControl()->getSettings()->getScrollbarHideType();
if (type == SCROLLBAR_HIDE_NONE || type == SCROLLBAR_HIDE_HORIZONTAL) {
if (scrollbarOnLeft) {
gtk_table_attach(GTK_TABLE(tableXournal), v, 0, 1, 0, 1, (GtkAttachOptions) 0, GTK_FILL, 0, 0);
} else {
gtk_table_attach(GTK_TABLE(tableXournal), v, 2, 3, 0, 1, (GtkAttachOptions) 0, GTK_FILL, 0, 0);
}
}
Sidebar * sidebar = this->control->getSidebar();
if (sidebar) {
sidebar->setBackgroundWhite();
}
int divider = gtk_paned_get_position(GTK_PANED(panelMainContents));
bool sidebarRight = control->getSettings()->isSidebarOnRight();
if (sidebarRight == (gtk_paned_get_child2(GTK_PANED(panelMainContents)) == sidebarContents)) {
// Already correct
return;
} else {
GtkAllocation allocation;
gtk_widget_get_allocation(panelMainContents, &allocation);
divider = allocation.width - divider;
}
g_object_ref(sidebarContents);
g_object_ref(tableXournal);
gtk_container_remove(GTK_CONTAINER(panelMainContents), sidebarContents);
gtk_container_remove(GTK_CONTAINER(panelMainContents), tableXournal);
if (sidebarRight) {
gtk_paned_pack1(GTK_PANED(panelMainContents), tableXournal, true, true);
gtk_paned_pack2(GTK_PANED(panelMainContents), sidebarContents, false, true);
} else {
gtk_paned_pack1(GTK_PANED(panelMainContents), sidebarContents, false, true);
gtk_paned_pack2(GTK_PANED(panelMainContents), tableXournal, true, true);
}
g_object_unref(sidebarContents);
g_object_unref(tableXournal);
}
void
statusbar_widgets_pack(GtkWidget *statusbar)
{
gtk_box_pack_start(GTK_BOX(statusbar), expert_info_error, FALSE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(statusbar), expert_info_warn, FALSE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(statusbar), expert_info_note, FALSE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(statusbar), expert_info_chat, FALSE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(statusbar), expert_info_none, FALSE, FALSE, 2);
gtk_box_pack_start(GTK_BOX(statusbar), status_pane_left, TRUE, TRUE, 0);
gtk_paned_pack1(GTK_PANED(status_pane_left), info_bar_event, FALSE, FALSE);
gtk_paned_pack2(GTK_PANED(status_pane_left), status_pane_right, TRUE, FALSE);
gtk_paned_pack1(GTK_PANED(status_pane_right), packets_bar, TRUE, FALSE);
gtk_paned_pack2(GTK_PANED(status_pane_right), profile_bar_event, FALSE, FALSE);
}
void
shell_init(void)
{
if (shell) {
g_error("Shell already created");
return;
}
create_window();
shell->tree = tree_new();
shell->info = info_tree_new(FALSE);
shell->moreinfo = info_tree_new(TRUE);
shell->loadgraph = load_graph_new(75);
gtk_paned_pack1(GTK_PANED(shell->hpaned), shell->tree->scroll,
SHELL_PACK_RESIZE, SHELL_PACK_SHRINK);
gtk_paned_pack1(GTK_PANED(shell->vpaned), shell->info->scroll,
SHELL_PACK_RESIZE, SHELL_PACK_SHRINK);
gtk_notebook_append_page(GTK_NOTEBOOK(shell->notebook),
shell->moreinfo->scroll, NULL);
gtk_notebook_append_page(GTK_NOTEBOOK(shell->notebook),
load_graph_get_framed(shell->loadgraph), NULL);
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(shell->notebook), FALSE);
gtk_notebook_set_show_border(GTK_NOTEBOOK(shell->notebook), FALSE);
shell_status_set_enabled(TRUE);
shell_status_update("Loading modules...");
shell_tree_modules_load(shell->tree);
g_slist_foreach(shell->tree->modules, add_modules_to_gui, shell->tree);
gtk_tree_view_expand_all(GTK_TREE_VIEW(shell->tree->view));
shell_status_update("Done.");
shell_status_set_enabled(FALSE);
gtk_widget_show_all(shell->hpaned);
load_graph_configure_expose(shell->loadgraph);
gtk_widget_hide(shell->notebook);
shell_action_set_enabled("RefreshAction", FALSE);
shell_action_set_active("LeftPaneAction", TRUE);
shell_action_set_active("ToolbarAction", TRUE);
shell_action_set_property("RefreshAction", "is-important", TRUE);
shell_action_set_property("ReportAction", "is-important", TRUE);
}
/**
* 创建所有区域.
* @return 主窗体
*/
GtkWidget *DialogPeer::CreateAllArea()
{
GtkWidget *box;
GtkWidget *hpaned, *vpaned;
gint position;
box = gtk_vbox_new(FALSE, 0);
/* 加入菜单条 */
gtk_box_pack_start(GTK_BOX(box), CreateMenuBar(), FALSE, FALSE, 0);
/* 加入主区域 */
hpaned = gtk_hpaned_new();
g_datalist_set_data(&widset, "main-paned", hpaned);
g_object_set_data(G_OBJECT(hpaned), "position-name",
(gpointer)"main-paned-divide");
position = GPOINTER_TO_INT(g_datalist_get_data(&dtset, "main-paned-divide"));
gtk_paned_set_position(GTK_PANED(hpaned), position);
gtk_box_pack_start(GTK_BOX(box), hpaned, TRUE, TRUE, 0);
g_signal_connect(hpaned, "notify::position",
G_CALLBACK(PanedDivideChanged), &dtset);
/*/* 加入聊天历史记录&输入区域 */
vpaned = gtk_vpaned_new();
g_object_set_data(G_OBJECT(vpaned), "position-name",
(gpointer)"historyinput-paned-divide");
position = GPOINTER_TO_INT(g_datalist_get_data(&dtset,
"historyinput-paned-divide"));
gtk_paned_set_position(GTK_PANED(vpaned), position);
gtk_paned_pack1(GTK_PANED(hpaned), vpaned, TRUE, TRUE);
g_signal_connect(vpaned, "notify::position",
G_CALLBACK(PanedDivideChanged), &dtset);
gtk_paned_pack1(GTK_PANED(vpaned), CreateHistoryArea(), TRUE, TRUE);
gtk_paned_pack2(GTK_PANED(vpaned), CreateInputArea(), FALSE, TRUE);
/* 加入好友信息&附件区域 */
vpaned = gtk_vpaned_new();
g_object_set_data(G_OBJECT(vpaned), "position-name",
(gpointer)"infoenclosure-paned-divide");
position = GPOINTER_TO_INT(g_datalist_get_data(&dtset,
"infoenclosure-paned-divide"));
gtk_paned_set_position(GTK_PANED(vpaned), position);
gtk_paned_pack2(GTK_PANED(hpaned), vpaned, FALSE, TRUE);
g_signal_connect(vpaned, "notify::position",
G_CALLBACK(PanedDivideChanged), &dtset);
gtk_paned_pack1(GTK_PANED(vpaned), CreateInfoArea(), TRUE, TRUE);
gtk_paned_pack2(GTK_PANED(vpaned), CreateFileArea(), FALSE, TRUE);
return box;
}
static GtkWidget *build_main_interface(void)
{
GtkWidget *vbox;
GtkWidget *hpaned;
GtkWidget *vpaned;
GtkWidget *panel;
hpaned = gtk_hpaned_new();
gtk_widget_show(hpaned);
vbox = gtk_vbox_new(FALSE, 3);
gtk_widget_show(vbox);
gtk_paned_pack1(GTK_PANED(hpaned), vbox, FALSE, TRUE);
gtk_box_pack_start(GTK_BOX(vbox),
identity_build_panel(), FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox),
resource_build_panel(), FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox),
build_develop_panel(), FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox),
player_build_summary(), TRUE, TRUE, 0);
main_paned = gtk_hpaned_new();
gtk_widget_show(main_paned);
vpaned = gtk_vpaned_new();
gtk_widget_show(vpaned);
gtk_paned_pack1(GTK_PANED(main_paned), vpaned, TRUE, TRUE);
gtk_paned_pack1(GTK_PANED(vpaned), build_map_panel(), TRUE, TRUE);
chat_panel = gtk_vbox_new(FALSE, 0);
gui_show_splash_page(TRUE, chat_panel);
panel = chat_build_panel();
frontend_gui_register(panel, GUI_DISCONNECT, NULL);
gtk_box_pack_start(GTK_BOX(chat_panel), panel, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(chat_panel),
build_messages_panel(), TRUE, TRUE, 0);
set_16_9_layout(config_get_int_with_default
("settings/layout_16_9", FALSE));
gtk_paned_pack2(GTK_PANED(hpaned), main_paned, TRUE, TRUE);
return hpaned;
}
/**
* gwy_module_browser:
*
* Shows a simple module browser.
**/
void
gwy_module_browser(void)
{
GtkWidget *browser, *scroll, *paned, *info;
if (window) {
gtk_window_present(GTK_WINDOW(window));
return;
}
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size(GTK_WINDOW(window), 480, 480);
gtk_window_set_title(GTK_WINDOW(window), _("Module Browser"));
gtk_window_set_wmclass(GTK_WINDOW(window), "browser_module",
g_get_application_name());
paned = gtk_vpaned_new();
gtk_container_add(GTK_CONTAINER(window), paned);
scroll = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
gtk_paned_pack1(GTK_PANED(paned), scroll, TRUE, FALSE);
browser = gwy_module_browser_construct(window);
gtk_container_add(GTK_CONTAINER(scroll), browser);
info = gwy_module_browser_info_table(window);
gtk_paned_pack2(GTK_PANED(paned), info, FALSE, FALSE);
g_signal_connect(window, "destroy", G_CALLBACK(gtk_widget_destroy), NULL);
g_signal_connect_swapped(window, "destroy",
G_CALLBACK(g_nullify_pointer), &window);
gtk_widget_show_all(window);
}
void
toggle_shrink (GtkWidget *widget,
GtkWidget *child)
{
GtkWidget *parent;
GtkPaned *paned;
gboolean is_child1;
gboolean resize, shrink;
parent = gtk_widget_get_parent (child);
paned = GTK_PANED (parent);
is_child1 = (child == gtk_paned_get_child1 (paned));
gtk_container_child_get (GTK_CONTAINER (paned), child,
"resize", &resize,
"shrink", &shrink,
NULL);
g_object_ref (child);
gtk_container_remove (GTK_CONTAINER (parent), child);
if (is_child1)
gtk_paned_pack1 (paned, child, resize, !shrink);
else
gtk_paned_pack2 (paned, child, resize, !shrink);
g_object_unref (child);
}
/************************************************************* Program Layout */
void
bmd_construct_editablecells(GtkApplication *app, gpointer data)
{
GtkWidget *sw;
bmd_widgets *a = (bmd_widgets *)data;
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_paned_pack1(GTK_PANED(a->paned), sw, TRUE, FALSE);
gtk_widget_set_size_request (sw, 530, 200);
/* create models */
a->items_model = bmd_create_items_model();
a->numbers_model = bmd_create_numbers_model();
/* create tree view */
a->treeview = gtk_tree_view_new_with_model (a->items_model);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW (a->treeview)),
GTK_SELECTION_SINGLE);
bmd_add_columns(NULL, (gpointer)a);
g_object_unref (a->numbers_model);
g_object_unref (a->items_model);
gtk_container_add (GTK_CONTAINER (sw), a->treeview);
}
static void
caja_navigation_window_set_up_sidebar (CajaNavigationWindow *window)
{
GtkWidget *title;
window->sidebar = caja_side_pane_new ();
title = caja_side_pane_get_title (window->sidebar);
gtk_size_group_add_widget (window->details->header_size_group,
title);
gtk_paned_pack1 (GTK_PANED (window->details->content_paned),
GTK_WIDGET (window->sidebar),
FALSE, FALSE);
setup_side_pane_width (window);
g_signal_connect (window->sidebar,
"size_allocate",
G_CALLBACK (side_pane_size_allocate_callback),
window);
add_sidebar_panels (window);
g_signal_connect (window->sidebar,
"close_requested",
G_CALLBACK (side_pane_close_requested_callback),
window);
g_signal_connect (window->sidebar,
"switch_page",
G_CALLBACK (side_pane_switch_page_callback),
window);
gtk_widget_show (GTK_WIDGET (window->sidebar));
}
static VALUE
rg_pack1(VALUE self, VALUE child, VALUE resize, VALUE shrink)
{
gtk_paned_pack1(_SELF(self), RVAL2WIDGET(child),
RVAL2CBOOL(resize), RVAL2CBOOL(shrink));
return self;
}
int main(int argc, char** argv) {
GtkWidget* w;
GtkWidget* box;
GtkWidget* p;
GtkWidget* f;
GtkWidget* menu;
GtkWidget* item;
GtkWidget* sub;
gtk_init(&argc, &argv);
// creates the window
w = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(w), "ev.view");
gtk_window_resize(GTK_WINDOW(w), 640, 480);
box = gtk_vbox_new(FALSE, 0);
// set menues
menu = gtk_menu_bar_new();
gtk_box_pack_start(GTK_BOX(box), menu, FALSE, TRUE, 0);
// File
item = gtk_menu_item_new_with_label("File");
sub = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), sub);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
newMenuItem(sub, "Open data...", G_CALLBACK(menuOpenData), w);
itemRecons = newMenuItem(sub, "Open reconstruction...", G_CALLBACK(menuOpenRec), w);
gtk_widget_set_sensitive(GTK_WIDGET(itemRecons), FALSE);
newMenuItem(sub, "Quit", G_CALLBACK(menuQuit), NULL);
// Map
item = gtk_menu_item_new_with_label("Map");
sub = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), sub);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
newMenuItem(sub, "Open raster...", G_CALLBACK(menuOpenRaster), NULL);
// Layout
p = gtk_hpaned_new();
gtk_widget_set_size_request(p, 100, -1);
f = gtk_frame_new(NULL);
gtk_paned_pack1(GTK_PANED(p), f, TRUE, FALSE);
gtk_widget_set_size_request(f, 50, -1);
initTree(f);
f = gtk_frame_new(NULL);
gtk_paned_pack2(GTK_PANED(p), f, TRUE, FALSE);
gtk_widget_set_size_request(f, 50, -1);
initMap(f);
gtk_box_pack_start(GTK_BOX(box), p, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(w), box);
gtk_widget_show_all(w);
gtk_widget_add_events(w, GDK_KEY_PRESS_MASK);
g_signal_connect(G_OBJECT(w), "key_press_event", G_CALLBACK(keyPress), w);
gtk_main();
return 0;
}
static void cookie_manager_page_init(CookieManagerPage *self)
{
GtkWidget *tree_swin;
GtkWidget *desc_swin;
GtkWidget *paned;
GtkWidget *filter_hbox;
GtkWidget *treeview;
CookieManagerPagePrivate *priv;
self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
COOKIE_MANAGER_PAGE_TYPE, CookieManagerPagePrivate);
priv = self->priv;
priv->ignore_changed_filter = FALSE;
cm_create_toolbar(self);
priv->desc_label = gtk_label_new(CM_EMPTY_LABEL_TEXT);
gtk_label_set_selectable(GTK_LABEL(priv->desc_label), TRUE);
gtk_label_set_line_wrap(GTK_LABEL(priv->desc_label), TRUE);
gtk_label_set_line_wrap_mode(GTK_LABEL(priv->desc_label), PANGO_WRAP_CHAR);
gtk_misc_set_alignment(GTK_MISC(priv->desc_label), 0, 0);
gtk_misc_set_padding(GTK_MISC(priv->desc_label), 3, 3);
gtk_widget_show(priv->desc_label);
desc_swin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(desc_swin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(desc_swin), GTK_SHADOW_NONE);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(desc_swin), priv->desc_label);
gtk_widget_show(desc_swin);
treeview = cm_tree_prepare(self);
gtk_widget_show(treeview);
tree_swin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(tree_swin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(tree_swin), treeview);
gtk_widget_show(tree_swin);
priv->filter_entry = sokoke_search_entry_new (_("Search Cookies by Name or Domain"));
gtk_widget_show(priv->filter_entry);
g_signal_connect(priv->filter_entry, "changed", G_CALLBACK(cm_filter_entry_changed_cb), self);
g_signal_connect(priv->filter_entry, "activate", G_CALLBACK(cm_filter_entry_changed_cb), self);
filter_hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(filter_hbox), priv->filter_entry, TRUE, TRUE, 3);
gtk_widget_show(filter_hbox);
paned = gtk_vpaned_new();
gtk_paned_pack1(GTK_PANED(paned), tree_swin, TRUE, FALSE);
gtk_paned_pack2(GTK_PANED(paned), desc_swin, FALSE, FALSE);
gtk_widget_show(paned);
gtk_box_pack_start(GTK_BOX(self), filter_hbox, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(self), paned, TRUE, TRUE, 0);
}
static void
pollmultidlg_init(PollMultiDlg *pmdlg, GtkWindow *parent) {
GtkWidget *mainbox, *vbox, *paned;
GtkWidget *menu, *label;
pmdlg->dlg = gtk_dialog_new_with_buttons(_("Multi Poll Question"),
parent, GTK_DIALOG_MODAL,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
jam_win_set_size(GTK_WINDOW(pmdlg->dlg), 500, -1);
mainbox = gtk_vbox_new(FALSE, 12);
menu = gtk_menu_new();
gtk_menu_shell_append(GTK_MENU_SHELL(menu),
gtk_menu_item_new_with_mnemonic(_("Choose best answer (_radio buttons)")));
gtk_menu_shell_append(GTK_MENU_SHELL(menu),
gtk_menu_item_new_with_mnemonic(_("Choose best answer (_drop-down menu)")));
gtk_menu_shell_append(GTK_MENU_SHELL(menu),
gtk_menu_item_new_with_mnemonic(_("Select _all that apply (checkboxes)")));
pmdlg->typemenu = gtk_option_menu_new();
gtk_option_menu_set_menu(GTK_OPTION_MENU(pmdlg->typemenu), menu);
gtk_box_pack_start(GTK_BOX(mainbox),
labelled_box_new_expand(_("Choice _Type:"), pmdlg->typemenu, TRUE),
FALSE, FALSE, 0);
paned = gtk_hpaned_new();
gtk_box_pack_start(GTK_BOX(mainbox), paned, TRUE, TRUE, 0);
vbox = gtk_vbox_new(FALSE, 6);
label = gtk_label_new_with_mnemonic(_("_Question:"));
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
pmdlg->question = gtk_text_view_new();
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(pmdlg->question), GTK_WRAP_WORD);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), pmdlg->question);
gtk_box_pack_start(GTK_BOX(vbox),
scroll_wrap(pmdlg->question),
TRUE, TRUE, 0);
gtk_paned_pack1(GTK_PANED(paned), vbox, TRUE, FALSE);
vbox = gtk_vbox_new(FALSE, 6);
pollmulti_make_list(pmdlg);
label = gtk_label_new_with_mnemonic(_("O_ptions:"));
gtk_label_set_mnemonic_widget(GTK_LABEL(label), pmdlg->answers.view);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), pmdlg->answers.box, TRUE, TRUE, 0);
gtk_paned_pack2(GTK_PANED(paned), vbox, TRUE, FALSE);
jam_dialog_set_contents(GTK_DIALOG(pmdlg->dlg), mainbox);
}
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);
}
GtkWidget*
create_MainWindow (void)
{
GtkWidget *MainWindow;
GtkWidget *SplitPane;
GtkWidget *RemoteText;
GtkWidget *LocalText;
GtkTooltips *tooltips;
tooltips = gtk_tooltips_new ();
MainWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request (MainWindow, 400, 300);
gtk_window_set_title (GTK_WINDOW (MainWindow), "Synchronet Sysop Chat");
gtk_window_set_icon_name (GTK_WINDOW (MainWindow), "stock_help-chat");
gtk_window_set_type_hint (GTK_WINDOW (MainWindow), GDK_WINDOW_TYPE_HINT_UTILITY);
SplitPane = gtk_vpaned_new ();
gtk_widget_show (SplitPane);
gtk_container_add (GTK_CONTAINER (MainWindow), SplitPane);
gtk_paned_set_position (GTK_PANED (SplitPane), 148);
RemoteText = gtk_text_view_new ();
gtk_widget_show (RemoteText);
gtk_paned_pack1 (GTK_PANED (SplitPane), RemoteText, FALSE, TRUE);
GTK_WIDGET_UNSET_FLAGS (RemoteText, GTK_CAN_FOCUS);
gtk_tooltips_set_tip (tooltips, RemoteText, "Remote Text Window", NULL);
gtk_text_view_set_editable (GTK_TEXT_VIEW (RemoteText), FALSE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (RemoteText), GTK_WRAP_WORD);
LocalText = gtk_text_view_new ();
gtk_widget_show (LocalText);
gtk_paned_pack2 (GTK_PANED (SplitPane), LocalText, TRUE, TRUE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (LocalText), GTK_WRAP_WORD);
gtk_text_view_set_editable (GTK_TEXT_VIEW (LocalText), FALSE);
g_signal_connect ((gpointer) MainWindow, "destroy",
G_CALLBACK (on_MainWindow_destroy),
NULL);
g_signal_connect ((gpointer) LocalText, "key_press_event",
G_CALLBACK (on_LocalText_key_press_event),
NULL);
/* Store pointers to all widgets, for use by lookup_widget(). */
GLADE_HOOKUP_OBJECT_NO_REF (MainWindow, MainWindow, "MainWindow");
GLADE_HOOKUP_OBJECT (MainWindow, SplitPane, "SplitPane");
GLADE_HOOKUP_OBJECT (MainWindow, RemoteText, "RemoteText");
GLADE_HOOKUP_OBJECT (MainWindow, LocalText, "LocalText");
GLADE_HOOKUP_OBJECT_NO_REF (MainWindow, tooltips, "tooltips");
gtk_widget_grab_focus (LocalText);
gtk_timeout_add(50, get_from_remote, RemoteText);
return MainWindow;
}
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
gs_window_build_ui (GsWindow *window)
{
GtkWidget *menubar;
g_return_if_fail (GS_IS_WINDOW (window));
window->priv->box = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (window), window->priv->box);
gtk_widget_show (window->priv->box);
window->priv->ui_manager = gtk_ui_manager_new ();
window->priv->ui_actions = gtk_action_group_new ("MenuActions");
gtk_action_group_add_actions (window->priv->ui_actions,
action_entries,
G_N_ELEMENTS (action_entries),
window);
gtk_action_group_add_toggle_actions (window->priv->ui_actions,
toggle_action_entries,
G_N_ELEMENTS (toggle_action_entries),
window);
gtk_ui_manager_insert_action_group (window->priv->ui_manager, window->priv->ui_actions, 0);
if (!gtk_ui_manager_add_ui_from_string (window->priv->ui_manager, UI_DEFINITION, -1, NULL)) {
g_assert ("No se pudo cargar la UI");
}
menubar = gtk_ui_manager_get_widget (window->priv->ui_manager, "/MainMenu");
g_assert (GTK_IS_WIDGET (menubar));
gtk_box_pack_start (GTK_BOX (window->priv->box), menubar, FALSE, FALSE, 0);
gtk_widget_show (menubar);
gtk_window_add_accel_group (GTK_WINDOW (window),
gtk_ui_manager_get_accel_group (window->priv->ui_manager));
window->priv->graph = gs_graph_new ();
gtk_widget_show (window->priv->graph);
window->priv->hpaned = gtk_hpaned_new ();
gtk_paned_pack1 (GTK_PANED (window->priv->hpaned), window->priv->graph, TRUE, FALSE);
window->priv->plot_list_panel = gs_plot_list_panel_new (GS_WINDOW (window));
gtk_paned_pack2 (GTK_PANED (window->priv->hpaned), window->priv->plot_list_panel, TRUE, FALSE);
gtk_widget_show (window->priv->plot_list_panel);
gtk_widget_show (window->priv->hpaned);
gtk_box_pack_start (GTK_BOX (window->priv->box), window->priv->hpaned, TRUE, TRUE, 0);
window->priv->statusbar = gtk_statusbar_new ();
gtk_box_pack_end (GTK_BOX (window->priv->box), window->priv->statusbar, FALSE, FALSE, 0);
gtk_widget_show (window->priv->statusbar);
}
static GtkWidget *
create_widget_tree(ParasiteWindow *parasite)
{
GtkWidget *vbox;
GtkWidget *bbox;
GtkWidget *button;
GtkWidget *swin;
GtkWidget *hpaned;
vbox = gtk_vbox_new(FALSE, 6);
gtk_widget_show(vbox);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 12);
bbox = gtk_hbutton_box_new();
gtk_widget_show(bbox);
gtk_box_pack_start(GTK_BOX(vbox), bbox, FALSE, FALSE, 0);
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_START);
gtk_box_set_spacing(GTK_BOX(bbox), 6);
button = gtkparasite_inspect_button_new(parasite);
gtk_widget_show(button);
gtk_box_pack_start(GTK_BOX(bbox), button, FALSE, FALSE, 0);
button = gtk_toggle_button_new_with_mnemonic("_Edit Mode");
gtk_widget_show(button);
gtk_box_pack_start(GTK_BOX(bbox), button, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(button), "toggled",
G_CALLBACK(on_edit_mode_toggled), parasite);
button = gtk_toggle_button_new_with_mnemonic("_Show Graphic Updates");
gtk_widget_show(button);
gtk_box_pack_start(GTK_BOX(bbox), button, FALSE, FALSE, 0);
g_signal_connect(G_OBJECT(button), "toggled",
G_CALLBACK(on_show_graphic_updates_toggled), parasite);
hpaned = gtk_hpaned_new();
gtk_widget_show(hpaned);
gtk_box_pack_start(GTK_BOX(vbox), hpaned, TRUE, TRUE, 0);
swin = create_widget_list_pane(parasite);
gtk_widget_show(swin);
gtk_paned_pack1(GTK_PANED(hpaned), swin, TRUE, TRUE);
swin = create_prop_list_pane(parasite);
gtk_widget_show(swin);
gtk_paned_pack2(GTK_PANED(hpaned), swin, FALSE, TRUE);
return vbox;
}
static void
add_class_list (GtkPaned *pane, struct utt *utt)
{
GtkWidget *view, *frame;
GtkListStore *store;
GtkTreeIter iter;
GtkCellRenderer *renderer;
GtkTreeViewColumn *column;
GtkTreeSelection *sel;
struct utt_module_tree_node *node;
struct utt_module *module;
frame = gtk_frame_new (NULL);
gtk_container_set_border_width (GTK_CONTAINER (frame), 4);
gtk_paned_pack1 (pane, frame, FALSE, FALSE);
store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_POINTER);
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
0, "Utt",
-1);
for (node = utt->modules->first_node;
node;
node = node->sibling) { /* FIXME: only a hack here */
module = node->module;
if (module &&
module->module_type == UTT_MODULE_INPUT_METHOD_TYPE) {
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,
0, module->locale_name (),
1, node,
-1);
}
}
utt->ui.im_view = view = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
gtk_container_set_border_width (GTK_CONTAINER (view), 4);
gtk_container_add (GTK_CONTAINER (frame), view);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (view), FALSE);
renderer = gtk_cell_renderer_text_new (); /* DISCUSS: memory leak? maybe not, scim_setup_ui.cpp talk us */
column = gtk_tree_view_column_new_with_attributes (NULL, renderer,
"text", 0,
NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (view), column);
sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (view));
/* learn from scim_setup_ui.cpp:create_main_ui(), select one item by default */
/* create_splash_view() is a beautiful code also */
gtk_tree_selection_set_mode (sel, GTK_SELECTION_BROWSE);
}
//====================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);
}
void validate_setup_ui(void)
{
GtkWidget *hpanel;
GtkWidget *scrolled_window;
GtkWidget *frame;
GtkTreeViewColumn *col;
GtkCellRenderer *renderer;
hpanel = gtk_hpaned_new();
debr.ui_validate.widget = hpanel;
/*
* Left side
*/
frame = gtk_frame_new("");
gtk_paned_pack1(GTK_PANED(hpanel), frame, FALSE, FALSE);
debr.ui_validate.list_store = gtk_list_store_new(VALIDATE_N_COLUMN,
GDK_TYPE_PIXBUF, G_TYPE_STRING, G_TYPE_POINTER);
scrolled_window = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window), GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_container_add(GTK_CONTAINER(frame), scrolled_window);
debr.ui_validate.tree_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(debr.ui_validate.list_store));
gtk_container_add(GTK_CONTAINER(scrolled_window), debr.ui_validate.tree_view);
gtk_widget_set_size_request(GTK_WIDGET(scrolled_window), 180, 30);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(debr.ui_validate.tree_view), FALSE);
gtk_tree_selection_set_mode(gtk_tree_view_get_selection(GTK_TREE_VIEW(debr.ui_validate.tree_view)),
GTK_SELECTION_MULTIPLE);
g_signal_connect(GTK_OBJECT(debr.ui_validate.tree_view), "cursor-changed", G_CALLBACK(validate_clicked), NULL);
renderer = gtk_cell_renderer_pixbuf_new();
col = gtk_tree_view_column_new_with_attributes("", renderer, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(debr.ui_validate.tree_view), col);
gtk_tree_view_column_add_attribute(col, renderer, "pixbuf", VALIDATE_ICON);
renderer = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new_with_attributes("", renderer, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(debr.ui_validate.tree_view), col);
gtk_tree_view_column_add_attribute(col, renderer, "text", VALIDATE_FILENAME);
/*
* Right side
*/
debr.ui_validate.text_view_vbox = gtk_vbox_new(FALSE, 0);
gtk_paned_pack2(GTK_PANED(hpanel), debr.ui_validate.text_view_vbox, TRUE, TRUE);
gtk_widget_show_all(debr.ui_validate.widget);
}
static void main_window_create_panes(void)
{
main_window.main_vertical_pane = gtk_vpaned_new ();
gtk_widget_show (main_window.main_vertical_pane);
gnome_app_set_contents (GNOME_APP (main_window.window), main_window.main_vertical_pane);
main_window.main_horizontal_pane = gtk_hpaned_new ();
gtk_widget_show (main_window.main_horizontal_pane);
gtk_paned_pack1 (GTK_PANED (main_window.main_vertical_pane), main_window.main_horizontal_pane, FALSE, TRUE);
gtk_signal_connect (GTK_OBJECT (main_window.window), "size_allocate", GTK_SIGNAL_FUNC (classbrowser_accept_size), NULL);
move_classbrowser_position();
if (gnome_config_get_int ("gPHPEdit/main_window/classbrowser_hidden=0") == 1)
classbrowser_hide();
}
/* erstellt die beiden Zeichenbereiche */
static void create_dareas(GtkWidget *top, GtkWidget *box1, GtkWidget *box2)
{
GtkWidget *pane, *frame[N_DAREAS], **darea;
gint i, width, height;
/* reserviert Speicher für die Zeichenbereiche */
darea = (GtkWidget **) g_malloc(N_DAREAS * sizeof(GtkWidget *));
g_signal_connect_swapped(G_OBJECT(top),
"destroy",
G_CALLBACK(g_free),
darea);
/* holt die Breite und Höhe des Hauptfensters */
gtk_window_get_size(GTK_WINDOW(top), &width, &height);
/* erstellt den verstellbaren Balken */
pane = gtk_hpaned_new();
gtk_box_pack_start(GTK_BOX(box1), pane, TRUE, TRUE, 0);
gtk_paned_set_position(GTK_PANED(pane), 0.6 * width);
/* erstellt die beiden Zeichenfelder */
frame[0] = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame[0]), GTK_SHADOW_IN);
gtk_paned_pack1(GTK_PANED(pane), frame[0], FALSE, FALSE);
darea[0] = darea_new();
gtk_container_add(GTK_CONTAINER(frame[0]), darea[0]);
gtk_paned_pack2(GTK_PANED(pane), box2, FALSE, FALSE);
frame[1] = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame[1]), GTK_SHADOW_IN);
gtk_box_pack_start(GTK_BOX(box2), frame[1], TRUE, TRUE, 0);
darea[1] = darea_new();
gtk_widget_add_events(darea[1], GDK_BUTTON_PRESS_MASK);
g_signal_connect(G_OBJECT(darea[1]), "configure_event",
G_CALLBACK(graph_rebuild), NULL);
g_signal_connect(G_OBJECT(darea[1]), "button-press-event",
G_CALLBACK(coord_draw_pos), NULL);
gtk_container_add(GTK_CONTAINER(frame[1]), darea[1]);
g_object_set_data(G_OBJECT(top), "darea", darea);
for (i = 0; i < N_DAREAS; i++) {
gtk_widget_show(darea[i]);
gtk_widget_show(frame[i]);
}
gtk_widget_show(pane);
}
/* paned : a paned widget
child : the child to add
resize : should this child expand when the paned widget is resized.
shrink : can this child be made smaller than its requsition. */
int
clip_GTK_PANEDPACK1(ClipMachine * cm)
{
C_widget *cpan = _fetch_cw_arg(cm);
C_widget *cwid = _fetch_cwidget(cm,_clip_spar(cm,2));
gboolean resize = _clip_parl(cm,3);
gboolean shrink = _clip_parl(cm,4);
CHECKCWID(cpan,GTK_IS_PANED);
CHECKARG2(2,MAP_t,NUMERIC_t); CHECKCWID(cwid,GTK_IS_WIDGET);
CHECKOPT(3,LOGICAL_t); CHECKOPT(4,LOGICAL_t);
if (_clip_parinfo(cm,3)==UNDEF_t) resize = TRUE;
if (_clip_parinfo(cm,4)==UNDEF_t) shrink = TRUE;
gtk_paned_pack1(GTK_PANED(cpan->widget), cwid->widget, resize, shrink);
return 0;
err:
return 1;
}
/**
* 创建文件接收区域.
* @return 主窗体
*/
GtkWidget *DialogPeer::CreateFileReceiveArea()
{
GtkWidget *vpaned;
gint position;
vpaned = gtk_vpaned_new();
g_datalist_set_data(&widset, "file-receive-paned-widget", vpaned);
g_object_set_data(G_OBJECT(vpaned), "position-name",
(gpointer)"file-receive-paned-divide");
position = GPOINTER_TO_INT(g_datalist_get_data(&dtset,
"file-receive-paned-divide"));
gtk_paned_set_position(GTK_PANED(vpaned), position);
g_signal_connect(vpaned, "notify::position",
G_CALLBACK(PanedDivideChanged), &dtset);
gtk_paned_pack1(GTK_PANED(vpaned),CreateFileToReceiveArea(),TRUE,FALSE);
gtk_paned_pack2(GTK_PANED(vpaned),CreateFileReceivedArea(),TRUE,FALSE);
return vpaned;
}
static void
xfce_image_list_dialog_init(XfceImageListDialog *aXfceImageListDialog)
{
XfceImageListDialogPrivate *priv;
priv = g_new0(XfceImageListDialogPrivate, 1);
aXfceImageListDialog->priv = priv;
priv->listbox = xfce_image_list_box_new ();
priv->image_label = GTK_LABEL (gtk_label_new (""));
gtk_widget_show (GTK_WIDGET (priv->image_label));
priv->image = XFCE_SCALED_IMAGE (xfce_scaled_image_new ());
gtk_widget_set_size_request (GTK_WIDGET (priv->image), 400, 400);
priv->image_box = GTK_BOX (gtk_vbox_new (FALSE, 7));
gtk_container_set_border_width (GTK_CONTAINER (priv->image_box), 5);
gtk_box_pack_start (GTK_BOX (priv->image_box), GTK_WIDGET (priv->image_label), FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (priv->image_box), GTK_WIDGET (priv->image), FALSE, FALSE, 0);
gtk_widget_show_all (GTK_WIDGET (priv->image_box));
gtk_widget_show (GTK_WIDGET (priv->listbox));
priv->paned = GTK_PANED (gtk_hpaned_new ());
gtk_paned_pack1 (priv->paned, GTK_WIDGET (priv->listbox), TRUE, TRUE);
gtk_paned_pack2 (priv->paned, GTK_WIDGET (priv->image_box), TRUE, TRUE);
gtk_widget_show (GTK_WIDGET (priv->paned));
gtk_box_pack_start (GTK_BOX (GTK_DIALOG (aXfceImageListDialog)->vbox), GTK_WIDGET (priv->paned), TRUE, TRUE, 0);
gtk_dialog_add_button (GTK_DIALOG (aXfceImageListDialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
priv->ok_button = GTK_BUTTON (gtk_dialog_add_button (GTK_DIALOG (aXfceImageListDialog), GTK_STOCK_OK, GTK_RESPONSE_OK));
gtk_dialog_set_default_response (GTK_DIALOG (aXfceImageListDialog), GTK_RESPONSE_CANCEL);
gtk_widget_set_sensitive (GTK_WIDGET (priv->ok_button), FALSE);
g_signal_connect (G_OBJECT (priv->listbox), "selection-changed", G_CALLBACK (xfce_image_list_dialog_selection_changed_cb), aXfceImageListDialog);
g_signal_connect (G_OBJECT (priv->listbox), "notify::changed", G_CALLBACK (xfce_image_list_dialog_notify_changed_cb), aXfceImageListDialog);
g_signal_connect (G_OBJECT (priv->listbox), "notify::filename", G_CALLBACK (xfce_image_list_dialog_notify_fname_changed_cb), aXfceImageListDialog);
g_signal_connect (G_OBJECT (priv->ok_button), "clicked", G_CALLBACK (xfce_image_list_dialog_ok_button_clicked_cb), aXfceImageListDialog);
}
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;
}
void
set_mode (int _mode)
{
if (_mode == mode)
return;
gtk_widget_unparent (status_bar);
mode = _mode;
//if (gtk_widget_get_parent (notebook))
// gtk_container_remove (GTK_CONTAINER (gtk_widget_get_parent (notebook)), notebook);
//if (gtk_widget_get_parent (proj_notebook))
// gtk_container_remove (GTK_CONTAINER (gtk_widget_get_parent (proj_notebook)), proj_notebook);
if (!gtk_widget_get_parent (content_paned))
gtk_box_pack_start (GTK_BOX (content_box), content_paned, TRUE, TRUE, 0);
if (!gtk_widget_get_parent (proj_notebook))
gtk_paned_pack1 (GTK_PANED (content_paned), proj_notebook, FALSE, FALSE);
//if (gtk_notebook_get_n_pages (GTK_NOTEBOOK (proj_notebook)) == 4)
// project_notebook_show_tree_views (PROJECT_NOTEBOOK (proj_notebook), FALSE);
//if (gtk_widget_get_parent (symbols_view))
// gtk_container_remove (GTK_CONTAINER (gtk_widget_get_parent (symbols_view)), symbols_view);
if (_mode == GIDLE_MODE_FILE)
{
project_notebook_show_tree_views (PROJECT_NOTEBOOK (proj_notebook), FALSE);
gtk_paned_pack2 (GTK_PANED (content_paned), notebook, TRUE, TRUE);
}
else
{
project_notebook_show_tree_views (PROJECT_NOTEBOOK (proj_notebook), TRUE);
gtk_paned_pack2 (GTK_PANED (content_paned), notebook, TRUE, TRUE);
gtk_widget_set_size_request (proj_notebook, 200, 200);
}
gtk_box_pack_start (GTK_BOX (content_box), status_bar, FALSE, FALSE, 0);
gtk_widget_show_all (content_box);
path_browser_show_paths (path_browser);
}
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);
}
/**
* 创建文件接收和发送区域.
* @return 主窗体
*/
GtkWidget *DialogPeer::CreateFileArea()
{
GtkWidget *frame, *vpaned;
gint position;
frame = gtk_frame_new(_("Enclosure."));
g_datalist_set_data(&widset, "file-enclosure-frame-widget", frame);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);
vpaned = gtk_vpaned_new();
g_object_set_data(G_OBJECT(vpaned), "position-name",
(gpointer)"enclosure-paned-divide");
position = GPOINTER_TO_INT(g_datalist_get_data(&dtset,
"enclosure-paned-divide"));
gtk_paned_set_position(GTK_PANED(vpaned), position);
g_signal_connect(vpaned, "notify::position",
G_CALLBACK(PanedDivideChanged), &dtset);
gtk_container_add(GTK_CONTAINER(frame), vpaned);
gtk_paned_pack1(GTK_PANED(vpaned),CreateFileReceiveArea(),TRUE,TRUE);
gtk_paned_pack2(GTK_PANED(vpaned),CreateFileSendArea(),FALSE,TRUE);
return frame;
}
