GtkWidget * nh_message_new() { GtkWidget *message_h; GtkWidget *sw; GtkTextIter iter; GtkTextBuffer *t; message_h = gtk_handle_box_new(); GTK_HANDLE_BOX(message_h)->shrink_on_detach = 1; message_text = gtk_text_view_new(); gtk_widget_show(message_text); GTK_WIDGET_UNSET_FLAGS(message_text, GTK_CAN_FOCUS); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(message_text), GTK_WRAP_WORD); t = gtk_text_view_get_buffer(GTK_TEXT_VIEW(message_text)); gtk_text_buffer_create_tag(t, "warning", "foreground", "red", NULL); gtk_text_buffer_get_end_iter(t, &iter); gtk_text_buffer_create_mark(t, "nh_end", &iter, FALSE); sw = nh_gtk_new_and_add(gtk_scrolled_window_new(NULL, NULL), message_h, ""); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(sw), message_text); return message_h; }
bool wxToolBar::Create( wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style, const wxString& name ) { if ( !PreCreation( parent, pos, size ) || !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name )) { wxFAIL_MSG( wxT("wxToolBar creation failed") ); return false; } FixupStyle(); m_toolbar = GTK_TOOLBAR( gtk_toolbar_new() ); #if !GTK_CHECK_VERSION(3,0,0) && !defined(GTK_DISABLE_DEPRECATED) if (gtk_check_version(2, 12, 0)) { m_tooltips = gtk_tooltips_new(); g_object_ref(m_tooltips); gtk_object_sink(GTK_OBJECT(m_tooltips)); } #endif GtkSetStyle(); if (style & wxTB_DOCKABLE) { m_widget = gtk_handle_box_new(); g_signal_connect(m_widget, "child_detached", G_CALLBACK(child_detached), NULL); g_signal_connect(m_widget, "child_attached", G_CALLBACK(child_attached), NULL); if (style & wxTB_FLAT) gtk_handle_box_set_shadow_type( GTK_HANDLE_BOX(m_widget), GTK_SHADOW_NONE ); } else { m_widget = gtk_event_box_new(); ConnectWidget( m_widget ); } g_object_ref(m_widget); gtk_container_add(GTK_CONTAINER(m_widget), GTK_WIDGET(m_toolbar)); gtk_widget_show(GTK_WIDGET(m_toolbar)); m_parent->DoAddChild( this ); PostCreation(size); g_signal_connect_after(m_toolbar, "size_request", G_CALLBACK(size_request), this); return true; }
bool wxToolBar::Create( wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style, const wxString& name ) { m_needParent = true; m_insertCallback = (wxInsertChildFunction)wxInsertChildInToolBar; if ( !PreCreation( parent, pos, size ) || !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name )) { wxFAIL_MSG( wxT("wxToolBar creation failed") ); return false; } FixupStyle(); GtkOrientation orient; GtkToolbarStyle gtkStyle; GetGtkStyle(style, &orient, >kStyle); m_toolbar = GTK_TOOLBAR( gtk_toolbar_new(orient, gtkStyle) ); SetToolSeparation(7); if (style & wxTB_DOCKABLE) { m_widget = gtk_handle_box_new(); gtk_container_add( GTK_CONTAINER(m_widget), GTK_WIDGET(m_toolbar) ); gtk_widget_show( GTK_WIDGET(m_toolbar) ); if (style & wxTB_FLAT) gtk_handle_box_set_shadow_type( GTK_HANDLE_BOX(m_widget), GTK_SHADOW_NONE ); } else { m_widget = gtk_event_box_new(); gtk_container_add( GTK_CONTAINER(m_widget), GTK_WIDGET(m_toolbar) ); ConnectWidget( m_widget ); gtk_widget_show(GTK_WIDGET(m_toolbar)); } gtk_toolbar_set_tooltips( GTK_TOOLBAR(m_toolbar), TRUE ); if (style & wxTB_FLAT) gtk_toolbar_set_button_relief( GTK_TOOLBAR(m_toolbar), GTK_RELIEF_NONE ); m_parent->DoAddChild( this ); PostCreation(size); return true; }
/* * Creates a new GtkWidget of class GtkHandleBox, performing any specialized * initialization needed for the widget to work correctly in this environment. * If a dialog box is used to initialize the widget, return NULL from this * function, and call data->callback with your new widget when it is done. * If the widget needs a special destroy handler, add a signal here. */ GtkWidget * gb_handle_box_new (GbWidgetNewData * data) { GtkWidget *new_widget = gtk_handle_box_new (); /* We set the snap edge to top, which matches the default handle position, since we don't support the default value of -1. */ gtk_handle_box_set_snap_edge (GTK_HANDLE_BOX (new_widget), GTK_POS_TOP); if (data->action != GB_LOADING) gtk_container_add (GTK_CONTAINER (new_widget), editor_new_placeholder ()); return new_widget; }
void interface (gint argc, gchar *argv[]) { GtkWidget *MenuBar; GtkWidget *VBox; GtkWidget *HandleBox; gtk_set_locale(); gtk_init (&argc, &argv); Settings = init_settings (); MainWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW(MainWindow), g_strconcat (WELCOME_MSG, " ", APP_NAME, " ", VERSION_NUMBER, NULL)); gtk_window_set_policy (GTK_WINDOW(MainWindow), TRUE, TRUE, FALSE); gtk_widget_set_usize (MainWindow, MAIN_WINDOW_WIDTH, MAIN_WINDOW_HEIGHT); gtk_signal_connect (GTK_OBJECT(MainWindow), "delete_event", (GtkSignalFunc) quit, NULL); gtk_signal_connect (GTK_OBJECT(MainWindow), "destroy", (GtkSignalFunc) quit, NULL); FileProperties = g_array_new (TRUE, FALSE, sizeof(t_fprops)); VBox = gtk_vbox_new (FALSE, 0); gtk_container_add (GTK_CONTAINER(MainWindow), VBox); HandleBox = gtk_handle_box_new(); gtk_container_set_border_width (GTK_CONTAINER(HandleBox), 2); gtk_box_pack_start (GTK_BOX(VBox), HandleBox, FALSE, FALSE, 0); init_toolbar (GTK_BOX(VBox)); MainNotebook = gtk_notebook_new (); read_uedit_wordfile (WORDFILE); editor_init(); MenuBar = menubar_new (MainWindow); gtk_container_add (GTK_CONTAINER(HandleBox), MenuBar); gtk_notebook_popup_enable (GTK_NOTEBOOK(MainNotebook)); gtk_notebook_set_homogeneous_tabs (GTK_NOTEBOOK(MainNotebook), TRUE); gtk_notebook_set_scrollable (GTK_NOTEBOOK(MainNotebook), TRUE); gtk_box_pack_start (GTK_BOX(VBox), MainNotebook, TRUE, TRUE, 0); gtk_signal_connect (GTK_OBJECT(MainNotebook), "switch_page", (GtkSignalFunc) set_title, NULL); init_msgbar (GTK_BOX(VBox)); print_msg ("You're the welcome..."); command_line (argc, argv); autosave (AUTOSAVE_DELAY); gtk_widget_show_all (MainWindow); if (!MSGBAR_DISPLAY) hide_msgbar (); if (!TOOLBAR_DISPLAY) hide_toolbar (); gtk_timeout_add (80, (GtkFunction)display_line_column, NULL); gtk_main (); set_preferences_to_disk (&Settings, NULL); gtk_item_factory_dump_rc (g_strconcat (g_get_home_dir (), PATH_SEP_STRING, CONF_DIR, PATH_SEP_STRING, "AccelRC", NULL), NULL, FALSE); }
void wxMenuBar::Init(size_t n, wxMenu *menus[], const wxString titles[], long style) { // the parent window is known after wxFrame::SetMenu() m_needParent = false; m_style = style; m_invokingWindow = (wxWindow*) NULL; if (!PreCreation( (wxWindow*) NULL, wxDefaultPosition, wxDefaultSize ) || !CreateBase( (wxWindow*) NULL, -1, wxDefaultPosition, wxDefaultSize, style, wxDefaultValidator, wxT("menubar") )) { wxFAIL_MSG( wxT("wxMenuBar creation failed") ); return; } m_menubar = gtk_menu_bar_new(); m_accel = gtk_accel_group_new(); if (style & wxMB_DOCKABLE) { m_widget = gtk_handle_box_new(); gtk_container_add( GTK_CONTAINER(m_widget), GTK_WIDGET(m_menubar) ); gtk_widget_show( GTK_WIDGET(m_menubar) ); } else { m_widget = GTK_WIDGET(m_menubar); } PostCreation(); ApplyWidgetStyle(); for (size_t i = 0; i < n; ++i ) Append(menus[i], titles[i]); // VZ: for some reason connecting to menus "deactivate" doesn't work (we // don't get it when the menu is dismissed by clicking outside the // toolbar) so we connect to the global one, even if it means that we // can't pass the menu which was closed in wxMenuEvent object gtk_signal_connect( GTK_OBJECT(GTK_MENU_SHELL(m_menubar)), "deactivate", GTK_SIGNAL_FUNC(gtk_menu_close_callback), (gpointer)this ); }
/** * cact_main_toolbar_activate: * @window: this #CactMainWindow. * @toolbar_id: the id of the activated toolbar. * @ui_manager: the #GtkUIManager. * @is_active: whether this toolbar is activated or not. * * Activate or desactivate the toolbar. */ void cact_main_toolbar_activate( CactMainWindow *window, int toolbar_id, GtkUIManager *ui_manager, gboolean is_active ) { static const gchar *thisfn = "cact_main_toolbar_activate"; ToolbarProps *props; GtkWidget *toolbar, *hbox, *handle; gulong attach_id, detach_id; props = get_toolbar_properties( toolbar_id ); if( !props ){ return; } toolbar = gtk_ui_manager_get_widget( ui_manager, props->ui_path ); g_debug( "%s: toolbar=%p, path=%s, ref_count=%d", thisfn, ( void * ) toolbar, props->ui_path, G_OBJECT( toolbar )->ref_count ); hbox = base_window_get_widget( BASE_WINDOW( window ), "ToolbarHBox" ); if( is_active ){ handle = gtk_handle_box_new(); gtk_handle_box_set_snap_edge( GTK_HANDLE_BOX( handle ), GTK_POS_LEFT ); g_object_set_data( G_OBJECT( toolbar ), "cact-main-toolbar-handle", handle ); attach_id = g_signal_connect( handle, "child-attached", (GCallback ) on_attach_toolbar, window ); g_object_set_data( G_OBJECT( handle ), "cact-handle-attach-id", ( gpointer ) attach_id ); detach_id = g_signal_connect( handle, "child-detached", (GCallback ) on_detach_toolbar, window ); g_object_set_data( G_OBJECT( handle ), "cact-handle-detach-id", ( gpointer ) detach_id ); g_object_weak_ref( G_OBJECT( handle ), ( GWeakNotify ) on_handle_finalize, NULL ); gtk_container_add( GTK_CONTAINER( handle ), toolbar ); gtk_container_add( GTK_CONTAINER( hbox ), handle ); reorder_toolbars( hbox, toolbar_id, handle ); gtk_widget_show_all( handle ); } else { handle = ( GtkWidget * ) g_object_get_data( G_OBJECT( toolbar ), "cact-main-toolbar-handle" ); detach_id = ( gulong ) g_object_get_data( G_OBJECT( handle ), "cact-handle-detach-id" ); g_signal_handler_disconnect( handle, detach_id ); attach_id = ( gulong ) g_object_get_data( G_OBJECT( handle ), "cact-handle-attach-id" ); g_signal_handler_disconnect( handle, attach_id ); gtk_container_remove( GTK_CONTAINER( handle ), toolbar ); gtk_container_remove( GTK_CONTAINER( hbox ), handle ); } na_settings_set_boolean( props->prefs_key, is_active ); }
/*! * Set "toolbars detachable" setting. */ void EV_GnomeToolbar::setDetachable(gboolean detachable) { if (detachable && GTK_IS_TOOLBAR(gtk_bin_get_child(GTK_BIN(m_wHandleBox)))) { // not detachable -> detachable GtkWidget *box = gtk_handle_box_new(); gtk_handle_box_set_shadow_type(GTK_HANDLE_BOX(box), GTK_SHADOW_NONE); gtk_widget_reparent(m_wToolbar, box); gtk_container_add(GTK_CONTAINER(m_wHandleBox), box); if (!isHidden()) { gtk_widget_show(box); } } else if (!detachable && GTK_IS_HANDLE_BOX(gtk_bin_get_child(GTK_BIN(m_wHandleBox)))) { // detachable -> not detachable GtkWidget *box = gtk_bin_get_child(GTK_BIN(m_wHandleBox)); g_object_ref(G_OBJECT(box)); gtk_container_remove(GTK_CONTAINER(m_wHandleBox), box); gtk_widget_reparent(m_wToolbar, m_wHandleBox); g_object_unref(G_OBJECT(box)); } }
GtkWidget * nh_message_new() { GtkWidget *message_h; GtkWidget *message_hbox; message_h = gtk_handle_box_new(); GTK_HANDLE_BOX(message_h)->shrink_on_detach = 1; message_hbox = nh_gtk_new_and_add(gtk_hbox_new(FALSE, 0), message_h, ""); message_text = nh_gtk_new_and_pack(gtk_text_new(NULL, NULL), message_hbox, "", TRUE, TRUE, NH_PAD); GTK_WIDGET_UNSET_FLAGS(message_text, GTK_CAN_FOCUS); gtk_text_set_word_wrap((GtkText *) message_text, TRUE); (void)nh_gtk_new_and_pack(gtk_vscrollbar_new(GTK_TEXT(message_text)->vadj), message_hbox, "", FALSE, FALSE, NH_PAD); return message_h; }
void wxMenuBar::Init(size_t n, wxMenu *menus[], const wxString titles[], long style) { #if wxUSE_LIBHILDON || wxUSE_LIBHILDON2 // Hildon window uses a single menu instead of a menu bar, so wxMenuBar is // the same as menu in this case m_widget = m_menubar = gtk_menu_new(); #else // !wxUSE_LIBHILDON && !wxUSE_LIBHILDON2 if (!PreCreation( NULL, wxDefaultPosition, wxDefaultSize ) || !CreateBase( NULL, -1, wxDefaultPosition, wxDefaultSize, style, wxDefaultValidator, wxT("menubar") )) { wxFAIL_MSG( wxT("wxMenuBar creation failed") ); return; } m_menubar = gtk_menu_bar_new(); if (style & wxMB_DOCKABLE) { m_widget = gtk_handle_box_new(); gtk_container_add(GTK_CONTAINER(m_widget), m_menubar); gtk_widget_show(m_menubar); } else { m_widget = m_menubar; } PostCreation(); GTKApplyWidgetStyle(); #endif // wxUSE_LIBHILDON || wxUSE_LIBHILDON2/!wxUSE_LIBHILDON && !wxUSE_LIBHILDON2 g_object_ref(m_widget); for (size_t i = 0; i < n; ++i ) Append(menus[i], titles[i]); }
void add_tasks_toolbar_widget (GtkUIManager *tasks_uim_widget, GtkWidget *widget, gpointer user_data) { GtkWidget *handle_box; GUI *appGUI = (GUI *)user_data; if (GTK_IS_TOOLBAR (widget)) { appGUI->tsk->tasks_toolbar = GTK_TOOLBAR (widget); handle_box = gtk_handle_box_new (); gtk_widget_show (handle_box); gtk_container_add (GTK_CONTAINER (handle_box), widget); gtk_box_pack_start (appGUI->tsk->vbox, handle_box, FALSE, FALSE, 0); g_signal_connect_swapped (widget, "destroy", G_CALLBACK (gtk_widget_destroy), handle_box); } else { gtk_box_pack_start (GTK_BOX(appGUI->tsk->vbox), widget, FALSE, FALSE, 0); } gtk_widget_show (widget); }
GtkWidget* create_YappiWindow (void) { GtkWidget *YappiWindow; GtkWidget *vbox2; GtkWidget *hbox4; GtkWidget *vbox4; GtkWidget *hbox5; GtkWidget *CommandLabel1; GtkWidget *InputBox; GtkWidget *OkButton; GtkWidget *handlebox1; GtkWidget *toolbar4; GtkIconSize tmp_toolbar_icon_size; GtkWidget *PlayBt; GtkWidget *StopBt; GtkWidget *scrollBt; GtkWidget *tmp_image; GtkWidget *MaximazeBt; GtkWidget *textview1; GtkWidget *statusbar1; YappiWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (YappiWindow), _("Yappi !")); vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox2); gtk_container_add (GTK_CONTAINER (YappiWindow), vbox2); hbox4 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox4); gtk_box_pack_start (GTK_BOX (vbox2), hbox4, FALSE, FALSE, 0); vbox4 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox4); gtk_box_pack_start (GTK_BOX (hbox4), vbox4, FALSE, FALSE, 0); hbox5 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox5); gtk_box_pack_start (GTK_BOX (vbox4), hbox5, TRUE, FALSE, 0); CommandLabel1 = gtk_label_new (_(" CODE: ")); gtk_widget_show (CommandLabel1); gtk_box_pack_start (GTK_BOX (hbox5), CommandLabel1, TRUE, TRUE, 0); InputBox = gtk_entry_new (); gtk_widget_show (InputBox); gtk_box_pack_start (GTK_BOX (hbox5), InputBox, TRUE, TRUE, 0); gtk_widget_set_size_request (InputBox, 115, -1); gtk_entry_set_text (GTK_ENTRY (InputBox), _("PRUEBA")); gtk_entry_set_activates_default (GTK_ENTRY (InputBox), TRUE); OkButton = gtk_image_new_from_stock ("gtk-ok", GTK_ICON_SIZE_BUTTON); gtk_widget_show (OkButton); gtk_box_pack_start (GTK_BOX (hbox5), OkButton, TRUE, TRUE, 0); handlebox1 = gtk_handle_box_new (); gtk_widget_show (handlebox1); gtk_box_pack_start (GTK_BOX (hbox4), handlebox1, TRUE, TRUE, 0); toolbar4 = gtk_toolbar_new (); gtk_widget_show (toolbar4); gtk_container_add (GTK_CONTAINER (handlebox1), toolbar4); gtk_widget_set_size_request (toolbar4, 209, 0); gtk_toolbar_set_style (GTK_TOOLBAR (toolbar4), GTK_TOOLBAR_ICONS); tmp_toolbar_icon_size = gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar4)); PlayBt = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-media-play"); gtk_widget_show (PlayBt); gtk_container_add (GTK_CONTAINER (toolbar4), PlayBt); gtk_tool_item_set_is_important (GTK_TOOL_ITEM (PlayBt), TRUE); StopBt = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-media-pause"); gtk_widget_show (StopBt); gtk_container_add (GTK_CONTAINER (toolbar4), StopBt); gtk_tool_item_set_is_important (GTK_TOOL_ITEM (StopBt), TRUE); scrollBt = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-go-down"); gtk_widget_show (scrollBt); gtk_container_add (GTK_CONTAINER (toolbar4), scrollBt); gtk_tool_item_set_is_important (GTK_TOOL_ITEM (scrollBt), TRUE); tmp_image = gtk_image_new_from_stock ("gtk-zoom-in", tmp_toolbar_icon_size); gtk_widget_show (tmp_image); MaximazeBt = (GtkWidget*) gtk_tool_button_new (tmp_image, ""); gtk_widget_show (MaximazeBt); gtk_container_add (GTK_CONTAINER (toolbar4), MaximazeBt); gtk_tool_item_set_is_important (GTK_TOOL_ITEM (MaximazeBt), TRUE); textview1 = gtk_text_view_new (); gtk_widget_show (textview1); gtk_box_pack_start (GTK_BOX (vbox2), textview1, TRUE, TRUE, 1); gtk_widget_set_size_request (textview1, 136, 87); gtk_container_set_border_width (GTK_CONTAINER (textview1), 5); statusbar1 = gtk_statusbar_new (); gtk_widget_show (statusbar1); gtk_box_pack_start (GTK_BOX (vbox2), statusbar1, FALSE, FALSE, 0); g_signal_connect ((gpointer) InputBox, "activate", G_CALLBACK (on_InputBox_activate), NULL); g_signal_connect ((gpointer) InputBox, "grab_focus", G_CALLBACK (InputBox_grab_focus), NULL); g_signal_connect ((gpointer) OkButton, "button_press_event", G_CALLBACK (on_OkButton_button_press_event), NULL); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (YappiWindow, YappiWindow, "YappiWindow"); GLADE_HOOKUP_OBJECT (YappiWindow, vbox2, "vbox2"); GLADE_HOOKUP_OBJECT (YappiWindow, hbox4, "hbox4"); GLADE_HOOKUP_OBJECT (YappiWindow, vbox4, "vbox4"); GLADE_HOOKUP_OBJECT (YappiWindow, hbox5, "hbox5"); GLADE_HOOKUP_OBJECT (YappiWindow, CommandLabel1, "CommandLabel1"); GLADE_HOOKUP_OBJECT (YappiWindow, InputBox, "InputBox"); GLADE_HOOKUP_OBJECT (YappiWindow, OkButton, "OkButton"); GLADE_HOOKUP_OBJECT (YappiWindow, handlebox1, "handlebox1"); GLADE_HOOKUP_OBJECT (YappiWindow, toolbar4, "toolbar4"); GLADE_HOOKUP_OBJECT (YappiWindow, PlayBt, "PlayBt"); GLADE_HOOKUP_OBJECT (YappiWindow, StopBt, "StopBt"); GLADE_HOOKUP_OBJECT (YappiWindow, scrollBt, "scrollBt"); GLADE_HOOKUP_OBJECT (YappiWindow, MaximazeBt, "MaximazeBt"); GLADE_HOOKUP_OBJECT (YappiWindow, textview1, "textview1"); GLADE_HOOKUP_OBJECT (YappiWindow, statusbar1, "statusbar1"); return YappiWindow; }
static GtkWidget * normal_contents (void) { GtkWidget *table; GtkWidget *handlebox; GtkWidget *statusbar; GtkWidget *contents; GtkWidget *sw; GtkActionGroup *action_group; GtkUIManager *ui_manager; table = gtk_table_new (1, 4, FALSE); /* Create the menubar */ action_group = gtk_action_group_new ("mainmenu"); gtk_action_group_add_actions (action_group, menu_items, G_N_ELEMENTS (menu_items), NULL); gtk_action_group_add_actions (action_group, tool_items, G_N_ELEMENTS (tool_items), NULL); ui_manager = gtk_ui_manager_new (); gtk_ui_manager_insert_action_group (ui_manager, action_group, 0); /* create menu items */ gtk_ui_manager_add_ui_from_string (ui_manager, menu_item_string, -1, NULL); gtk_table_attach (GTK_TABLE (table), gtk_ui_manager_get_widget (ui_manager, "/ui/menubar"), /* X direction */ /* Y direction */ 0, 1, 0, 1, GTK_EXPAND | GTK_FILL, 0, 0, 0); handlebox = gtk_handle_box_new (); gtk_container_add (GTK_CONTAINER (handlebox), gtk_ui_manager_get_widget (ui_manager, "/ui/toolbar")); gtk_table_attach (GTK_TABLE (table), handlebox, /* X direction */ /* Y direction */ 0, 1, 1, 2, GTK_EXPAND | GTK_FILL, 0, 0, 0); /* Create document */ sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN); gtk_table_attach (GTK_TABLE (table), sw, /* X direction */ /* Y direction */ 0, 1, 2, 3, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); contents = gtk_text_view_new (); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (contents), PANGO_WRAP_WORD); gtk_container_add (GTK_CONTAINER (sw), contents); /* Create statusbar */ statusbar = gtk_statusbar_new (); gtk_table_attach (GTK_TABLE (table), statusbar, /* X direction */ /* Y direction */ 0, 1, 3, 4, GTK_EXPAND | GTK_FILL, 0, 0, 0); gtk_widget_show_all (table); g_object_unref (ui_manager); return table; }
GtkWidget* create_bsv_main_win (void) { GtkWidget *bsv_main_win; GtkWidget *vbox1; GtkWidget *menubar1; GtkWidget *menuitem4; GtkWidget *menuitem4_menu; GtkWidget *preferences_main; GtkWidget *image18; GtkWidget *separatormenuitem1; GtkWidget *quit1; GtkWidget *menuitem5; GtkWidget *menuitem5_menu; GtkWidget *preferences_driver; GtkWidget *image19; GtkWidget *information2; GtkWidget *handlebox1; GtkWidget *toolbar1; GtkWidget *start_but; GtkWidget *alignment1; GtkWidget *hbox24; GtkWidget *image20; GtkWidget *label10; GtkWidget *stop_but; GtkWidget *alignment2; GtkWidget *hbox25; GtkWidget *image21; GtkWidget *label11; GtkWidget *handlebox2; GtkWidget *toolbar2; GtkWidget *chansel_combo; GtkWidget *combo_entry1; GtkWidget *label12; GtkObject *mag_spinbut_adj; GtkWidget *mag_spinbut; GtkWidget *label13; GtkWidget *combo1; GtkWidget *combo_entry2; GtkWidget *apply_but; GtkWidget *hbox18; GtkWidget *drawingarea; GtkWidget *vscrollbar1; GtkWidget *statusbar; GtkAccelGroup *accel_group; accel_group = gtk_accel_group_new (); bsv_main_win = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (bsv_main_win), _("BSView")); gtk_window_set_default_size (GTK_WINDOW (bsv_main_win), 500, 300); vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox1); gtk_container_add (GTK_CONTAINER (bsv_main_win), vbox1); menubar1 = gtk_menu_bar_new (); gtk_widget_show (menubar1); gtk_box_pack_start (GTK_BOX (vbox1), menubar1, FALSE, FALSE, 0); menuitem4 = gtk_menu_item_new_with_mnemonic (_("_Viewer")); gtk_widget_show (menuitem4); gtk_container_add (GTK_CONTAINER (menubar1), menuitem4); menuitem4_menu = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem4), menuitem4_menu); preferences_main = gtk_image_menu_item_new_with_mnemonic (_("_Preferences")); gtk_widget_show (preferences_main); gtk_container_add (GTK_CONTAINER (menuitem4_menu), preferences_main); image18 = gtk_image_new_from_stock ("gtk-preferences", GTK_ICON_SIZE_MENU); gtk_widget_show (image18); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (preferences_main), image18); separatormenuitem1 = gtk_menu_item_new (); gtk_widget_show (separatormenuitem1); gtk_container_add (GTK_CONTAINER (menuitem4_menu), separatormenuitem1); gtk_widget_set_sensitive (separatormenuitem1, FALSE); quit1 = gtk_image_menu_item_new_from_stock ("gtk-quit", accel_group); gtk_widget_show (quit1); gtk_container_add (GTK_CONTAINER (menuitem4_menu), quit1); menuitem5 = gtk_menu_item_new_with_mnemonic (_("_Driver")); gtk_widget_show (menuitem5); gtk_container_add (GTK_CONTAINER (menubar1), menuitem5); menuitem5_menu = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem5), menuitem5_menu); preferences_driver = gtk_image_menu_item_new_with_mnemonic (_("_Preferences")); gtk_widget_show (preferences_driver); gtk_container_add (GTK_CONTAINER (menuitem5_menu), preferences_driver); image19 = gtk_image_new_from_stock ("gtk-preferences", GTK_ICON_SIZE_MENU); gtk_widget_show (image19); gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (preferences_driver), image19); information2 = gtk_image_menu_item_new_from_stock ("gtk-dialog-info", accel_group); gtk_widget_show (information2); gtk_container_add (GTK_CONTAINER (menuitem5_menu), information2); handlebox1 = gtk_handle_box_new (); gtk_widget_show (handlebox1); gtk_box_pack_start (GTK_BOX (vbox1), handlebox1, FALSE, FALSE, 0); toolbar1 = gtk_toolbar_new (); gtk_widget_show (toolbar1); gtk_container_add (GTK_CONTAINER (handlebox1), toolbar1); gtk_toolbar_set_style (GTK_TOOLBAR (toolbar1), GTK_TOOLBAR_ICONS); start_but = gtk_button_new (); gtk_widget_show (start_but); gtk_toolbar_append_widget (GTK_TOOLBAR (toolbar1), start_but, _("Start Aquistion"), NULL); alignment1 = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_widget_show (alignment1); gtk_container_add (GTK_CONTAINER (start_but), alignment1); hbox24 = gtk_hbox_new (FALSE, 2); gtk_widget_show (hbox24); gtk_container_add (GTK_CONTAINER (alignment1), hbox24); image20 = gtk_image_new_from_stock ("gtk-yes", GTK_ICON_SIZE_BUTTON); gtk_widget_show (image20); gtk_box_pack_start (GTK_BOX (hbox24), image20, FALSE, FALSE, 0); label10 = gtk_label_new_with_mnemonic (_("_Start")); gtk_widget_show (label10); gtk_box_pack_start (GTK_BOX (hbox24), label10, FALSE, FALSE, 0); stop_but = gtk_button_new (); gtk_widget_show (stop_but); gtk_toolbar_append_widget (GTK_TOOLBAR (toolbar1), stop_but, _("Stop Aquistion"), NULL); gtk_widget_set_sensitive (stop_but, FALSE); alignment2 = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_widget_show (alignment2); gtk_container_add (GTK_CONTAINER (stop_but), alignment2); hbox25 = gtk_hbox_new (FALSE, 2); gtk_widget_show (hbox25); gtk_container_add (GTK_CONTAINER (alignment2), hbox25); image21 = gtk_image_new_from_stock ("gtk-no", GTK_ICON_SIZE_BUTTON); gtk_widget_show (image21); gtk_box_pack_start (GTK_BOX (hbox25), image21, FALSE, FALSE, 0); label11 = gtk_label_new_with_mnemonic (_("St_op")); gtk_widget_show (label11); gtk_box_pack_start (GTK_BOX (hbox25), label11, FALSE, FALSE, 0); handlebox2 = gtk_handle_box_new (); gtk_widget_show (handlebox2); gtk_box_pack_start (GTK_BOX (vbox1), handlebox2, FALSE, FALSE, 0); toolbar2 = gtk_toolbar_new (); gtk_widget_show (toolbar2); gtk_container_add (GTK_CONTAINER (handlebox2), toolbar2); gtk_toolbar_set_style (GTK_TOOLBAR (toolbar2), GTK_TOOLBAR_ICONS); chansel_combo = gtk_combo_box_new_text(); gtk_widget_show(chansel_combo); gtk_toolbar_append_widget(GTK_TOOLBAR(toolbar2), chansel_combo, NULL, NULL); gtk_widget_set_sensitive(chansel_combo, FALSE); /* chansel_combo = gtk_combo_new (); g_object_set_data (G_OBJECT (GTK_COMBO (chansel_combo)->popwin), "GladeParentKey", chansel_combo); gtk_widget_show (chansel_combo); gtk_toolbar_append_widget (GTK_TOOLBAR (toolbar2), chansel_combo, NULL, NULL); gtk_widget_set_sensitive (chansel_combo, FALSE); combo_entry1 = GTK_COMBO (chansel_combo)->entry; gtk_widget_show (combo_entry1); */ label12 = gtk_label_new (_(" Mag in %: ")); gtk_widget_show (label12); gtk_toolbar_append_widget (GTK_TOOLBAR (toolbar2), label12, NULL, NULL); mag_spinbut_adj = gtk_adjustment_new (1, 0, 100, 1, 10, 10); mag_spinbut = gtk_spin_button_new (GTK_ADJUSTMENT (mag_spinbut_adj), 1, 0); gtk_widget_show (mag_spinbut); gtk_toolbar_append_widget (GTK_TOOLBAR (toolbar2), mag_spinbut, NULL, NULL); gtk_widget_set_sensitive (mag_spinbut, FALSE); label13 = gtk_label_new (_(" Notch: ")); gtk_widget_show (label13); gtk_toolbar_append_widget (GTK_TOOLBAR (toolbar2), label13, NULL, NULL); combo1 = gtk_combo_box_new_text(); gtk_widget_show(combo1); gtk_toolbar_append_widget(GTK_TOOLBAR(toolbar2), combo1, NULL, NULL); gtk_widget_set_sensitive(combo1, FALSE); /* combo1 = gtk_combo_new (); g_object_set_data (G_OBJECT (GTK_COMBO (combo1)->popwin), "GladeParentKey", combo1); gtk_widget_show (combo1); gtk_toolbar_append_widget (GTK_TOOLBAR (toolbar2), combo1, NULL, NULL); combo_entry2 = GTK_COMBO (combo1)->entry; gtk_widget_show (combo_entry2); */ apply_but = gtk_button_new_from_stock ("gtk-apply"); gtk_widget_show (apply_but); gtk_toolbar_append_widget (GTK_TOOLBAR (toolbar2), apply_but, _("Start Aquistion"), NULL); gtk_widget_set_sensitive (apply_but, FALSE); hbox18 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox18); gtk_box_pack_start (GTK_BOX (vbox1), hbox18, TRUE, TRUE, 0); drawingarea = gtk_drawing_area_new (); gtk_widget_show (drawingarea); gtk_box_pack_start (GTK_BOX (hbox18), drawingarea, TRUE, TRUE, 0); vscrollbar1 = gtk_vscrollbar_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 10, 1, 1, 1))); gtk_widget_show (vscrollbar1); gtk_box_pack_start (GTK_BOX (hbox18), vscrollbar1, FALSE, TRUE, 0); gtk_widget_set_sensitive (vscrollbar1, FALSE); statusbar = gtk_statusbar_new (); gtk_widget_show (statusbar); gtk_box_pack_start (GTK_BOX (vbox1), statusbar, FALSE, FALSE, 0); g_signal_connect ((gpointer) bsv_main_win, "delete-event", G_CALLBACK (main_quit), NULL); g_signal_connect ((gpointer) preferences_main, "activate", G_CALLBACK (run_viewer_preference_dlg), NULL); g_signal_connect ((gpointer) quit1, "activate", G_CALLBACK (gtk_main_quit), NULL); g_signal_connect ((gpointer) preferences_driver, "activate", G_CALLBACK (run_driver_perferences_dlg), NULL); g_signal_connect ((gpointer) information2, "activate", G_CALLBACK (run_driver_info_dlg), NULL); g_signal_connect ((gpointer) start_but, "clicked", G_CALLBACK (start_acquistion), NULL); g_signal_connect ((gpointer) stop_but, "clicked", G_CALLBACK (stop_acquistion), NULL); g_signal_connect ((gpointer) apply_but, "clicked", G_CALLBACK (apply_but_clicked), NULL); g_signal_connect ((gpointer) drawingarea, "expose_event", G_CALLBACK (resize_area), NULL); g_signal_connect ((gpointer) vscrollbar1, "value_changed", G_CALLBACK (vsbar_value_changed), NULL); g_signal_connect ((gpointer) chansel_combo, "changed", G_CALLBACK (chansel_combo_changed), NULL); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (bsv_main_win, bsv_main_win, "bsv_main_win"); GLADE_HOOKUP_OBJECT (bsv_main_win, vbox1, "vbox1"); GLADE_HOOKUP_OBJECT (bsv_main_win, menubar1, "menubar1"); GLADE_HOOKUP_OBJECT (bsv_main_win, menuitem4, "menuitem4"); GLADE_HOOKUP_OBJECT (bsv_main_win, menuitem4_menu, "menuitem4_menu"); GLADE_HOOKUP_OBJECT (bsv_main_win, preferences_main, "preferences_main"); GLADE_HOOKUP_OBJECT (bsv_main_win, image18, "image18"); GLADE_HOOKUP_OBJECT (bsv_main_win, separatormenuitem1, "separatormenuitem1"); GLADE_HOOKUP_OBJECT (bsv_main_win, quit1, "quit1"); GLADE_HOOKUP_OBJECT (bsv_main_win, menuitem5, "menuitem5"); GLADE_HOOKUP_OBJECT (bsv_main_win, menuitem5_menu, "menuitem5_menu"); GLADE_HOOKUP_OBJECT (bsv_main_win, preferences_driver, "preferences_driver"); GLADE_HOOKUP_OBJECT (bsv_main_win, image19, "image19"); GLADE_HOOKUP_OBJECT (bsv_main_win, information2, "information2"); GLADE_HOOKUP_OBJECT (bsv_main_win, handlebox1, "handlebox1"); GLADE_HOOKUP_OBJECT (bsv_main_win, toolbar1, "toolbar1"); GLADE_HOOKUP_OBJECT (bsv_main_win, start_but, "start_but"); GLADE_HOOKUP_OBJECT (bsv_main_win, alignment1, "alignment1"); GLADE_HOOKUP_OBJECT (bsv_main_win, hbox24, "hbox24"); GLADE_HOOKUP_OBJECT (bsv_main_win, image20, "image20"); GLADE_HOOKUP_OBJECT (bsv_main_win, label10, "label10"); GLADE_HOOKUP_OBJECT (bsv_main_win, stop_but, "stop_but"); GLADE_HOOKUP_OBJECT (bsv_main_win, alignment2, "alignment2"); GLADE_HOOKUP_OBJECT (bsv_main_win, hbox25, "hbox25"); GLADE_HOOKUP_OBJECT (bsv_main_win, image21, "image21"); GLADE_HOOKUP_OBJECT (bsv_main_win, label11, "label11"); GLADE_HOOKUP_OBJECT (bsv_main_win, handlebox2, "handlebox2"); GLADE_HOOKUP_OBJECT (bsv_main_win, toolbar2, "toolbar2"); GLADE_HOOKUP_OBJECT (bsv_main_win, chansel_combo, "chansel_combo"); // GLADE_HOOKUP_OBJECT (bsv_main_win, combo_entry1, "combo_entry1"); GLADE_HOOKUP_OBJECT (bsv_main_win, label12, "label12"); GLADE_HOOKUP_OBJECT (bsv_main_win, mag_spinbut, "mag_spinbut"); GLADE_HOOKUP_OBJECT (bsv_main_win, label13, "label13"); GLADE_HOOKUP_OBJECT (bsv_main_win, combo1, "combo1"); // GLADE_HOOKUP_OBJECT (bsv_main_win, combo_entry2, "combo_entry2"); GLADE_HOOKUP_OBJECT (bsv_main_win, apply_but, "apply_but"); GLADE_HOOKUP_OBJECT (bsv_main_win, hbox18, "hbox18"); GLADE_HOOKUP_OBJECT (bsv_main_win, drawingarea, "drawingarea"); GLADE_HOOKUP_OBJECT (bsv_main_win, vscrollbar1, "vscrollbar1"); GLADE_HOOKUP_OBJECT (bsv_main_win, statusbar, "statusbar"); gtk_window_add_accel_group (GTK_WINDOW (bsv_main_win), accel_group); return bsv_main_win; }
void Launch_Gtk_Process(int pipe_number) { int argc = 0; gchar **argv = NULL; GtkWidget *button, *mbar, *swin; GtkWidget *table, *align, *handlebox; GtkWidget *vbox, *hbox, *vbox2, *scrolled_win; GtkObject *adj; /* enable locale */ gtk_set_locale (); gtk_init (&argc, &argv); ttip = create_yellow_tooltips(); window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_widget_set_name(window, "TiMidity"); gtk_window_set_title(GTK_WINDOW(window), "TiMidity - MIDI Player"); gtk_window_set_wmclass(GTK_WINDOW(window), "timidity", "TiMidity"); gtk_signal_connect(GTK_OBJECT(window), "delete_event", GTK_SIGNAL_FUNC (delete_event), NULL); gtk_signal_connect(GTK_OBJECT(window), "destroy", GTK_SIGNAL_FUNC (destroy), NULL); vbox = gtk_vbox_new(FALSE, 0); gtk_container_add(GTK_CONTAINER(window), vbox); mbar = create_menubar(); gtk_box_pack_start(GTK_BOX(vbox), mbar, FALSE, FALSE, 0); scrolled_win = gtk_scrolled_window_new(NULL, NULL); gtk_box_pack_start(GTK_BOX(vbox), scrolled_win, TRUE, TRUE ,0); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_win),GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_widget_show(scrolled_win); #ifdef HAVE_GTK_2 text = gtk_text_view_new(); gtk_text_view_set_editable(GTK_TEXT_VIEW(text), FALSE); gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(text), GTK_WRAP_WORD); #else text = gtk_text_new(NULL, NULL); #endif gtk_widget_show(text); gtk_container_add(GTK_CONTAINER(scrolled_win), text); hbox = gtk_hbox_new(FALSE, 4); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 4); gtk_widget_show(hbox); adj = gtk_adjustment_new(0., 0., 100., 1., 20., 0.); locator = gtk_hscale_new(GTK_ADJUSTMENT(adj)); gtk_scale_set_draw_value(GTK_SCALE(locator), TRUE); gtk_signal_connect(GTK_OBJECT(adj), "value_changed", GTK_SIGNAL_FUNC(generic_scale_cb), (gpointer)GTK_CHANGE_LOCATOR); gtk_signal_connect(GTK_OBJECT(locator), "button_press_event", GTK_SIGNAL_FUNC(locate_update_cb), NULL); gtk_signal_connect(GTK_OBJECT(locator), "button_release_event", GTK_SIGNAL_FUNC(locate_update_cb), NULL); gtk_range_set_update_policy(GTK_RANGE(locator), GTK_UPDATE_DISCONTINUOUS); gtk_scale_set_digits(GTK_SCALE(locator), 0); gtk_widget_show(locator); gtk_box_pack_start(GTK_BOX(hbox), locator, TRUE, TRUE, 4); align = gtk_alignment_new(0., 1., 1., 0.); gtk_widget_show(align); cnt_lbl = gtk_label_new("00:00"); gtk_widget_show(cnt_lbl); gtk_container_add(GTK_CONTAINER(align), cnt_lbl); gtk_box_pack_start(GTK_BOX(hbox), align, FALSE, TRUE, 0); align = gtk_alignment_new(0., 1., 1., 0.); gtk_widget_show(align); tot_lbl = gtk_label_new("/00:00"); gtk_widget_show(tot_lbl); gtk_container_add(GTK_CONTAINER(align), tot_lbl); gtk_box_pack_start(GTK_BOX(hbox), align, FALSE, TRUE, 0); hbox = gtk_hbox_new(FALSE, 4); gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 4); swin = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); clist = gtk_clist_new(1); gtk_container_add(GTK_CONTAINER(swin), clist); gtk_widget_show(swin); gtk_widget_show(clist); gtk_widget_set_usize(clist, 200, 10); gtk_clist_set_reorderable(GTK_CLIST(clist), TRUE); gtk_clist_set_button_actions(GTK_CLIST(clist), 0, GTK_BUTTON_SELECTS); gtk_clist_set_button_actions(GTK_CLIST(clist), 1, GTK_BUTTON_DRAGS); gtk_clist_set_button_actions(GTK_CLIST(clist), 2, GTK_BUTTON_SELECTS); gtk_clist_set_selection_mode(GTK_CLIST(clist), GTK_SELECTION_SINGLE); gtk_clist_set_column_auto_resize(GTK_CLIST(clist), 1, TRUE); gtk_signal_connect(GTK_OBJECT(clist), "select_row", GTK_SIGNAL_FUNC(file_list_cb), NULL); gtk_box_pack_start(GTK_BOX(hbox), swin, TRUE, TRUE, 0); vbox2 = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(hbox), vbox2, FALSE, FALSE, 0); gtk_widget_show(vbox2); /* This is so the pixmap creation works properly. */ gtk_widget_realize(window); set_icon_pixmap(window, timidity_xpm); gtk_box_pack_start(GTK_BOX(vbox2), create_pixmap_label(window, loud_xpm), FALSE, FALSE, 0); adj = gtk_adjustment_new(30., 0., (gfloat)MAX_AMPLIFICATION, 1., 20., 0.); vol_scale = gtk_vscale_new(GTK_ADJUSTMENT(adj)); gtk_scale_set_draw_value(GTK_SCALE(vol_scale), FALSE); gtk_signal_connect (GTK_OBJECT(adj), "value_changed", GTK_SIGNAL_FUNC(generic_scale_cb), (gpointer)GTK_CHANGE_VOLUME); gtk_range_set_update_policy(GTK_RANGE(vol_scale), GTK_UPDATE_DELAYED); gtk_widget_show(vol_scale); gtk_tooltips_set_tip(ttip, vol_scale, "Volume control", NULL); gtk_box_pack_start(GTK_BOX(vbox2), vol_scale, TRUE, TRUE, 0); gtk_box_pack_start(GTK_BOX(vbox2), create_pixmap_label(window, quiet_xpm), FALSE, FALSE, 0); handlebox = gtk_handle_box_new(); gtk_box_pack_start(GTK_BOX(hbox), handlebox, FALSE, FALSE, 0); table = gtk_table_new(7, 2, TRUE); gtk_container_add(GTK_CONTAINER(handlebox), table); button = create_button_with_pixmap(window, playpaus_xpm, GTK_PAUSE, "Play/Pause"); gtk_table_attach_defaults(GTK_TABLE(table), button, 0, 2, 0, 1); button = create_button_with_pixmap(window, prevtrk_xpm, GTK_PREV, "Previous file"); gtk_table_attach_defaults(GTK_TABLE(table), button, 0, 1, 1, 2); button = create_button_with_pixmap(window, nexttrk_xpm, GTK_NEXT, "Next file"); gtk_table_attach_defaults(GTK_TABLE(table), button, 1, 2, 1, 2); button = create_button_with_pixmap(window, rew_xpm, GTK_RWD, "Rewind"); gtk_table_attach_defaults(GTK_TABLE(table), button, 0, 1, 2, 3); button = create_button_with_pixmap(window, ff_xpm, GTK_FWD, "Fast forward"); gtk_table_attach_defaults(GTK_TABLE(table), button, 1, 2, 2, 3); button = create_button_with_pixmap(window, keydown_xpm, GTK_KEYDOWN, "Lower pitch"); gtk_table_attach_defaults(GTK_TABLE(table), button, 0, 1, 3, 4); button = create_button_with_pixmap(window, keyup_xpm, GTK_KEYUP, "Raise pitch"); gtk_table_attach_defaults(GTK_TABLE(table), button, 1, 2, 3, 4); button = create_button_with_pixmap(window, slow_xpm, GTK_SLOWER, "Decrease tempo"); gtk_table_attach_defaults(GTK_TABLE(table), button, 0, 1, 4, 5); button = create_button_with_pixmap(window, fast_xpm, GTK_FASTER, "Increase tempo"); gtk_table_attach_defaults(GTK_TABLE(table), button, 1, 2, 4, 5); button = create_button_with_pixmap(window, restart_xpm, GTK_RESTART, "Restart"); gtk_table_attach_defaults(GTK_TABLE(table), button, 0, 1, 5, 6); button = create_button_with_pixmap(window, open_xpm, 0, "Open"); #ifdef HAVE_GTK_2 gtk_signal_disconnect_by_func(GTK_OBJECT(button), G_CALLBACK(generic_cb), 0); #else gtk_signal_disconnect_by_func(GTK_OBJECT(button), generic_cb, 0); #endif gtk_signal_connect(GTK_OBJECT(button), "clicked", GTK_SIGNAL_FUNC(open_file_cb), 0); gtk_table_attach_defaults(GTK_TABLE(table), button, 1, 2, 5, 6); button = create_button_with_pixmap(window, quit_xpm, GTK_QUIT, "Quit"); gtk_table_attach_defaults(GTK_TABLE(table), button, 0, 2, 6, 7); gtk_widget_show(hbox); gtk_widget_show(vbox); gtk_widget_show(table); gtk_widget_show(handlebox); gtk_widget_show(window); gdk_input_add(pipe_number, GDK_INPUT_READ, handle_input, NULL); gtk_main(); }
/*! \todo Finish function documentation!!! * \brief * \par Function Description * */ void x_window_create_main(GSCHEM_TOPLEVEL *w_current) { TOPLEVEL *toplevel = w_current->toplevel; GtkWidget *label=NULL; GtkWidget *main_box=NULL; GtkWidget *menubar=NULL; GtkWidget *drawbox=NULL; GtkWidget *bottom_box=NULL; GtkWidget *toolbar=NULL; GtkWidget *handlebox=NULL; /* used to signify that the window isn't mapped yet */ w_current->window = NULL; w_current->main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_widget_set_name (w_current->main_window, "gschem"); gtk_window_set_policy (GTK_WINDOW (w_current->main_window), TRUE, TRUE, TRUE); /* We want the widgets to flow around the drawing area, so we don't * set a size of the main window. The drawing area's size is fixed, * see below */ /* * normally we let the window manager handle locating and sizing * the window. However, for some batch processing of schematics * (generating a pdf of all schematics for example) we want to * override this. Hence "auto_place_mode". */ if( auto_place_mode ) gtk_widget_set_uposition (w_current->main_window, 10, 10); /* this should work fine */ g_signal_connect (G_OBJECT (w_current->main_window), "delete_event", G_CALLBACK (i_callback_close_wm), w_current); /* Containers first */ main_box = gtk_vbox_new(FALSE, 1); gtk_container_border_width(GTK_CONTAINER(main_box), 0); gtk_container_add(GTK_CONTAINER(w_current->main_window), main_box); menubar = get_main_menu (w_current); if (w_current->handleboxes) { handlebox = gtk_handle_box_new (); gtk_box_pack_start(GTK_BOX(main_box), handlebox, FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER (handlebox), menubar); } else { gtk_box_pack_start(GTK_BOX(main_box), menubar, FALSE, FALSE, 0); } w_current->menubar = menubar; gtk_widget_realize (w_current->main_window); if (w_current->handleboxes && w_current->toolbars) { handlebox = gtk_handle_box_new (); gtk_box_pack_start (GTK_BOX (main_box), handlebox, FALSE, FALSE, 0); } if (w_current->toolbars) { toolbar = gtk_toolbar_new(); gtk_toolbar_set_orientation (GTK_TOOLBAR(toolbar), GTK_ORIENTATION_HORIZONTAL); gtk_toolbar_set_style (GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS); if (w_current->handleboxes) { gtk_container_add (GTK_CONTAINER (handlebox), toolbar); } else { gtk_box_pack_start(GTK_BOX(main_box), toolbar, FALSE, FALSE, 0); } gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("New"), _("New file"), "toolbar/new", x_window_stock_pixmap("new", w_current), (GtkSignalFunc) i_callback_toolbar_file_new, w_current); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Open"), _("Open file..."), "toolbar/open", x_window_stock_pixmap("open", w_current), (GtkSignalFunc) i_callback_toolbar_file_open, w_current); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Save"), _("Save file"), "toolbar/save", x_window_stock_pixmap("save", w_current), (GtkSignalFunc) i_callback_toolbar_file_save, w_current); gtk_toolbar_append_space (GTK_TOOLBAR(toolbar)); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Undo"), _("Undo last operation"), "toolbar/undo", x_window_stock_pixmap("undo", w_current), (GtkSignalFunc) i_callback_toolbar_edit_undo, w_current); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Redo"), _("Redo last undo"), "toolbar/redo", x_window_stock_pixmap("redo", w_current), (GtkSignalFunc) i_callback_toolbar_edit_redo, w_current); gtk_toolbar_append_space (GTK_TOOLBAR(toolbar)); /* not part of any radio button group */ gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Component"), _("Add component...\nSelect library and component from list, move the mouse into main window, click to place\nRight mouse button to cancel"), "toolbar/component", x_window_stock_pixmap("comp", w_current), (GtkSignalFunc) i_callback_toolbar_add_component, w_current); w_current->toolbar_net = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_CHILD_RADIOBUTTON, NULL, _("Nets"), _("Add nets mode\nRight mouse button to cancel"), "toolbar/nets", x_window_stock_pixmap("net", w_current), (GtkSignalFunc) i_callback_toolbar_add_net, w_current); w_current->toolbar_bus = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_CHILD_RADIOBUTTON, w_current->toolbar_net, _("Bus"), _("Add buses mode\nRight mouse button to cancel"), "toolbar/bus", x_window_stock_pixmap("bus", w_current), (GtkSignalFunc) i_callback_toolbar_add_bus, w_current); /* not part of any radio button group */ gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Text"), _("Add Text..."), "toolbar/text", x_window_stock_pixmap("text", w_current), (GtkSignalFunc) i_callback_toolbar_add_text, w_current); gtk_toolbar_append_space (GTK_TOOLBAR(toolbar)); w_current->toolbar_select = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_CHILD_RADIOBUTTON, w_current->toolbar_bus, _("Select"), _("Select mode"), "toolbar/select", x_window_stock_pixmap("select", w_current), (GtkSignalFunc) i_callback_toolbar_edit_select, w_current); gtk_toolbar_append_space (GTK_TOOLBAR(toolbar)); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w_current->toolbar_select), TRUE); } /* Try to create popup menu (appears in right mouse button */ w_current->popup_menu = (GtkWidget *) get_main_popup(w_current); drawbox = gtk_hbox_new(FALSE, 0); gtk_container_border_width(GTK_CONTAINER(drawbox), 0); gtk_container_add(GTK_CONTAINER(main_box), drawbox); x_window_create_drawing(drawbox, w_current); x_window_setup_draw_events(w_current); if (w_current->scrollbars_flag == TRUE) { /* setup scroll bars */ w_current->v_adjustment = GTK_ADJUSTMENT ( gtk_adjustment_new (toplevel->init_bottom, 0.0, toplevel->init_bottom, 100.0, 100.0, 10.0)); w_current->v_scrollbar = gtk_vscrollbar_new (w_current->v_adjustment); gtk_range_set_update_policy (GTK_RANGE (w_current->v_scrollbar), GTK_UPDATE_CONTINUOUS); gtk_box_pack_start (GTK_BOX (drawbox), w_current->v_scrollbar, FALSE, FALSE, 0); g_signal_connect (w_current->v_adjustment, "value_changed", G_CALLBACK (x_event_vschanged), w_current); w_current->h_adjustment = GTK_ADJUSTMENT ( gtk_adjustment_new (0.0, 0.0, toplevel->init_right, 100.0, 100.0, 10.0)); w_current->h_scrollbar = gtk_hscrollbar_new (w_current->h_adjustment); gtk_range_set_update_policy (GTK_RANGE (w_current->h_scrollbar), GTK_UPDATE_CONTINUOUS); gtk_box_pack_start (GTK_BOX (main_box), w_current->h_scrollbar, FALSE, FALSE, 0); g_signal_connect (w_current->h_adjustment, "value_changed", G_CALLBACK (x_event_hschanged), w_current); } /* macro box */ w_current->macro_entry = gtk_entry_new(); g_signal_connect(w_current->macro_entry, "activate", G_CALLBACK(&x_window_invoke_macro), w_current); w_current->macro_box = gtk_hbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(w_current->macro_box), w_current->macro_entry, TRUE, TRUE, 2); gtk_container_border_width(GTK_CONTAINER(w_current->macro_box), 1); gtk_box_pack_start (GTK_BOX (main_box), w_current->macro_box, FALSE, FALSE, 0); /* bottom box */ bottom_box = gtk_hbox_new(FALSE, 0); gtk_container_border_width(GTK_CONTAINER(bottom_box), 1); gtk_box_pack_start (GTK_BOX (main_box), bottom_box, FALSE, FALSE, 0); /* label = gtk_label_new ("Mouse buttons:"); gtk_box_pack_start (GTK_BOX (bottom_box), label, FALSE, FALSE, 10); */ label = gtk_label_new (" "); gtk_box_pack_start (GTK_BOX (bottom_box), label, FALSE, FALSE, 2); w_current->left_label = gtk_label_new (_("Pick")); gtk_box_pack_start (GTK_BOX (bottom_box), w_current->left_label, FALSE, FALSE, 0); label = gtk_label_new ("|"); gtk_box_pack_start (GTK_BOX (bottom_box), label, FALSE, FALSE, 5); if (w_current->middle_button == STROKE) { #ifdef HAVE_LIBSTROKE w_current->middle_label = gtk_label_new (_("Stroke")); #else w_current->middle_label = gtk_label_new (_("none")); #endif } else if (w_current->middle_button == ACTION) { w_current->middle_label = gtk_label_new (_("Action")); } else { w_current->middle_label = gtk_label_new (_("Repeat/none")); } gtk_box_pack_start (GTK_BOX (bottom_box), w_current->middle_label, FALSE, FALSE, 0); label = gtk_label_new ("|"); gtk_box_pack_start (GTK_BOX (bottom_box), label, FALSE, FALSE, 5); if (default_third_button == POPUP_ENABLED) { w_current->right_label = gtk_label_new (_("Menu/Cancel")); } else { w_current->right_label = gtk_label_new (_("Pan/Cancel")); } gtk_box_pack_start (GTK_BOX (bottom_box), w_current->right_label, FALSE, FALSE, 0); label = gtk_label_new (" "); gtk_box_pack_start (GTK_BOX (bottom_box), label, FALSE, FALSE, 5); w_current->grid_label = gtk_label_new (" "); gtk_box_pack_start (GTK_BOX (bottom_box), w_current->grid_label, FALSE, FALSE, 10); w_current->status_label = gtk_label_new (_("Select Mode")); gtk_box_pack_end (GTK_BOX (bottom_box), w_current->status_label, FALSE, FALSE, 10); gtk_widget_show_all (w_current->main_window); gtk_widget_hide(w_current->macro_box); w_current->window = w_current->drawing_area->window; w_current->drawable = w_current->window; x_window_setup_gc(w_current); }
void do_menu (GtkWidget * vbox) { GtkWidget *menu_bar, *menu, *smenu; GtkWidget *mi; GtkWidget *handlebox; menu_bar = gtk_menu_bar_new (); menu = gtk_menu_item_new_with_label (_("File")); gtk_widget_show (menu); smenu = gtk_menu_new (); gtk_widget_show (smenu); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu), smenu); mi = gtk_menu_item_new_with_label (_("C-Wizard")); gtk_signal_connect (GTK_OBJECT (mi), "activate", GTK_SIGNAL_FUNC (clist), NULL); gtk_widget_show (mi); gtk_menu_append (GTK_MENU (smenu), mi); mi = gtk_menu_item_new_with_label (_("Connect")); gtk_signal_connect (GTK_OBJECT (mi), "activate", GTK_SIGNAL_FUNC (cbox), NULL); gtk_widget_show (mi); gtk_menu_append (GTK_MENU (smenu), mi); mi = gtk_menu_item_new_with_label (_("Disconnect")); gtk_signal_connect (GTK_OBJECT (mi), "activate", GTK_SIGNAL_FUNC (disconnect), NULL); gtk_widget_show (mi); gtk_menu_append (GTK_MENU (smenu), mi); mi = gtk_menu_item_new (); gtk_widget_show (mi); gtk_menu_append (GTK_MENU (smenu), mi); /* mi = gtk_menu_item_new_with_label (_("Preferences...")); gtk_signal_connect (GTK_OBJECT (mi), "activate", GTK_SIGNAL_FUNC (show_config), NULL); gtk_widget_show (mi); gtk_menu_append (GTK_MENU (smenu), mi); */ mi = gtk_menu_item_new (); gtk_widget_show (mi); gtk_menu_append (GTK_MENU (smenu), mi); mi = gtk_menu_item_new_with_label (_("Exit")); gtk_signal_connect (GTK_OBJECT (mi), "activate", GTK_SIGNAL_FUNC (bmud_exit), NULL); gtk_widget_show (mi); gtk_menu_append (GTK_MENU (smenu), mi); gtk_menu_bar_append (GTK_MENU_BAR (menu_bar), menu); menu = gtk_menu_item_new_with_label (_("Tools")); gtk_widget_show (menu); smenu = gtk_menu_new (); gtk_widget_show (smenu); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu), smenu); mi = gtk_menu_item_new_with_label (_("Equip")); gtk_signal_connect (GTK_OBJECT (mi), "activate", GTK_SIGNAL_FUNC (NULL), NULL); gtk_widget_set_sensitive (GTK_WIDGET (mi), FALSE); gtk_widget_show (mi); gtk_menu_append (GTK_MENU (smenu), mi); mi = gtk_menu_item_new_with_label (_("Map")); gtk_signal_connect (GTK_OBJECT (mi), "activate", GTK_SIGNAL_FUNC (NULL), NULL); gtk_widget_set_sensitive (GTK_WIDGET (mi), FALSE); gtk_widget_show (mi); gtk_menu_append (GTK_MENU (smenu), mi); gtk_menu_bar_append (GTK_MENU_BAR (menu_bar), menu); menu = gtk_menu_item_new_with_label (_("Help")); gtk_widget_show (menu); gtk_menu_item_right_justify (GTK_MENU_ITEM (menu)); smenu = gtk_menu_new (); gtk_widget_show (smenu); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu), smenu); mi = gtk_menu_item_new_with_label (_("About")); gtk_signal_connect (GTK_OBJECT (mi), "activate", GTK_SIGNAL_FUNC (do_about), NULL); gtk_widget_show (mi); gtk_menu_append (GTK_MENU (smenu), mi); mi = gtk_menu_item_new_with_label (_("Manual")); /* I d'no about this one */ /* gtk_signal_connect(GTK_OBJECT(mi),"activate",GTK_SIGNAL_FUNC(gtk_main_quit),NULL); */ gtk_widget_show (mi); gtk_menu_append (GTK_MENU (smenu), mi); gtk_menu_bar_append (GTK_MENU_BAR (menu_bar), menu); gtk_widget_show (menu_bar); handlebox = gtk_handle_box_new (); gtk_widget_show (handlebox); gtk_container_add (GTK_CONTAINER (handlebox), menu_bar); gtk_box_pack_start (GTK_BOX (vbox), handlebox, FALSE, FALSE, 0); return; }
static GtkWidget * do_appwindow (void) { GtkWidget *window; GtkWidget *table; GtkWidget *toolbar; GtkWidget *handlebox; GtkWidget *statusbar; GtkWidget *contents; GtkWidget *sw; GtkTextBuffer *buffer; #if GTK_CHECK_VERSION(3, 0, 0) GtkActionGroup *action_group; GtkUIManager *ui_manager; #else GtkAccelGroup *accel_group; GtkItemFactory *item_factory; #endif /* Create the toplevel window */ ++window_count; aspect_on = FALSE; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), "Application Window"); g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (destroy_cb), NULL); table = gtk_table_new (1, 4, FALSE); gtk_container_add (GTK_CONTAINER (window), table); #if GTK_CHECK_VERSION(3, 0, 0) action_group = gtk_action_group_new("ActionGroups"); gtk_action_group_add_actions(action_group, entries, G_N_ELEMENTS(entries), NULL); ui_manager = gtk_ui_manager_new(); gtk_ui_manager_insert_action_group(ui_manager, action_group, 0); gtk_ui_manager_add_ui_from_string(ui_manager, ui_definition, -1, NULL); gtk_table_attach (GTK_TABLE (table), gtk_ui_manager_get_widget (ui_manager, "/MainMenuBar"), /* X direction */ /* Y direction */ 0, 1, 0, 1, GTK_EXPAND | GTK_FILL, 0, 0, 0); gtk_window_add_accel_group (GTK_WINDOW (window), gtk_ui_manager_get_accel_group (ui_manager)); #else /* Create the menubar */ accel_group = gtk_accel_group_new (); gtk_window_add_accel_group (GTK_WINDOW (window), accel_group); g_object_unref (accel_group); item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", accel_group); /* Set up item factory to go away with the window */ g_object_ref (item_factory); g_object_ref_sink (item_factory); g_object_unref (item_factory); g_object_set_data_full (G_OBJECT (window), "<main>", item_factory, (GDestroyNotify) g_object_unref); /* create menu items */ gtk_item_factory_create_items (item_factory, G_N_ELEMENTS (menu_items), menu_items, window); gtk_table_attach (GTK_TABLE (table), gtk_item_factory_get_widget (item_factory, "<main>"), /* X direction */ /* Y direction */ 0, 1, 0, 1, GTK_EXPAND | GTK_FILL, 0, 0, 0); #endif /* Create document */ sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN); gtk_table_attach (GTK_TABLE (table), sw, /* X direction */ /* Y direction */ 0, 1, 2, 3, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); gtk_window_set_default_size (GTK_WINDOW (window), 200, 200); contents = gtk_text_view_new (); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (contents), PANGO_WRAP_WORD); gtk_container_add (GTK_CONTAINER (sw), contents); /* Create the toolbar */ toolbar = gtk_toolbar_new (); GtkToolItem *newButton = gtk_tool_button_new_from_stock(GTK_STOCK_NEW); gtk_tool_item_set_tooltip_text(newButton, "Open another one of these windows"); g_signal_connect(G_OBJECT(newButton), "clicked", G_CALLBACK(do_appwindow), window); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), newButton, -1); /*-1 means append to end of toolbar*/ GtkToolItem *lockButton = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN); gtk_tool_item_set_tooltip_text(lockButton, "This is a demo button that locks up the demo"); g_signal_connect(G_OBJECT(lockButton), "clicked", G_CALLBACK(sleep_cb), window); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), lockButton, -1); /*-1 means append to end of toolbar*/ GtkToolItem *decoButton = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN); gtk_tool_item_set_tooltip_text(decoButton, "This is a demo button that toggles window decorations"); g_signal_connect(G_OBJECT(decoButton), "clicked", G_CALLBACK(toggle_decorated_cb), window); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), decoButton, -1); /*-1 means append to end of toolbar*/ GtkToolItem *lockRatioButton = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN); gtk_tool_item_set_tooltip_text(lockRatioButton, "This is a demo button that locks the aspect ratio using a hint"); g_signal_connect(G_OBJECT(lockRatioButton), "clicked", G_CALLBACK(toggle_aspect_ratio), window); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), lockRatioButton, -1); /*-1 means append to end of toolbar*/ GtkToolItem *quitButton = gtk_tool_button_new_from_stock(GTK_STOCK_QUIT); gtk_tool_item_set_tooltip_text(quitButton, "This is a demo button with a 'quit' icon"); g_signal_connect(G_OBJECT(quitButton), "clicked", G_CALLBACK(clicked_toolbar_cb), window); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), quitButton, -1); /*-1 means append to end of toolbar*/ handlebox = gtk_handle_box_new (); gtk_container_add (GTK_CONTAINER (handlebox), toolbar); gtk_table_attach (GTK_TABLE (table), handlebox, /* X direction */ /* Y direction */ 0, 1, 1, 2, GTK_EXPAND | GTK_FILL, 0, 0, 0); /* Create statusbar */ statusbar = gtk_statusbar_new (); gtk_table_attach (GTK_TABLE (table), statusbar, /* X direction */ /* Y direction */ 0, 1, 3, 4, GTK_EXPAND | GTK_FILL, 0, 0, 0); /* Show text widget info in the statusbar */ buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (contents)); gtk_text_buffer_set_text (buffer, "This demo demonstrates various kinds of windows that " "window managers and window manager themes should handle. " "Be sure to tear off the menu and toolbar, those are also " "a special kind of window.", -1); g_signal_connect_object (buffer, "changed", G_CALLBACK (update_statusbar), statusbar, 0); g_signal_connect_object (buffer, "mark_set", /* cursor moved */ G_CALLBACK (mark_set_callback), statusbar, 0); update_statusbar (buffer, GTK_STATUSBAR (statusbar)); gtk_widget_show_all (window); return window; }
static VALUE rg_initialize(VALUE self) { RBGTK_INITIALIZE(self, gtk_handle_box_new()); return Qnil; }
int main( int argc,char *argv[] ) { GtkWidget *vbox; GtkWidget *hbox; GtkWidget* menubar; GtkWidget* main_toolbar; GtkWidget* tools_toolbar; GtkWidget* colortable; GtkWidget* frame; gtk_init (&argc, &argv); modified=0; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW(window), "Illuminati"); g_signal_connect (G_OBJECT (window), "delete-event", G_CALLBACK (delete_event), NULL); g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (delete_event), NULL); vbox = gtk_vbox_new (FALSE, 0); gtk_container_add(GTK_CONTAINER(window), vbox); /*To create the menu bar*/ menubar = get_menubar_menu (window); gtk_box_pack_start (GTK_BOX(vbox),menubar, FALSE, FALSE, 0); gtk_widget_show (menubar); main_toolbar=get_main_toolbar(); /* to make it nice we'll put the toolbar into the handle box, * so that it can be detached from the main window */ mainhandlebox = gtk_handle_box_new (); gtk_box_pack_start (GTK_BOX (vbox),mainhandlebox, FALSE, FALSE, 5); gtk_container_add (GTK_CONTAINER (mainhandlebox), main_toolbar); gtk_widget_show (main_toolbar); gtk_widget_show (mainhandlebox); /*hbox for tools_toolbar and drawing area*/ hbox = gtk_hbox_new (FALSE, 2); gtk_box_pack_start (GTK_BOX (vbox),hbox, FALSE, FALSE, 0); tools_toolbar=get_tools_toolbar(); toolhandlebox = gtk_handle_box_new (); gtk_box_pack_start (GTK_BOX(hbox),toolhandlebox, FALSE, FALSE, 5); gtk_container_add (GTK_CONTAINER (toolhandlebox), tools_toolbar); gtk_widget_show (tools_toolbar); gtk_widget_show (toolhandlebox); scrolled_win = gtk_scrolled_window_new (NULL, NULL); gtk_widget_set_size_request (GTK_WIDGET (scrolled_win),400,400); gtk_container_set_border_width (GTK_CONTAINER (scrolled_win), 1); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start (GTK_BOX (hbox), scrolled_win, TRUE, TRUE, 0); drawing_area = gtk_drawing_area_new (); gtk_widget_set_size_request (GTK_WIDGET (drawing_area),800,600); gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_win),drawing_area); gtk_widget_show (drawing_area); gtk_widget_show (scrolled_win); gtk_widget_show (hbox); /* Signals used to handle backing pixmap */ g_signal_connect (G_OBJECT (drawing_area), "expose_event", G_CALLBACK (expose_event), NULL); g_signal_connect (G_OBJECT (drawing_area),"configure_event", G_CALLBACK (configure_event), NULL); /* Event signals */ g_signal_connect (G_OBJECT (drawing_area), "motion_notify_event", G_CALLBACK (motion_notify_event), NULL); g_signal_connect (G_OBJECT (drawing_area), "button_press_event", G_CALLBACK (button_press_event), NULL); g_signal_connect (G_OBJECT (drawing_area), "button_release_event", G_CALLBACK(button_release_event),NULL); gtk_widget_set_events (drawing_area,GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK | GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_BUTTON_RELEASE_MASK); hbox = gtk_hbox_new (FALSE,0); gtk_box_pack_start(GTK_BOX (vbox),hbox, FALSE, FALSE, 2); frame=get_fgbgframe(); gtk_box_pack_start(GTK_BOX (hbox),frame, FALSE, FALSE, 2); gtk_widget_show(frame); colortable=get_system_color_table(); frame=gtk_frame_new("select color"); gtk_widget_set_size_request (GTK_WIDGET (frame),400,75); gtk_box_pack_start(GTK_BOX (hbox),frame, TRUE, TRUE, 2); gtk_container_add(GTK_CONTAINER(frame),colortable); gtk_widget_show (colortable); gtk_widget_show(frame); gtk_widget_show (hbox); gtk_widget_show(vbox); gtk_widget_show(window); /*Initial tool set to PENCIL */ display=gdk_display_get_default(); cursor=gdk_cursor_new(GDK_PENCIL); gdk_window_set_cursor(drawing_area->window,cursor); tool=PENCIL; gtk_button_set_relief(GTK_BUTTON(pencil_button),GTK_RELIEF_NORMAL); filename=g_strdup("Untitled.jpeg"); pixmap = gdk_pixmap_new (drawing_area->window, drawing_area->allocation.width, drawing_area->allocation.height, -1); gdk_draw_rectangle (pixmap, drawing_area->style->white_gc, TRUE, 0, 0, drawing_area->allocation.width, drawing_area->allocation.height); gtk_main (); return 0; }
static void populate_window(ChmSee *self) { GtkWidget* vbox = gtk_vbox_new(FALSE, 0); GladeXML *glade; glade = glade_xml_new(get_resource_path(GLADE_FILE), "main_vbox", NULL); if (glade == NULL) { g_error("Cannot find glade file!"); exit(1); } g_object_set_data(G_OBJECT (self), "glade", glade); GtkWidget *main_vbox; main_vbox = get_widget(self, "main_vbox"); gtk_container_add(GTK_CONTAINER (self), vbox); GtkActionGroup* action_group = gtk_action_group_new ("MenuActions"); selfp->action_group = action_group; gtk_action_group_add_actions (action_group, entries, G_N_ELEMENTS (entries), self); gtk_action_group_add_toggle_actions (action_group, toggle_entries, G_N_ELEMENTS (toggle_entries), self); gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "NewTab"), FALSE); gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "CloseTab"), FALSE); gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "Home"), FALSE); gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "Back"), FALSE); gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "Forward"), FALSE); gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "SidePane"), FALSE); gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "ZoomIn"), FALSE); gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "ZoomOut"), FALSE); gtk_action_set_sensitive(gtk_action_group_get_action(action_group, "ZoomReset"), FALSE); GtkUIManager* ui_manager = gtk_ui_manager_new (); selfp->ui_manager = ui_manager; gtk_ui_manager_insert_action_group (ui_manager, action_group, 0); GtkAccelGroup* accel_group = gtk_ui_manager_get_accel_group (ui_manager); gtk_window_add_accel_group (GTK_WINDOW (self), accel_group); GError* error = NULL; if (!gtk_ui_manager_add_ui_from_string (ui_manager, ui_description, -1, &error)) { g_message ("building menus failed: %s", error->message); g_error_free (error); exit (EXIT_FAILURE); } GtkWidget* menubar = gtk_handle_box_new(); selfp->menubar = menubar; gtk_container_add(GTK_CONTAINER(menubar), gtk_ui_manager_get_widget (ui_manager, "/MainMenu")); gtk_box_pack_start (GTK_BOX (vbox), menubar, FALSE, FALSE, 0); GtkWidget* toolbar = gtk_handle_box_new(); selfp->toolbar = toolbar; gtk_container_add(GTK_CONTAINER(toolbar), gtk_ui_manager_get_widget(ui_manager, "/toolbar")); gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0); GtkWidget* ui_chmfile = chmsee_ui_chmfile_new(); selfp->ui_chmfile = ui_chmfile; gtk_box_pack_start(GTK_BOX(vbox), ui_chmfile, TRUE, TRUE, 0); gtk_container_set_focus_child(GTK_CONTAINER(vbox), ui_chmfile); g_signal_connect_swapped(ui_chmfile, "model_changed", G_CALLBACK(on_ui_chmfile_model_changed), self); g_signal_connect_swapped(ui_chmfile, "html_changed", G_CALLBACK(on_ui_chmfile_html_changed), self); g_signal_connect_swapped(ui_chmfile, "notify::link-message", G_CALLBACK(on_ui_chmfile_html_link_message_notify), self); gtk_tool_button_set_icon_widget( GTK_TOOL_BUTTON(gtk_ui_manager_get_widget(ui_manager, "/toolbar/sidepane")), gtk_image_new_from_file(get_resource_path("show-pane.png"))); gtk_box_pack_start (GTK_BOX (vbox), main_vbox, FALSE, FALSE, 0); gtk_widget_show_all(vbox); accel_group = g_object_new(GTK_TYPE_ACCEL_GROUP, NULL); gtk_window_add_accel_group(GTK_WINDOW (self), accel_group); /* status bar */ selfp->statusbar = glade_xml_get_widget(glade, "statusbar"); selfp->scid_default = gtk_statusbar_get_context_id(GTK_STATUSBAR (selfp->statusbar), "default"); update_status_bar(self, _("Ready!")); }
/*! \todo Finish function documentation!!! * \brief * \par Function Description * */ void x_window_create_main(GschemToplevel *w_current) { TOPLEVEL *toplevel = gschem_toplevel_get_toplevel (w_current); GtkPolicyType policy; GtkWidget *main_box=NULL; GtkWidget *menubar=NULL; GtkWidget *toolbar=NULL; GtkWidget *handlebox=NULL; GtkWidget *hscrollbar; GtkWidget *vscrollbar; GtkAdjustment *hadjustment; GtkAdjustment *vadjustment; char *right_button_text; /* used to signify that the window isn't mapped yet */ w_current->window = NULL; w_current->main_window = GTK_WIDGET (gschem_main_window_new ()); gtk_widget_set_name (w_current->main_window, "gschem"); gtk_window_set_policy (GTK_WINDOW (w_current->main_window), TRUE, TRUE, TRUE); /* We want the widgets to flow around the drawing area, so we don't * set a size of the main window. The drawing area's size is fixed, * see below */ /* * normally we let the window manager handle locating and sizing * the window. However, for some batch processing of schematics * (generating a pdf of all schematics for example) we want to * override this. Hence "auto_place_mode". */ if( auto_place_mode ) gtk_widget_set_uposition (w_current->main_window, 10, 10); /* this should work fine */ g_signal_connect (G_OBJECT (w_current->main_window), "delete_event", G_CALLBACK (i_callback_close_wm), w_current); /* Containers first */ main_box = gtk_vbox_new(FALSE, 1); gtk_container_border_width(GTK_CONTAINER(main_box), 0); gtk_container_add(GTK_CONTAINER(w_current->main_window), main_box); menubar = get_main_menu (w_current); if (w_current->handleboxes) { handlebox = gtk_handle_box_new (); gtk_box_pack_start(GTK_BOX(main_box), handlebox, FALSE, FALSE, 0); gtk_container_add (GTK_CONTAINER (handlebox), menubar); } else { gtk_box_pack_start(GTK_BOX(main_box), menubar, FALSE, FALSE, 0); } w_current->menubar = menubar; gtk_widget_realize (w_current->main_window); if (w_current->handleboxes && w_current->toolbars) { handlebox = gtk_handle_box_new (); gtk_box_pack_start (GTK_BOX (main_box), handlebox, FALSE, FALSE, 0); } if (w_current->toolbars) { toolbar = gtk_toolbar_new(); gtk_toolbar_set_orientation (GTK_TOOLBAR(toolbar), GTK_ORIENTATION_HORIZONTAL); gtk_toolbar_set_style (GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS); if (w_current->handleboxes) { gtk_container_add (GTK_CONTAINER (handlebox), toolbar); } else { gtk_box_pack_start(GTK_BOX(main_box), toolbar, FALSE, FALSE, 0); } gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("New"), _("New file"), "toolbar/new", x_window_stock_pixmap("new", w_current), (GtkSignalFunc) i_callback_toolbar_file_new, w_current); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Open"), _("Open file..."), "toolbar/open", x_window_stock_pixmap("open", w_current), (GtkSignalFunc) i_callback_toolbar_file_open, w_current); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Save"), _("Save file"), "toolbar/save", x_window_stock_pixmap("save", w_current), (GtkSignalFunc) i_callback_toolbar_file_save, w_current); gtk_toolbar_append_space (GTK_TOOLBAR(toolbar)); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Undo"), _("Undo last operation"), "toolbar/undo", x_window_stock_pixmap("undo", w_current), (GtkSignalFunc) i_callback_toolbar_edit_undo, w_current); gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Redo"), _("Redo last undo"), "toolbar/redo", x_window_stock_pixmap("redo", w_current), (GtkSignalFunc) i_callback_toolbar_edit_redo, w_current); gtk_toolbar_append_space (GTK_TOOLBAR(toolbar)); /* not part of any radio button group */ gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Component"), _("Add component...\nSelect library and component from list, move the mouse into main window, click to place\nRight mouse button to cancel"), "toolbar/component", x_window_stock_pixmap("insert-symbol", w_current), (GtkSignalFunc) i_callback_toolbar_add_component, w_current); w_current->toolbar_net = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_CHILD_RADIOBUTTON, NULL, _("Nets"), _("Add nets mode\nRight mouse button to cancel"), "toolbar/nets", x_window_stock_pixmap("insert-net", w_current), (GtkSignalFunc) i_callback_toolbar_add_net, w_current); w_current->toolbar_bus = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_CHILD_RADIOBUTTON, w_current->toolbar_net, _("Bus"), _("Add buses mode\nRight mouse button to cancel"), "toolbar/bus", x_window_stock_pixmap("insert-bus", w_current), (GtkSignalFunc) i_callback_toolbar_add_bus, w_current); /* not part of any radio button group */ gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Text"), _("Add Text..."), "toolbar/text", x_window_stock_pixmap("insert-text", w_current), (GtkSignalFunc) i_callback_toolbar_add_text, w_current); gtk_toolbar_append_space (GTK_TOOLBAR(toolbar)); w_current->toolbar_select = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_CHILD_RADIOBUTTON, w_current->toolbar_bus, _("Select"), _("Select mode"), "toolbar/select", x_window_stock_pixmap("select", w_current), (GtkSignalFunc) i_callback_toolbar_edit_select, w_current); gtk_toolbar_append_space (GTK_TOOLBAR(toolbar)); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w_current->toolbar_select), TRUE); } /* Try to create popup menu (appears in right mouse button */ w_current->popup_menu = (GtkWidget *) get_main_popup(w_current); /* Setup a GtkScrolledWindow for the drawing area */ hadjustment = GTK_ADJUSTMENT (gtk_adjustment_new (0.0, 0.0, toplevel->init_right, 100.0, 100.0, 10.0)); vadjustment = GTK_ADJUSTMENT (gtk_adjustment_new (toplevel->init_bottom, 0.0, toplevel->init_bottom, 100.0, 100.0, 10.0)); w_current->scrolled = gtk_scrolled_window_new (hadjustment, vadjustment); gtk_container_add(GTK_CONTAINER(main_box), w_current->scrolled); x_window_create_drawing(w_current->scrolled, w_current); x_window_setup_draw_events(w_current); policy = (w_current->scrollbars_flag) ? GTK_POLICY_ALWAYS : GTK_POLICY_NEVER; gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (w_current->scrolled), policy, policy); hscrollbar = gtk_scrolled_window_get_hscrollbar (GTK_SCROLLED_WINDOW (w_current->scrolled)); gtk_range_set_update_policy (GTK_RANGE (hscrollbar), GTK_UPDATE_CONTINUOUS); vscrollbar = gtk_scrolled_window_get_vscrollbar (GTK_SCROLLED_WINDOW (w_current->scrolled)); gtk_range_set_update_policy (GTK_RANGE (vscrollbar), GTK_UPDATE_CONTINUOUS); /* macro box */ w_current->macro_widget = GTK_WIDGET (g_object_new (GSCHEM_TYPE_MACRO_WIDGET, NULL)); gtk_box_pack_start (GTK_BOX (main_box), w_current->macro_widget, FALSE, FALSE, 0); g_signal_connect (w_current->macro_widget, "response", G_CALLBACK (&x_window_invoke_macro), w_current); /* bottom box */ if (default_third_button == POPUP_ENABLED) { right_button_text = _("Menu/Cancel"); } else { right_button_text = _("Pan/Cancel"); } w_current->bottom_widget = GTK_WIDGET (g_object_new (GSCHEM_TYPE_BOTTOM_WIDGET, "grid-mode", gschem_options_get_grid_mode (w_current->options), "grid-size", gschem_options_get_snap_size (w_current->options), /* x_grid_query_drawn_spacing (w_current), -- occurs before the page is set */ "left-button-text", _("Pick"), "middle-button-text", _("none"), "right-button-text", right_button_text, "snap-mode", gschem_options_get_snap_mode (w_current->options), "snap-size", gschem_options_get_snap_size (w_current->options), "status-text", _("Select Mode"), NULL)); i_update_middle_button (w_current, NULL, NULL); gtk_box_pack_start (GTK_BOX (main_box), w_current->bottom_widget, FALSE, FALSE, 0); gtk_widget_show_all (w_current->main_window); w_current->window = w_current->drawing_area->window; w_current->drawable = w_current->window; x_window_setup_gc(w_current); }
GtkWidget* create_window1 (void) { GtkWidget *window1; GtkWidget *vbox1; GtkWidget *menubar1; GtkWidget *menuitem1; GtkWidget *menu1; GtkWidget *new1; GtkWidget *open1; GtkWidget *save1; GtkWidget *save_as1; GtkWidget *separatormenuitem1; GtkWidget *quit1; GtkWidget *menuitem2; GtkWidget *menu2; GtkWidget *cut1; GtkWidget *copy1; GtkWidget *paste1; GtkWidget *delete1; GtkWidget *menuitem3; GtkWidget *menu3; GtkWidget *menuitem4; GtkWidget *menu4; GtkWidget *about1; GtkWidget *handlebox1; GtkWidget *toolbar1; GtkWidget *tmp_toolbar_icon; GtkWidget *button1; GtkWidget *button2; GtkWidget *button3; GtkWidget *hscale1; GtkWidget *statusbar1; GtkAccelGroup *accel_group; accel_group = gtk_accel_group_new (); window1 = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window1), _("window1")); vbox1 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox1); gtk_container_add (GTK_CONTAINER (window1), vbox1); menubar1 = gtk_menu_bar_new (); gtk_widget_show (menubar1); gtk_box_pack_start (GTK_BOX (vbox1), menubar1, FALSE, FALSE, 0); menuitem1 = gtk_menu_item_new_with_mnemonic (_("_File")); gtk_widget_show (menuitem1); gtk_container_add (GTK_CONTAINER (menubar1), menuitem1); menu1 = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem1), menu1); new1 = gtk_image_menu_item_new_from_stock ("gtk-new", accel_group); gtk_widget_show (new1); gtk_container_add (GTK_CONTAINER (menu1), new1); open1 = gtk_image_menu_item_new_from_stock ("gtk-open", accel_group); gtk_widget_show (open1); gtk_container_add (GTK_CONTAINER (menu1), open1); save1 = gtk_image_menu_item_new_from_stock ("gtk-save", accel_group); gtk_widget_show (save1); gtk_container_add (GTK_CONTAINER (menu1), save1); save_as1 = gtk_image_menu_item_new_from_stock ("gtk-save-as", accel_group); gtk_widget_show (save_as1); gtk_container_add (GTK_CONTAINER (menu1), save_as1); separatormenuitem1 = gtk_separator_menu_item_new (); gtk_widget_show (separatormenuitem1); gtk_container_add (GTK_CONTAINER (menu1), separatormenuitem1); gtk_widget_set_sensitive (separatormenuitem1, FALSE); quit1 = gtk_image_menu_item_new_from_stock ("gtk-quit", accel_group); gtk_widget_show (quit1); gtk_container_add (GTK_CONTAINER (menu1), quit1); menuitem2 = gtk_menu_item_new_with_mnemonic (_("_Edit")); gtk_widget_show (menuitem2); gtk_container_add (GTK_CONTAINER (menubar1), menuitem2); menu2 = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem2), menu2); cut1 = gtk_image_menu_item_new_from_stock ("gtk-cut", accel_group); gtk_widget_show (cut1); gtk_container_add (GTK_CONTAINER (menu2), cut1); copy1 = gtk_image_menu_item_new_from_stock ("gtk-copy", accel_group); gtk_widget_show (copy1); gtk_container_add (GTK_CONTAINER (menu2), copy1); paste1 = gtk_image_menu_item_new_from_stock ("gtk-paste", accel_group); gtk_widget_show (paste1); gtk_container_add (GTK_CONTAINER (menu2), paste1); delete1 = gtk_image_menu_item_new_from_stock ("gtk-delete", accel_group); gtk_widget_show (delete1); gtk_container_add (GTK_CONTAINER (menu2), delete1); menuitem3 = gtk_menu_item_new_with_mnemonic (_("_View")); gtk_widget_show (menuitem3); gtk_container_add (GTK_CONTAINER (menubar1), menuitem3); menu3 = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem3), menu3); menuitem4 = gtk_menu_item_new_with_mnemonic (_("_Help")); gtk_widget_show (menuitem4); gtk_container_add (GTK_CONTAINER (menubar1), menuitem4); menu4 = gtk_menu_new (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem4), menu4); about1 = gtk_menu_item_new_with_mnemonic (_("_About")); gtk_widget_show (about1); gtk_container_add (GTK_CONTAINER (menu4), about1); handlebox1 = gtk_handle_box_new (); gtk_widget_show (handlebox1); gtk_box_pack_start (GTK_BOX (vbox1), handlebox1, FALSE, TRUE, 0); toolbar1 = gtk_toolbar_new (); gtk_widget_show (toolbar1); gtk_container_add (GTK_CONTAINER (handlebox1), toolbar1); gtk_toolbar_set_style (GTK_TOOLBAR (toolbar1), GTK_TOOLBAR_BOTH); tmp_toolbar_icon = gtk_image_new_from_stock ("gtk-open", gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar1))); button1 = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, _("button1"), NULL, NULL, tmp_toolbar_icon, NULL, NULL); gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (toolbar1)->children)->data))->label), TRUE); gtk_widget_show (button1); tmp_toolbar_icon = gtk_image_new_from_stock ("gtk-cdrom", gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar1))); button2 = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, _("button2"), NULL, NULL, tmp_toolbar_icon, NULL, NULL); gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (toolbar1)->children)->data))->label), TRUE); gtk_widget_show (button2); tmp_toolbar_icon = gtk_image_new_from_stock ("gtk-refresh", gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar1))); button3 = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, _("button3"), NULL, NULL, tmp_toolbar_icon, NULL, NULL); gtk_label_set_use_underline (GTK_LABEL (((GtkToolbarChild*) (g_list_last (GTK_TOOLBAR (toolbar1)->children)->data))->label), TRUE); gtk_widget_show (button3); hscale1 = gtk_hscale_new (GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 0, 0, 0, 0))); gtk_widget_show (hscale1); gtk_box_pack_start (GTK_BOX (vbox1), hscale1, TRUE, TRUE, 0); statusbar1 = gtk_statusbar_new (); gtk_widget_show (statusbar1); gtk_box_pack_start (GTK_BOX (vbox1), statusbar1, FALSE, FALSE, 0); g_signal_connect ((gpointer) new1, "activate", G_CALLBACK (on_new1_activate), NULL); g_signal_connect ((gpointer) open1, "activate", G_CALLBACK (on_open1_activate), NULL); g_signal_connect ((gpointer) save1, "activate", G_CALLBACK (on_save1_activate), NULL); g_signal_connect ((gpointer) save_as1, "activate", G_CALLBACK (on_save_as1_activate), NULL); g_signal_connect ((gpointer) quit1, "activate", G_CALLBACK (on_quit1_activate), NULL); g_signal_connect ((gpointer) cut1, "activate", G_CALLBACK (on_cut1_activate), NULL); g_signal_connect ((gpointer) copy1, "activate", G_CALLBACK (on_copy1_activate), NULL); g_signal_connect ((gpointer) paste1, "activate", G_CALLBACK (on_paste1_activate), NULL); g_signal_connect ((gpointer) delete1, "activate", G_CALLBACK (on_delete1_activate), NULL); g_signal_connect ((gpointer) about1, "activate", G_CALLBACK (on_about1_activate), NULL); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (window1, window1, "window1"); GLADE_HOOKUP_OBJECT (window1, vbox1, "vbox1"); GLADE_HOOKUP_OBJECT (window1, menubar1, "menubar1"); GLADE_HOOKUP_OBJECT (window1, menuitem1, "menuitem1"); GLADE_HOOKUP_OBJECT (window1, menu1, "menu1"); GLADE_HOOKUP_OBJECT (window1, new1, "new1"); GLADE_HOOKUP_OBJECT (window1, open1, "open1"); GLADE_HOOKUP_OBJECT (window1, save1, "save1"); GLADE_HOOKUP_OBJECT (window1, save_as1, "save_as1"); GLADE_HOOKUP_OBJECT (window1, separatormenuitem1, "separatormenuitem1"); GLADE_HOOKUP_OBJECT (window1, quit1, "quit1"); GLADE_HOOKUP_OBJECT (window1, menuitem2, "menuitem2"); GLADE_HOOKUP_OBJECT (window1, menu2, "menu2"); GLADE_HOOKUP_OBJECT (window1, cut1, "cut1"); GLADE_HOOKUP_OBJECT (window1, copy1, "copy1"); GLADE_HOOKUP_OBJECT (window1, paste1, "paste1"); GLADE_HOOKUP_OBJECT (window1, delete1, "delete1"); GLADE_HOOKUP_OBJECT (window1, menuitem3, "menuitem3"); GLADE_HOOKUP_OBJECT (window1, menu3, "menu3"); GLADE_HOOKUP_OBJECT (window1, menuitem4, "menuitem4"); GLADE_HOOKUP_OBJECT (window1, menu4, "menu4"); GLADE_HOOKUP_OBJECT (window1, about1, "about1"); GLADE_HOOKUP_OBJECT (window1, handlebox1, "handlebox1"); GLADE_HOOKUP_OBJECT (window1, toolbar1, "toolbar1"); GLADE_HOOKUP_OBJECT (window1, button1, "button1"); GLADE_HOOKUP_OBJECT (window1, button2, "button2"); GLADE_HOOKUP_OBJECT (window1, button3, "button3"); GLADE_HOOKUP_OBJECT (window1, hscale1, "hscale1"); GLADE_HOOKUP_OBJECT (window1, statusbar1, "statusbar1"); gtk_window_add_accel_group (GTK_WINDOW (window1), accel_group); return window1; }
static GtkWidget * normal_contents (void) { GtkWidget *table; GtkWidget *toolbar; GtkWidget *handlebox; GtkWidget *statusbar; GtkWidget *contents; GtkWidget *sw; GtkItemFactory *item_factory; table = gtk_table_new (1, 4, FALSE); /* Create the menubar */ item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>", NULL); gtk_item_factory_set_translate_func(item_factory, (GtkTranslateFunc)gettext, NULL, NULL); /* Set up item factory to go away */ g_object_ref (item_factory); g_object_ref_sink (item_factory); g_object_unref (item_factory); g_object_set_data_full (G_OBJECT (table), "<main>", item_factory, (GDestroyNotify) g_object_unref); /* create menu items */ gtk_item_factory_create_items (item_factory, G_N_ELEMENTS (menu_items), menu_items, NULL); gtk_table_attach (GTK_TABLE (table), gtk_item_factory_get_widget (item_factory, "<main>"), /* X direction */ /* Y direction */ 0, 1, 0, 1, GTK_EXPAND | GTK_FILL, 0, 0, 0); /* Create the toolbar */ toolbar = gtk_toolbar_new (); GtkToolItem *newButton = gtk_tool_button_new_from_stock(GTK_STOCK_NEW); gtk_tool_item_set_tooltip_text(newButton, "Open another one of these windows"); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), newButton, -1); /*-1 means append to end of toolbar*/ GtkToolItem *openButton = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN); gtk_tool_item_set_tooltip_text(openButton, "This is a demo button with an \'open\' icon"); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), openButton, -1); /*-1 means append to end of toolbar*/ GtkToolItem *quitButton = gtk_tool_button_new_from_stock(GTK_STOCK_QUIT); gtk_tool_item_set_tooltip_text(quitButton, "This is a demo button with a \'quit\' icon"); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), quitButton, -1); /*-1 means append to end of toolbar*/ handlebox = gtk_handle_box_new (); gtk_container_add (GTK_CONTAINER (handlebox), toolbar); gtk_table_attach (GTK_TABLE (table), handlebox, /* X direction */ /* Y direction */ 0, 1, 1, 2, GTK_EXPAND | GTK_FILL, 0, 0, 0); /* Create document */ sw = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_IN); gtk_table_attach (GTK_TABLE (table), sw, /* X direction */ /* Y direction */ 0, 1, 2, 3, GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0); contents = gtk_text_view_new (); gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (contents), PANGO_WRAP_WORD); gtk_container_add (GTK_CONTAINER (sw), contents); /* Create statusbar */ statusbar = gtk_statusbar_new (); gtk_table_attach (GTK_TABLE (table), statusbar, /* X direction */ /* Y direction */ 0, 1, 3, 4, GTK_EXPAND | GTK_FILL, 0, 0, 0); gtk_widget_show_all (table); return table; }
void init_main_win( void ) { GtkAttachOptions xOpt, yOpt; gMapWin = gtk_window_new( GTK_WINDOW_TOPLEVEL ); if( gMapWin == NULL ){ print_msg( FLG_MSG_ERR, "gtk_window_new()" ); exit_game( EXIT_FAILURE ); } GtkWidget *vBox = gtk_vbox_new( FALSE, 0 ); gtk_container_add( GTK_CONTAINER( gMapWin ), vBox ); gtk_widget_show( vBox ); // メイン・ウィンドウへのイベント・ハンドラを設定 gtk_signal_connect( GTK_OBJECT( gMapWin ), "delete_event", GTK_SIGNAL_FUNC( handle_delete ), NULL ); gtk_signal_connect( GTK_OBJECT( gMapWin ), "destroy", GTK_SIGNAL_FUNC( handle_destroy ), NULL ); gtk_signal_connect( GTK_OBJECT( gMapWin ), "key-press-event", GTK_SIGNAL_FUNC( handleKeyPress ), NULL ); // ツール・バーを作成 GtkWidget *handleBox = gtk_handle_box_new(); gtk_box_pack_start( GTK_BOX( vBox ), handleBox, FALSE, FALSE, 0 ); gtk_widget_show( handleBox ); GtkWidget *toolBar = gtk_toolbar_new(); gtk_toolbar_set_orientation( GTK_TOOLBAR( toolBar ), GTK_ORIENTATION_HORIZONTAL ); gtk_toolbar_set_style( GTK_TOOLBAR( toolBar ), GTK_TOOLBAR_ICONS ); gtk_widget_show( toolBar ); gtk_container_add( GTK_CONTAINER( handleBox ), toolBar ); // ツール・バーのボタンを作成 btnMapExec = gtk_button_new_with_label( MSG_GUI_MAP_EXEC ); gMapButtonContExec = gtk_button_new_with_label( MSG_GUI_MAP_CONT_EXEC_OFF ); #if FLAG_BTN_MAP_LABEL_IS_NAME btnMapAutoMark = gtk_button_new_with_label( MSG_GUI_MAP_AUTO_MARK ); btnMapUserMenu = gtk_button_new_with_label( MSG_GUI_MAP_USER_MENU ); btnMapSpell = gtk_button_new_with_label( MSG_GUI_MAP_SPELL ); btnMapSquare = gtk_button_new_with_label( MSG_GUI_MAP_SQUARE ); #else btnMapAutoMark = gtk_button_new_with_label( " / " ); btnMapUserMenu = gtk_button_new_with_label( " * " ); btnMapSpell = gtk_button_new_with_label( " - " ); btnMapSquare = gtk_button_new_with_label( " + " ); #endif btnMapCancel = gtk_button_new_with_label( MSG_GUI_MAP_CANCEL ); btnMapOk = gtk_button_new_with_label( MSG_GUI_MAP_OK ); gtk_toolbar_append_widget( GTK_TOOLBAR( toolBar ), btnMapExec, MSG_GUI_MAP_TOOL_TIP_EXEC, NULL ); gtk_toolbar_append_widget( GTK_TOOLBAR( toolBar ), gMapButtonContExec, MSG_GUI_MAP_TOOL_TIP_CONT_EXEC, NULL ); gtk_toolbar_append_widget( GTK_TOOLBAR( toolBar ), btnMapAutoMark, MSG_GUI_MAP_TOOL_TIP_AUTO_MARK, NULL ); gtk_toolbar_append_widget( GTK_TOOLBAR( toolBar ), btnMapUserMenu, MSG_GUI_MAP_TOOL_TIP_USER_MENU, NULL ); gtk_toolbar_append_widget( GTK_TOOLBAR( toolBar ), btnMapSpell, MSG_GUI_MAP_TOOL_TIP_SPELL, NULL ); gtk_toolbar_append_widget( GTK_TOOLBAR( toolBar ), btnMapSquare, MSG_GUI_MAP_TOOL_TIP_SQUARE, NULL ); gtk_toolbar_append_widget( GTK_TOOLBAR( toolBar ), btnMapCancel, MSG_GUI_MAP_TOOL_TIP_CANCEL, NULL ); gtk_toolbar_append_widget( GTK_TOOLBAR( toolBar ), btnMapOk, MSG_GUI_MAP_TOOL_TIP_OK, NULL ); gtk_widget_show( btnMapExec ); gtk_widget_show( gMapButtonContExec ); gtk_widget_show( btnMapAutoMark ); gtk_widget_show( btnMapUserMenu ); gtk_widget_show( btnMapSpell ); gtk_widget_show( btnMapSquare ); gtk_widget_show( btnMapCancel ); gtk_widget_show( btnMapOk ); // ツール・バーへのイベント・ハンドラを設定 gtk_signal_connect( GTK_OBJECT( btnMapExec ), "clicked", GTK_SIGNAL_FUNC( handle_exec_clicked ), NULL ); gtk_signal_connect( GTK_OBJECT( gMapButtonContExec ), "clicked", GTK_SIGNAL_FUNC( handle_cont_exec_clicked ), NULL ); gtk_signal_connect( GTK_OBJECT( btnMapAutoMark ), "clicked", GTK_SIGNAL_FUNC( handle_auto_mark_clicked ), NULL ); gtk_signal_connect( GTK_OBJECT( btnMapUserMenu ), "clicked", GTK_SIGNAL_FUNC( handle_user_menu_clicked ), NULL ); gtk_signal_connect( GTK_OBJECT( btnMapSpell ), "clicked", GTK_SIGNAL_FUNC( handle_spell_clicked ), NULL ); gtk_signal_connect( GTK_OBJECT( btnMapSquare ), "clicked", GTK_SIGNAL_FUNC( handle_square_clicked ), NULL ); gtk_signal_connect( GTK_OBJECT( btnMapCancel ), "clicked", GTK_SIGNAL_FUNC( handle_cancel_clicked ), NULL ); gtk_signal_connect( GTK_OBJECT( btnMapOk ), "clicked", GTK_SIGNAL_FUNC( handle_ok_clicked ), NULL ); // 描画エリアを作成 GtkWidget *pTab = gtk_table_new( 2, 2, FALSE ); gtk_box_pack_start( GTK_BOX( vBox ), pTab, TRUE, TRUE, 0 ); gtk_widget_show( pTab ); gMapDrawingArea = gtk_drawing_area_new(); if( gMapDrawingArea == NULL ){ print_msg( FLG_MSG_ERR, "gtk_drawing_area_new()" ); exit_game( EXIT_FAILURE ); } gtk_drawing_area_size( GTK_DRAWING_AREA( gMapDrawingArea ), MAP_WIN_INIT_WIDTH(), MAP_WIN_INIT_HEIGHT() ); xOpt = (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK | GTK_FILL); yOpt = (GtkAttachOptions)(GTK_EXPAND | GTK_SHRINK | GTK_FILL); gtk_table_attach( GTK_TABLE( pTab ), gMapDrawingArea, 0, 1, 0, 1, xOpt, yOpt, 0, 0 ); gtk_widget_show( gMapDrawingArea ); // 描画エリアへのイベント・ハンドラを設定 gtk_signal_connect( GTK_OBJECT( gMapDrawingArea ), "expose_event", GTK_SIGNAL_FUNC( handle_map_expose ), NULL ); gtk_signal_connect( GTK_OBJECT( gMapDrawingArea ), "configure_event", GTK_SIGNAL_FUNC( handle_map_configure ), NULL ); // 描画エリアのマウス・モーションのイベント・ハンドラを設定 gtk_signal_connect( GTK_OBJECT( gMapDrawingArea ), "motion_notify_event", GTK_SIGNAL_FUNC( handle_map_motion_notify ), NULL ); gtk_signal_connect( GTK_OBJECT( gMapDrawingArea ), "button_press_event", GTK_SIGNAL_FUNC( handle_map_button_press ), NULL ); gtk_signal_connect( GTK_OBJECT( gMapDrawingArea ), "button_release_event", GTK_SIGNAL_FUNC( handle_map_button_release ), NULL ); gtk_signal_connect( GTK_OBJECT( gMapDrawingArea ), "scroll_event", GTK_SIGNAL_FUNC( handle_map_scroll ), NULL ); gtk_widget_set_events( gMapDrawingArea, (GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK | GDK_SCROLL_MASK) ); // 水平スクロール・バーの調整を作成 gMapHScrollBarAdjustment = gtk_adjustment_new( 0, 0, MAP_PIX_MAX_X(), 1 * TILE_X_SIZE(), AREA_MAX_X * TILE_X_SIZE() / 2, AREA_MAX_X * TILE_X_SIZE() ); if( gMapHScrollBarAdjustment == NULL ){ print_msg( FLG_MSG_ERR, "gtk_adjustment_new()" ); exit_game( EXIT_FAILURE ); } // 水平スクロール・バーの調整のイベント・ハンドラを設定 gtk_signal_connect( GTK_OBJECT( gMapHScrollBarAdjustment ), "changed", GTK_SIGNAL_FUNC( handle_map_scroll_changed ), NULL ); gtk_signal_connect( GTK_OBJECT( gMapHScrollBarAdjustment ), "value_changed", GTK_SIGNAL_FUNC( handle_map_scroll_changed ), NULL ); // 水平スクロール・バーを作成 gMapHScrollBar = gtk_hscrollbar_new( GTK_ADJUSTMENT( gMapHScrollBarAdjustment ) ); if( gMapHScrollBar == NULL ){ print_msg( FLG_MSG_ERR, "gtk_hscrollbar_new()" ); exit_game( EXIT_FAILURE ); } xOpt = (GtkAttachOptions)(GTK_SHRINK | GTK_FILL); yOpt = (GtkAttachOptions)(GTK_FILL); gtk_table_attach( GTK_TABLE( pTab ), gMapHScrollBar, 0, 1, 1, 2, xOpt, yOpt, 0, 0 ); gtk_widget_show( gMapHScrollBar ); // 垂直スクロール・バーの調整を作成 gMapVScrollBarAdjustment = gtk_adjustment_new( 0, 0, MAP_PIX_MAX_Y(), 1 * TILE_Y_SIZE(), AREA_MAX_Y * TILE_Y_SIZE() / 2, AREA_MAX_Y * TILE_Y_SIZE() ); if( gMapVScrollBarAdjustment == NULL ){ print_msg( FLG_MSG_ERR, "gtk_adjustment_new()" ); exit_game( EXIT_FAILURE ); } // 垂直スクロール・バーの調整のイベント・ハンドラを設定 gtk_signal_connect( GTK_OBJECT( gMapVScrollBarAdjustment ), "changed", GTK_SIGNAL_FUNC( handle_map_scroll_changed ), NULL ); gtk_signal_connect( GTK_OBJECT( gMapVScrollBarAdjustment ), "value_changed", GTK_SIGNAL_FUNC( handle_map_scroll_changed ), NULL ); // 垂直スクロール・バーを作成 gMapVScrollBar = gtk_vscrollbar_new( GTK_ADJUSTMENT( gMapVScrollBarAdjustment ) ); if( gMapVScrollBar == NULL ){ print_msg( FLG_MSG_ERR, "gtk_vscrollbar_new()" ); exit_game( EXIT_FAILURE ); } xOpt = (GtkAttachOptions)(GTK_FILL); yOpt = (GtkAttachOptions)(GTK_SHRINK | GTK_FILL); gtk_table_attach( GTK_TABLE( pTab ), gMapVScrollBar, 1, 2, 0, 1, xOpt, yOpt, 0, 0 ); gtk_widget_show( gMapVScrollBar ); // ステータス・バーを作成 statBarMap = gtk_statusbar_new(); if( statBarMap == NULL ){ print_msg( FLG_MSG_ERR, "gtk_statusbar_new()" ); exit_game( EXIT_FAILURE ); } gtk_box_pack_start( GTK_BOX( vBox ), statBarMap, FALSE, FALSE, 0 ); statBarMapContextId = gtk_statusbar_get_context_id( GTK_STATUSBAR( statBarMap ), "Status bar" ); gtk_statusbar_set_has_resize_grip( GTK_STATUSBAR( statBarMap ), TRUE ); statBarMapMesId = gtk_statusbar_push( GTK_STATUSBAR( statBarMap ), statBarMapContextId, "OK" ); gtk_widget_show( statBarMap ); // メイン・ウィンドウを表示 gWinPos[WIN_KIND_MAP].draw( WIN_KIND_MAP ); gtk_drawing_area_size( GTK_DRAWING_AREA( gMapDrawingArea ), MAP_WIN_MIN_WIDTH(), MAP_WIN_MIN_HEIGHT() ); }