Пример #1
0
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;
}
Пример #2
0
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;
}
Пример #3
0
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, &gtkStyle);

    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;
}
Пример #4
0
/*
 * 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;
}
Пример #5
0
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);
}
Пример #6
0
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 );

}
Пример #7
0
/**
 * 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 );
}
Пример #8
0
/*!
* 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));
	}
}
Пример #9
0
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;
}
Пример #10
0
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]);
}
Пример #11
0
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);
}
Пример #12
0
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;
}
Пример #13
0
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;
}
Пример #14
0
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;
}
Пример #15
0
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();
}
Пример #16
0
/*! \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);
}
Пример #17
0
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;
}
Пример #18
0
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;
}
Пример #19
0
static VALUE
rg_initialize(VALUE self)
{
    RBGTK_INITIALIZE(self, gtk_handle_box_new());
    return Qnil;
}
Пример #20
0
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;
}
Пример #21
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!"));
}
Пример #22
0
/*! \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);
}
Пример #23
0
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;
}
Пример #24
0
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;
}
Пример #25
0
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() );
}