ZLGtkApplicationWindow::ZLGtkApplicationWindow(ZLApplication *application) :
	ZLApplicationWindow(application),
	KeyActionOnReleaseNotOnPressOption(ZLCategoryKey::CONFIG, "KeyAction", "OnRelease", false),
	myFullScreen(false) {
	myProgram = HILDON_PROGRAM(hildon_program_get_instance());
	g_set_application_name("");

	myWindow = HILDON_WINDOW(hildon_window_new());

	((ZLMaemoCommunicationManager&)ZLCommunicationManager::Instance()).init();

	myToolbar = GTK_TOOLBAR(gtk_toolbar_new());
	gtk_toolbar_set_show_arrow(myToolbar, false);
	gtk_toolbar_set_orientation(myToolbar, GTK_ORIENTATION_HORIZONTAL);
	gtk_toolbar_set_style(myToolbar, GTK_TOOLBAR_ICONS);

	myMenu = GTK_MENU(gtk_menu_new());
	hildon_window_set_menu(myWindow, myMenu);
	gtk_widget_show_all(GTK_WIDGET(myMenu));

	hildon_window_add_toolbar(myWindow, myToolbar);
	hildon_program_add_window(myProgram, myWindow);
	gtk_widget_show_all(GTK_WIDGET(myWindow));

	myViewWidget = 0;

	ZLGtkSignalUtil::connectSignal(GTK_OBJECT(myWindow), "delete_event", GTK_SIGNAL_FUNC(applicationQuit), this);
	ZLGtkSignalUtil::connectSignal(GTK_OBJECT(myWindow), "key_press_event", GTK_SIGNAL_FUNC(handleKeyPress), this);
	ZLGtkSignalUtil::connectSignal(GTK_OBJECT(myWindow), "key_release_event", GTK_SIGNAL_FUNC(handleKeyRelease), this);
}
Exemple #2
0
static void
change_orientation (GtkWidget *button, GtkWidget *toolbar)
{
  GtkWidget *table;
  GtkOrientation orientation;

  table = gtk_widget_get_parent (toolbar);
  if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (button)))
    orientation = GTK_ORIENTATION_VERTICAL;
  else
    orientation = GTK_ORIENTATION_HORIZONTAL;

  g_object_ref (toolbar);
  gtk_container_remove (GTK_CONTAINER (table), toolbar);
  gtk_toolbar_set_orientation (GTK_TOOLBAR (toolbar), orientation);
  if (orientation == GTK_ORIENTATION_HORIZONTAL)
    {
      gtk_table_attach (GTK_TABLE (table), toolbar,
			0,2, 0,1, GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0);
    }
  else
    {
      gtk_table_attach (GTK_TABLE (table), toolbar,
			0,1, 0,4, GTK_FILL, GTK_FILL|GTK_EXPAND, 0, 0);
    }
  g_object_unref (toolbar);
}
static void create_toolbar_menu()
{
	GtkWidget *iconw;
	GtkWidget *close_button;

	bdk_window.toolbar = gtk_toolbar_new ();
	gtk_toolbar_set_orientation (GTK_TOOLBAR (bdk_window.toolbar), GTK_ORIENTATION_HORIZONTAL);
	gtk_toolbar_set_style (GTK_TOOLBAR (bdk_window.toolbar), GTK_TOOLBAR_BOTH);

	/* our first item is <close> button */
	iconw = gtk_image_new_from_stock (GTK_STOCK_OPEN, GTK_ICON_SIZE_SMALL_TOOLBAR)  ; // ("gtk.xpm"); /* icon widget */
	close_button = 
	gtk_toolbar_append_item (GTK_TOOLBAR (bdk_window.toolbar), /* our toolbar */
							 "Open",               /* button label */
							 "Open a file",     /* this button's tooltip */
							 "Private",             /* tooltip private info */
							 iconw,                 /* icon widget */
							 GTK_SIGNAL_FUNC (open_event), /* a signal */
							 NULL);
	gtk_toolbar_append_space (GTK_TOOLBAR (bdk_window.toolbar)); /* space after item */
	/* our first item is <close> button */
	iconw = gtk_image_new_from_stock (GTK_STOCK_QUIT, GTK_ICON_SIZE_SMALL_TOOLBAR)  ; // ("gtk.xpm"); /* icon widget */
	close_button = 
	gtk_toolbar_append_item(	GTK_TOOLBAR (bdk_window.toolbar), /* our toolbar */
								 "Close",               /* button label */
								 "Closes this app",     /* this button's tooltip */
								 "Private",             /* tooltip private info */
								 iconw,                 /* icon widget */
								 GTK_SIGNAL_FUNC (gtk_main_quit), /* a signal */
								 NULL);
	gtk_box_pack_start (GTK_BOX (bdk_window.main_vbox), bdk_window.toolbar, FALSE, TRUE, 0);
}
Exemple #4
0
/*	Creates a toolbar based on the data found in the passed xmlNode
 * 	Returns the fully populated GtkToolbar 	
 */
GtkToolbar* ToolbarManager::createToolbar(xml::Node& node) {
	// Get all action children elements 
	xml::NodeList toolItemList = node.getChildren();
	GtkWidget* toolbar;
		
	if (!toolItemList.empty()) {
		// Create a new toolbar
		toolbar = gtk_toolbar_new();
		gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
		
		// Try to set the alignment, if the attribute is properly set
		std::string align = node.getAttributeValue("align");
		GtkOrientation orientation = (align == "vertical") ? GTK_ORIENTATION_VERTICAL : GTK_ORIENTATION_HORIZONTAL;
		gtk_toolbar_set_orientation(GTK_TOOLBAR(toolbar), orientation);
		
		for (std::size_t i = 0; i < toolItemList.size(); i++) {
			// Create and get the toolItem with the parsing 
			GtkWidget* toolItem = createToolItem(toolItemList[i]);
			
			// It is possible that no toolItem is returned, only add it if it's safe to do so
			if (toolItem != NULL) {    				
				gtk_toolbar_insert(GTK_TOOLBAR(toolbar), GTK_TOOL_ITEM(toolItem), -1);    				
			}
		}
	}
	else {
		throw std::runtime_error("No elements in toolbar.");
	}
	
	return GTK_TOOLBAR(toolbar);
}
Exemple #5
0
/*********************************************************************************************************
* gui functions
*/
void create_filter()
{
    GtkToolItem* toolitem;
    GtkWidget* label;
    GtkWidget* hbox;

    hbox = gtk_hbox_new(FALSE, 0);
    toolitem = gtk_tool_item_new(); /* This is how gtk does more complex toolbar items. */
    gtk_tool_item_set_expand(toolitem, TRUE);

    g_MainWindow.filterBar = gtk_toolbar_new();
    gtk_toolbar_set_orientation(GTK_TOOLBAR(g_MainWindow.filterBar), GTK_ORIENTATION_HORIZONTAL);

    label = gtk_label_new_with_mnemonic(tr("F_ilter:"));
    g_MainWindow.filter = gtk_entry_new();
    gtk_label_set_mnemonic_widget(GTK_LABEL(label), g_MainWindow.filter);
    gtk_entry_set_text(GTK_ENTRY(g_MainWindow.filter), "");

    g_signal_connect(g_MainWindow.filter, "changed", G_CALLBACK(callback_apply_filter), NULL);
    g_signal_connect(g_MainWindow.filter, "activate", G_CALLBACK(callback_apply_filter), NULL);
    g_signal_connect(g_MainWindow.filter, "focus-in-event", G_CALLBACK(callback_filter_selected), NULL);
    g_signal_connect(g_MainWindow.filter, "focus-out-event", G_CALLBACK(callback_filter_unselected), NULL);
    g_signal_connect(g_MainWindow.filter, "grab-notify", G_CALLBACK(callback_filter_grab_unselected), NULL);

    gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5);
    gtk_box_pack_start(GTK_BOX(hbox), g_MainWindow.filter, TRUE, TRUE, 5);

    gtk_container_add(GTK_CONTAINER(toolitem), hbox);
    gtk_toolbar_insert(GTK_TOOLBAR(g_MainWindow.filterBar), toolitem, 0);

    gtk_box_pack_start(GTK_BOX(g_MainWindow.toplevelVBox), g_MainWindow.filterBar, FALSE, FALSE, 0);
}
Exemple #6
0
static void create_toolbar() {
    browser->toolbar = gtk_toolbar_new();
#ifndef GTK_ORIENTABLE
    gtk_toolbar_set_orientation(GTK_TOOLBAR (browser->toolbar), GTK_ORIENTATION_HORIZONTAL);
#else
    gtk_orientable_set_orientation(GTK_ORIENTABLE (browser->toolbar), GTK_ORIENTATION_HORIZONTAL);
#endif
    gtk_toolbar_set_style(GTK_TOOLBAR (browser->toolbar), GTK_TOOLBAR_BOTH_HORIZ);

    GtkToolItem* item;
    /* the back button */
    item = gtk_tool_button_new_from_stock(GTK_STOCK_GO_BACK);
    g_signal_connect (G_OBJECT (item), "clicked", G_CALLBACK (go_back_cb), (gpointer) browser);
    gtk_toolbar_insert(GTK_TOOLBAR (browser->toolbar), item, -1);

    /* The forward button */
    item = gtk_tool_button_new_from_stock(GTK_STOCK_GO_FORWARD);
    g_signal_connect (G_OBJECT (item), "clicked", G_CALLBACK (go_forward_cb), (gpointer) browser);
    gtk_toolbar_insert(GTK_TOOLBAR (browser->toolbar), item, -1);

    /* The URL entry */
    item = gtk_tool_item_new();
    gtk_tool_item_set_expand(item, TRUE);

    browser->uri_entry = gtk_entry_new();
    gtk_container_add(GTK_CONTAINER (item), browser->uri_entry);
    g_signal_connect (G_OBJECT (browser->uri_entry), "activate", G_CALLBACK (activate_uri_entry_cb), (gpointer)browser);
    gtk_toolbar_insert(GTK_TOOLBAR (browser->toolbar), item, -1);

    /* The go button */
    item = gtk_tool_button_new_from_stock(GTK_STOCK_OK);
    g_signal_connect_swapped (G_OBJECT (item), "clicked", G_CALLBACK (activate_uri_entry_cb), (gpointer)browser->uri_entry);
    gtk_toolbar_insert(GTK_TOOLBAR (browser->toolbar), item, -1);
}
static GtkWidget* create_toolbar()
{
 GtkWidget* toolbar=gtk_toolbar_new();

 gtk_toolbar_set_orientation(GTK_TOOLBAR (toolbar), GTK_ORIENTATION_HORIZONTAL);
 gtk_toolbar_set_style(GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH_HORIZ);

 GtkToolItem* item;

// botao para voltar
 item = gtk_tool_button_new_from_stock(GTK_STOCK_GO_BACK);
 g_signal_connect(G_OBJECT (item), "clicked", G_CALLBACK (go_back_box), NULL);
 gtk_toolbar_insert(GTK_TOOLBAR (toolbar), item, -1);

// botao para ir para url que esta antes
 item = gtk_tool_button_new_from_stock(GTK_STOCK_GO_FORWARD);
 g_signal_connect(G_OBJECT (item), "clicked", G_CALLBACK (go_forward_box), NULL);
 gtk_toolbar_insert(GTK_TOOLBAR (toolbar), item, -1);

// form de entrada de url
 item = gtk_tool_item_new();
 gtk_tool_item_set_expand(item, TRUE);
 uri_entry = gtk_entry_new();
 gtk_container_add(GTK_CONTAINER (item), uri_entry);
 g_signal_connect(G_OBJECT (uri_entry), "activate", G_CALLBACK (activate_uri_entry_box), NULL);
 gtk_toolbar_insert(GTK_TOOLBAR (toolbar), item, -1);

// botao bara ir e abrir
 item = gtk_tool_button_new_from_stock(GTK_STOCK_OK);
 g_signal_connect_swapped(G_OBJECT (item), "clicked", G_CALLBACK (activate_uri_entry_box), (gpointer)uri_entry);
 gtk_toolbar_insert(GTK_TOOLBAR (toolbar), item, -1);

 return toolbar;
}
Exemple #8
0
void wxToolBar::GtkSetStyle()
{
    GtkOrientation orient;
    GtkToolbarStyle style;
    GetGtkStyle(GetWindowStyle(), &orient, &style);

    gtk_toolbar_set_orientation(m_toolbar, orient);
    gtk_toolbar_set_style(m_toolbar, style);
}
Exemple #9
0
void canvas(link q)
{
    GtkWidget *window, *draw_area, *table, *tool_bar;
    GtkWidget *export, *save, *zoom_in, *zoom_out, *restore;
    gchar stmp[MAXLEN] = "Node ";
    strc *r;

    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_widget_set_size_request (GTK_WIDGET(window), 620, 480);
    gtk_window_set_title (GTK_WINDOW(window), strcat(stmp, p->nodename[q->i]));
    gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);

    gtk_window_set_transient_for(GTK_WINDOW (window), GTK_WINDOW (main_window));
    gtk_window_set_destroy_with_parent(GTK_WINDOW (window), TRUE);

    table = gtk_table_new(4, 2, FALSE);
    gtk_table_set_row_spacings(GTK_TABLE(table), 0);
    gtk_table_set_col_spacings(GTK_TABLE(table), 0);
    gtk_container_add(GTK_CONTAINER(window), table);

    draw_area = gtk_drawing_area_new();
    gtk_widget_set_size_request (GTK_WIDGET(draw_area), 400, 400);

    gtk_signal_connect(GTK_OBJECT(draw_area), "expose_event",
                 G_CALLBACK(expose_event), q);

    gtk_signal_connect (GTK_OBJECT(window), "destroy", G_CALLBACK(child_window_quit), NULL);

    gtk_widget_set_events(draw_area, GDK_EXPOSURE_MASK | GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK);

    hruler[q->i] = gtk_hruler_new ();
    g_signal_connect_swapped(G_OBJECT (draw_area), "motion_notify_event",
                             G_CALLBACK (EVENT_METHOD (hruler[q->i], motion_notify_event)),
                             G_OBJECT (hruler[q->i]));
    vruler[q->i] = gtk_vruler_new ();  
    g_signal_connect_swapped(G_OBJECT (draw_area), "motion_notify_event",
                             G_CALLBACK (EVENT_METHOD (vruler[q->i], motion_notify_event)),
                             G_OBJECT (vruler[q->i]));

    g_signal_connect(G_OBJECT (draw_area), "motion_notify_event", G_CALLBACK (put_status), q);

    tool_bar = gtk_toolbar_new();
    gtk_toolbar_set_orientation (GTK_TOOLBAR (tool_bar), GTK_ORIENTATION_HORIZONTAL);
    gtk_toolbar_set_style (GTK_TOOLBAR (tool_bar), GTK_TOOLBAR_BOTH);	

    r = malloc(sizeof(strc));
    r->widget = draw_area;
    r->p = q;

    status_bar[q->i] = gtk_statusbar_new (); 

    export = gtk_toolbar_append_item(GTK_TOOLBAR(tool_bar),"Export", 
Exemple #10
0
void wxToolBar::GtkSetStyle()
{
    GtkOrientation orient = GTK_ORIENTATION_HORIZONTAL;
    if (HasFlag(wxTB_LEFT | wxTB_RIGHT))
        orient = GTK_ORIENTATION_VERTICAL;

    GtkToolbarStyle style = GTK_TOOLBAR_ICONS;
    if (HasFlag(wxTB_NOICONS))
        style = GTK_TOOLBAR_TEXT;
    else if (HasFlag(wxTB_TEXT))
    {
        style = GTK_TOOLBAR_BOTH;
        if (HasFlag(wxTB_HORZ_LAYOUT))
            style = GTK_TOOLBAR_BOTH_HORIZ;
    }

    gtk_toolbar_set_orientation(m_toolbar, orient);
    gtk_toolbar_set_style(m_toolbar, style);
}
Exemple #11
0
create_statusbar ()void *GtkMain(void * argument)
{
    printf("%s:%d\n", __func__, __LINE__);

    int argc = 0;
    char**argv = NULL;

    unsigned char haveUrl = 0;
    int argCount = 0;
{
    g_main_statusbar = GTK_STATUSBAR (gtk_statusbar_new ());
    gtk_widget_set_can_focus(GTK_WIDGET (g_main_statusbar), false);
    status_context_id = gtk_statusbar_get_context_id (g_main_statusbar, "Link Hover");
    
    return (GtkWidget*)g_main_statusbar;
}

static GtkWidget*
create_toolbar ()
{
    g_toolbar = gtk_toolbar_new ();
    gtk_widget_set_can_focus(GTK_WIDGET (g_toolbar), false);

#if GTK_CHECK_VERSION(2,15,0)
    gtk_orientable_set_orientation (GTK_ORIENTABLE (g_toolbar), GTK_ORIENTATION_HORIZONTAL);
#else
    gtk_toolbar_set_orientation (GTK_TOOLBAR (g_toolbar), GTK_ORIENTATION_HORIZONTAL);
#endif
    gtk_toolbar_set_style (GTK_TOOLBAR (g_toolbar), GTK_TOOLBAR_BOTH_HORIZ);


    /* The URL entry */
    itemUrl = gtk_tool_item_new ();
    gtk_widget_set_can_focus(GTK_WIDGET (itemUrl), false);
    gtk_tool_item_set_expand (itemUrl, TRUE);
    uri_entry = gtk_entry_new ();
    gtk_container_add (GTK_CONTAINER (itemUrl), uri_entry);
    g_signal_connect (G_OBJECT (uri_entry), "activate", G_CALLBACK (activate_uri_entry_cb), NULL);
    gtk_toolbar_insert (GTK_TOOLBAR (g_toolbar), itemUrl, -1);

    return g_toolbar;
}
Exemple #12
0
static GtkWidget*
create_toolbar ()
{
    GtkWidget* toolbar = gtk_toolbar_new ();

#if GTK_CHECK_VERSION(2,15,0)
    gtk_orientable_set_orientation (GTK_ORIENTABLE (toolbar), GTK_ORIENTATION_HORIZONTAL);
#else
    gtk_toolbar_set_orientation (GTK_TOOLBAR (toolbar), GTK_ORIENTATION_HORIZONTAL);
#endif
    gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH_HORIZ);

    GtkToolItem* item;

    /* the back button */
    item = gtk_tool_button_new_from_stock (GTK_STOCK_GO_BACK);
    g_signal_connect (G_OBJECT (item), "clicked", G_CALLBACK (go_back_cb), NULL);
    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);

    /* The forward button */
    item = gtk_tool_button_new_from_stock (GTK_STOCK_GO_FORWARD);
    g_signal_connect (G_OBJECT (item), "clicked", G_CALLBACK (go_forward_cb), NULL);
    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);

    /* The URL entry */
    item = gtk_tool_item_new ();
    gtk_tool_item_set_expand (item, TRUE);
    uri_entry = gtk_entry_new ();
    gtk_container_add (GTK_CONTAINER (item), uri_entry);
    g_signal_connect (G_OBJECT (uri_entry), "activate", G_CALLBACK (activate_uri_entry_cb), NULL);
    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);

    /* The go button */
    item = gtk_tool_button_new_from_stock (GTK_STOCK_OK);
    g_signal_connect_swapped (G_OBJECT (item), "clicked", G_CALLBACK (activate_uri_entry_cb), (gpointer)uri_entry);
    gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1);

    return toolbar;
}
Exemple #13
0
void wxToolBar::GtkSetStyle()
{
    GtkOrientation orient = GTK_ORIENTATION_HORIZONTAL;
    if (HasFlag(wxTB_LEFT | wxTB_RIGHT))
        orient = GTK_ORIENTATION_VERTICAL;

    GtkToolbarStyle style = GTK_TOOLBAR_ICONS;
    if (HasFlag(wxTB_NOICONS))
        style = GTK_TOOLBAR_TEXT;
    else if (HasFlag(wxTB_TEXT))
    {
        style = GTK_TOOLBAR_BOTH;
        if (HasFlag(wxTB_HORZ_LAYOUT))
            style = GTK_TOOLBAR_BOTH_HORIZ;
    }

#if GTK_CHECK_VERSION(3,0,0) || defined(GTK_DISABLE_DEPRECATED)
    gtk_orientable_set_orientation(GTK_ORIENTABLE(m_toolbar), orient);
#else
    gtk_toolbar_set_orientation(m_toolbar, orient);
#endif
    gtk_toolbar_set_style(m_toolbar, style);
}
Exemple #14
0
GtkWidget *hwidget_get_vtoolbar(HviewWidgetsT *w)
{
      GtkWidget		*tbar;
      GtkToolItem	*but;

      tbar = gtk_toolbar_new();

      gtk_toolbar_set_orientation(GTK_TOOLBAR(tbar),
				  GTK_ORIENTATION_VERTICAL);
      gtk_toolbar_set_style(GTK_TOOLBAR(tbar), GTK_TOOLBAR_ICONS);

      but = hwidget_get_tool_button("hide.png", "Hide", "Hide domain list",
		      		    hview_show_hide_domain_call,
				    w,
				    HWIDGET_TOOL_BUTTON);
      gtk_toolbar_insert(GTK_TOOLBAR(tbar), but, -1);

      but = hwidget_get_tool_button("open.png", "Open", "Open new session",
		      		    hview_open_session_call, w,
				    HWIDGET_TOOL_BUTTON);
      gtk_toolbar_insert(GTK_TOOLBAR(tbar), but, -1);

      return tbar;
}
Exemple #15
0
GtkWidget *create_main_toolbar(GtkWidget *parent, MainToolbar *toolbar) {
  GtkWidget *toolbar1;
  GtkWidget *toolbar_newf;
  GtkWidget *toolbar_open;
  GtkWidget *toolbar_save;
  GtkWidget *toolbar_zplus;
  GtkWidget *toolbar_yplus;
  GtkWidget *toolbar_yminus;
  GtkWidget *toolbar_xplus;
  GtkWidget *toolbar_xminus;
  GtkWidget *toolbar_iso;
  GtkWidget *toolbar_target;
  GtkWidget *toolbar_abox;
  GtkWidget *toolbar_apyr;
  GtkWidget *toolbar_atel;
  GtkWidget *toolbar_alnk;
  GtkWidget *toolbar_abas;
  GtkWidget *toolbar_slider;

  GtkTooltips *tooltips;
  GtkWidget *tmp_toolbar_icon;
  GtkAdjustment *sa;

  tooltips = gtk_tooltips_new();

  toolbar1 = gtk_toolbar_new();
  gtk_toolbar_set_orientation(GTK_TOOLBAR(toolbar1), GTK_ORIENTATION_HORIZONTAL);
  gtk_widget_ref(toolbar1);
  gtk_widget_show(toolbar1);

  tmp_toolbar_icon = gtk_image_new_from_stock(GTK_STOCK_NEW, GTK_ICON_SIZE_SMALL_TOOLBAR);
  toolbar_newf = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, NULL, _("Create a new BZFlag world"), NULL, tmp_toolbar_icon, NULL, NULL);
  gtk_widget_ref(toolbar_newf);
  gtk_widget_show(toolbar_newf);

  tmp_toolbar_icon = gtk_image_new_from_stock(GTK_STOCK_OPEN, GTK_ICON_SIZE_SMALL_TOOLBAR);
  toolbar_open = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, NULL, _("Open a BZFlag world"), NULL, tmp_toolbar_icon, NULL, NULL);
  gtk_widget_ref(toolbar_open);
  gtk_widget_show(toolbar_open);

  tmp_toolbar_icon = gtk_image_new_from_stock(GTK_STOCK_SAVE, GTK_ICON_SIZE_SMALL_TOOLBAR);
  toolbar_save = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, NULL, _("Save the current world"), NULL, tmp_toolbar_icon, NULL, NULL);
  gtk_widget_ref(toolbar_save);
  gtk_widget_show(toolbar_save);

  gtk_toolbar_append_space(GTK_TOOLBAR(toolbar1));

  tmp_toolbar_icon = gnome_pixmap_new_from_xpm_d(TB::zplus_xpm);
  toolbar_zplus = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, NULL, _("View from above"), NULL, tmp_toolbar_icon, NULL, NULL);
  gtk_widget_ref(toolbar_zplus);
  gtk_widget_show(toolbar_zplus);

  gtk_toolbar_append_space(GTK_TOOLBAR(toolbar1));

  tmp_toolbar_icon = gnome_pixmap_new_from_xpm_d(TB::yplus_xpm);
  toolbar_yplus = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, NULL, _("View from +Y"), NULL, tmp_toolbar_icon, NULL, NULL);
  gtk_widget_ref(toolbar_yplus);
  gtk_widget_show(toolbar_yplus);

  tmp_toolbar_icon = gnome_pixmap_new_from_xpm_d(TB::yminus_xpm);
  toolbar_yminus = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, NULL, _("View from -Y"), NULL, tmp_toolbar_icon, NULL, NULL);
  gtk_widget_ref(toolbar_yminus);
  gtk_widget_show(toolbar_yminus);

  gtk_toolbar_append_space(GTK_TOOLBAR(toolbar1));

  tmp_toolbar_icon = gnome_pixmap_new_from_xpm_d(TB::xplus_xpm);
  toolbar_xplus = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, NULL, _("View from +X"), NULL, tmp_toolbar_icon, NULL, NULL);
  gtk_widget_ref(toolbar_xplus);
  gtk_widget_show(toolbar_xplus);

  tmp_toolbar_icon = gnome_pixmap_new_from_xpm_d(TB::xminus_xpm);
  toolbar_xminus = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, NULL, _("View from -X"), NULL, tmp_toolbar_icon, NULL, NULL);
  gtk_widget_ref(toolbar_xminus);
  gtk_widget_show(toolbar_xminus);

  gtk_toolbar_append_space(GTK_TOOLBAR(toolbar1));

  tmp_toolbar_icon = gnome_pixmap_new_from_xpm_d(TB::iso_xpm);
  toolbar_iso = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, NULL, _("Isometric view"), NULL, tmp_toolbar_icon, NULL, NULL);
  gtk_widget_ref(toolbar_iso);
  gtk_widget_show(toolbar_iso);

  gtk_toolbar_append_space(GTK_TOOLBAR(toolbar1));

  tmp_toolbar_icon = gnome_pixmap_new_from_xpm_d(TB::target_xpm);
  toolbar_target = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, NULL, _("Center view on (0, 0, 0)"), NULL, tmp_toolbar_icon, NULL, NULL);
  gtk_widget_ref(toolbar_target);
  gtk_widget_show(toolbar_target);

  gtk_toolbar_append_space(GTK_TOOLBAR(toolbar1));

  tmp_toolbar_icon = gnome_pixmap_new_from_xpm_d(TB::addbox_xpm);
  toolbar_abox = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, NULL, _("Add a box"), NULL, tmp_toolbar_icon, NULL, NULL);
  gtk_widget_ref(toolbar_abox);
  gtk_widget_show(toolbar_abox);

  tmp_toolbar_icon = gnome_pixmap_new_from_xpm_d(TB::addpyr_xpm);
  toolbar_apyr = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, NULL, _("Add a pyramid"), NULL, tmp_toolbar_icon, NULL, NULL);
  gtk_widget_ref(toolbar_apyr);
  gtk_widget_show(toolbar_apyr);

  tmp_toolbar_icon = gnome_pixmap_new_from_xpm_d(TB::addtele_xpm);
  toolbar_atel = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, NULL, _("Add a teleporter"), NULL, tmp_toolbar_icon, NULL, NULL);
  gtk_widget_ref(toolbar_atel);
  gtk_widget_show(toolbar_atel);
 
  tmp_toolbar_icon = gnome_pixmap_new_from_xpm_d(TB::addlink_xpm);
  toolbar_alnk = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, NULL, _("Add a link"), NULL, tmp_toolbar_icon, NULL, NULL);
  gtk_widget_ref(toolbar_alnk);
  gtk_widget_show(toolbar_alnk);
 
  tmp_toolbar_icon = gnome_pixmap_new_from_xpm_d(TB::addbase_xpm);
  toolbar_abas = gtk_toolbar_append_element(GTK_TOOLBAR(toolbar1), GTK_TOOLBAR_CHILD_BUTTON, NULL, NULL, _("Add a base"), NULL, tmp_toolbar_icon, NULL, NULL);
  gtk_widget_ref(toolbar_abas);
  gtk_widget_show(toolbar_abas);

  sa = GTK_ADJUSTMENT(gtk_adjustment_new(100.0, 0.0, 100.0, 1.0, 10.0, 0.0));
  toolbar_slider = gtk_hscale_new(sa);
  gtk_widget_set_size_request(toolbar_slider, 75, -1);
  gtk_scale_set_draw_value(GTK_SCALE(toolbar_slider), FALSE);
  gtk_toolbar_append_widget(GTK_TOOLBAR(toolbar1), toolbar_slider, NULL, NULL);
  gtk_tooltips_set_tip(GTK_TOOLTIPS(tooltips), toolbar_slider, _("Transparency"), NULL);
  gtk_widget_ref(toolbar_slider);
  gtk_widget_show(toolbar_slider);

  gtk_signal_connect(GTK_OBJECT(toolbar_newf), "clicked", GTK_SIGNAL_FUNC(CB::MW::newf), NULL);
  gtk_signal_connect(GTK_OBJECT(toolbar_open), "clicked", GTK_SIGNAL_FUNC(CB::MW::open), NULL);
  gtk_signal_connect(GTK_OBJECT(toolbar_save), "clicked", GTK_SIGNAL_FUNC(CB::MW::save), NULL);
  gtk_signal_connect(GTK_OBJECT(toolbar_zplus), "clicked", GTK_SIGNAL_FUNC(CB::MW::tb_zplus), NULL);
  gtk_signal_connect(GTK_OBJECT(toolbar_yplus), "clicked", GTK_SIGNAL_FUNC(CB::MW::tb_yplus), NULL);
  gtk_signal_connect(GTK_OBJECT(toolbar_yminus), "clicked", GTK_SIGNAL_FUNC(CB::MW::tb_yminus), NULL);
  gtk_signal_connect(GTK_OBJECT(toolbar_xplus), "clicked", GTK_SIGNAL_FUNC(CB::MW::tb_xplus), NULL);
  gtk_signal_connect(GTK_OBJECT(toolbar_xminus), "clicked", GTK_SIGNAL_FUNC(CB::MW::tb_xminus), NULL);
  gtk_signal_connect(GTK_OBJECT(toolbar_iso), "clicked", GTK_SIGNAL_FUNC(CB::MW::tb_iso), NULL);
  gtk_signal_connect(GTK_OBJECT(toolbar_target), "clicked", GTK_SIGNAL_FUNC(CB::MW::tb_target), NULL);
  gtk_signal_connect(GTK_OBJECT(toolbar_abox), "clicked", GTK_SIGNAL_FUNC(CB::MW::tb_addbox), NULL);
  gtk_signal_connect(GTK_OBJECT(toolbar_apyr), "clicked", GTK_SIGNAL_FUNC(CB::MW::tb_addpyr), NULL);
  gtk_signal_connect(GTK_OBJECT(toolbar_atel), "clicked", GTK_SIGNAL_FUNC(CB::MW::tb_addtel), NULL);
  gtk_signal_connect(GTK_OBJECT(toolbar_alnk), "clicked", GTK_SIGNAL_FUNC(CB::MW::tb_addlnk), NULL);
  gtk_signal_connect(GTK_OBJECT(toolbar_abas), "clicked", GTK_SIGNAL_FUNC(CB::MW::tb_addbas), NULL);
  gtk_signal_connect(GTK_OBJECT(sa), "value_changed", GTK_SIGNAL_FUNC(CB::MW::tb_trans), NULL);
  gtk_signal_connect(GTK_OBJECT(sa), "changed", GTK_SIGNAL_FUNC(CB::MW::tb_trans), NULL);

  toolbar->toolbar = toolbar1;
  toolbar->newf = toolbar_newf;
  toolbar->open = toolbar_open;
  toolbar->save = toolbar_save;
  toolbar->zplus = toolbar_zplus;
  toolbar->yplus = toolbar_yplus;
  toolbar->yminus = toolbar_yminus;
  toolbar->xplus = toolbar_xplus;
  toolbar->xminus = toolbar_xminus;
  toolbar->iso = toolbar_iso;
  toolbar->target = toolbar_target;
  toolbar->abox = toolbar_abox;
  toolbar->apyr = toolbar_apyr;
  toolbar->atel = toolbar_atel;
  toolbar->alnk = toolbar_alnk;
  toolbar->abas = toolbar_abas;
  toolbar->slider = toolbar_slider;

  return toolbar1;
}
Exemple #16
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);
}
void create_vector_table_options_dialog (vector_table_options_D *dialog)
  {
  GtkWidget *tbl = NULL, *toolbar = NULL, *btn = NULL, *btnBaseRadioSource = NULL ;
  GtkAccelGroup *accel_group = NULL ;
  GtkTreeViewColumn *col = NULL ;
  GtkCellRenderer *cr = NULL ;

  accel_group = gtk_accel_group_new () ;

  dialog->dialog = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_modal (GTK_WINDOW (dialog->dialog), TRUE);
  gtk_window_set_title (GTK_WINDOW (dialog->dialog), _("Vector Table Setup"));
  gtk_window_set_resizable (GTK_WINDOW (dialog->dialog), TRUE) ;
  g_object_set_data (G_OBJECT (dialog->dialog), "dialog", dialog) ;

  tbl = gtk_table_new (2, 1, FALSE) ;
  gtk_widget_show (tbl) ;
  gtk_container_add (GTK_CONTAINER (dialog->dialog), tbl) ;

  toolbar = gtk_toolbar_new () ;
  gtk_widget_show (toolbar) ;
  gtk_table_attach (GTK_TABLE (tbl), toolbar, 0, 1, 0, 1,
    (GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
    (GtkAttachOptions)(GTK_FILL), 0, 0) ;
  gtk_toolbar_set_orientation (GTK_TOOLBAR (toolbar), GTK_ORIENTATION_HORIZONTAL) ;
  gtk_toolbar_set_tooltips (GTK_TOOLBAR (toolbar), TRUE) ;
  gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH) ;

  g_object_set_data (G_OBJECT (btn = gtk_toolbar_append_element (
    GTK_TOOLBAR (toolbar),
    GTK_TOOLBAR_CHILD_BUTTON,
    NULL,
    _("Close"),
    _("Close Window"),
    _("Close vector table editor."),
    gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_LARGE_TOOLBAR),
    (GCallback)vector_table_options_dialog_btnClose_clicked,
    NULL)),
  "dialog", dialog) ;
	gtk_widget_add_accelerator (btn, "clicked", accel_group, GDK_w, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE) ;

  gtk_toolbar_append_space (GTK_TOOLBAR (toolbar)) ;

#ifdef STDIO_FILEIO
  dialog->btnOpen =
  btn = gtk_toolbar_append_element (
    GTK_TOOLBAR (toolbar),
    GTK_TOOLBAR_CHILD_BUTTON,
    NULL,
    _("Open"),
    _("Open Vector Table"),
    _("Open and display another vector table."),
    gtk_image_new_from_stock (GTK_STOCK_OPEN, GTK_ICON_SIZE_LARGE_TOOLBAR),
    (GCallback)vector_table_options_dialog_btnOpen_clicked,
    dialog) ;
	gtk_widget_add_accelerator (btn, "clicked", accel_group, GDK_o, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE) ;

  dialog->btnSave =
  btn = gtk_toolbar_append_element (
    GTK_TOOLBAR (toolbar),
    GTK_TOOLBAR_CHILD_BUTTON,
    NULL,
    _("Save"),
    _("Save Vector Table"),
    _("Save the displayed vector table."),
    gtk_image_new_from_stock (GTK_STOCK_SAVE, GTK_ICON_SIZE_LARGE_TOOLBAR),
    (GCallback)vector_table_options_dialog_btnSave_clicked,
    dialog->dialog) ;
	gtk_widget_add_accelerator (btn, "clicked", accel_group, GDK_s, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE) ;
#endif /* def STDIO_FILEIO */

  gtk_toolbar_append_space (GTK_TOOLBAR (toolbar)) ;

  g_object_set_data (G_OBJECT (
    dialog->tbtnExhaustive =
    btnBaseRadioSource = gtk_toolbar_append_element (
      GTK_TOOLBAR (toolbar),
      GTK_TOOLBAR_CHILD_RADIOBUTTON,
      NULL,
      _("Exhaustive"),
      _("Exhaustive Verification"),
      _("Attempt all possible inputs."),
      gtk_image_new_from_stock (GTK_STOCK_YES, GTK_ICON_SIZE_LARGE_TOOLBAR),
      (GCallback)vector_table_options_dialog_btnSimType_clicked,
      dialog)),
    "sim_type", (gpointer)EXHAUSTIVE_VERIFICATION) ;

  g_object_set_data (G_OBJECT (
    dialog->tbtnVT =
    gtk_toolbar_append_element (
      GTK_TOOLBAR (toolbar),
      GTK_TOOLBAR_CHILD_RADIOBUTTON,
      btnBaseRadioSource,
      _("Vector Table"),
      _("Vector Table Simulation"),
      _("Create a sequence of inputs."),
      gtk_image_new_from_stock (GTK_STOCK_NO, GTK_ICON_SIZE_LARGE_TOOLBAR),
      (GCallback)vector_table_options_dialog_btnSimType_clicked,
      dialog)),
    "sim_type", (gpointer)VECTOR_TABLE) ;

  dialog->tblVT = gtk_table_new (1, 2, FALSE) ;
  gtk_widget_show (dialog->tblVT) ;
  gtk_table_attach (GTK_TABLE (tbl), dialog->tblVT, 0, 1, 1, 2,
    (GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
    (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0) ;

  toolbar = gtk_toolbar_new () ;
  gtk_widget_show (toolbar) ;
  gtk_table_attach (GTK_TABLE (dialog->tblVT), toolbar, 0, 1, 0, 1,
    (GtkAttachOptions)(GTK_FILL),
    (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 0, 0) ;
  gtk_toolbar_set_orientation (GTK_TOOLBAR (toolbar), GTK_ORIENTATION_VERTICAL) ;
  gtk_toolbar_set_tooltips (GTK_TOOLBAR (toolbar), TRUE) ;
  gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS) ;

  dialog->btnAdd =
  btn = gtk_toolbar_append_element (
    GTK_TOOLBAR (toolbar),
    GTK_TOOLBAR_CHILD_BUTTON,
    NULL,
    _("Add"),
    _("Add Vector"),
    _("Apend a vector to the end of the table."),
    gtk_image_new_from_stock (GTK_STOCK_ADD, GTK_ICON_SIZE_LARGE_TOOLBAR),
    (GCallback)vector_table_options_dialog_btnAdd_clicked,
    dialog->dialog) ;

  dialog->btnInsert =
  btn = gtk_toolbar_append_element (
    GTK_TOOLBAR (toolbar),
    GTK_TOOLBAR_CHILD_BUTTON,
    NULL,
    _("Insert Before"),
    _("Insert Vector Before"),
    _("Insert vector before the selected one."),
    gtk_image_new_from_stock (QCAD_STOCK_INSERT_COL_BEFORE, GTK_ICON_SIZE_LARGE_TOOLBAR),
    (GCallback)vector_table_options_dialog_btnAdd_clicked,
    dialog->dialog) ;

  dialog->btnDelete =
  btn = gtk_toolbar_append_element (
    GTK_TOOLBAR (toolbar),
    GTK_TOOLBAR_CHILD_BUTTON,
    NULL,
    _("Delete Vector"),
    _("Delete Vector"),
    _("Insert the selected vector."),
    gtk_image_new_from_stock (GTK_STOCK_DELETE, GTK_ICON_SIZE_LARGE_TOOLBAR),
    (GCallback)vector_table_options_dialog_btnDelete_clicked,
    dialog->dialog) ;

  dialog->sw = qcad_tree_view_container_new () ;
  gtk_widget_show (dialog->sw) ;
  gtk_table_attach (GTK_TABLE (dialog->tblVT), dialog->sw, 1, 2, 0, 1,
    (GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
    (GtkAttachOptions)(GTK_EXPAND | GTK_FILL), 2, 2) ;
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (dialog->sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC) ;
  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (dialog->sw), GTK_SHADOW_IN) ;

  dialog->tv = create_bus_layout_tree_view (TRUE, _("Inputs"), GTK_SELECTION_SINGLE) ;
  gtk_tree_view_append_column (GTK_TREE_VIEW (dialog->tv), col = gtk_tree_view_column_new ()) ;
  gtk_tree_view_column_set_title (col, _("Active")) ;
  gtk_tree_view_column_pack_start (col, cr = dialog->crActive = gtk_cell_renderer_toggle_new (), TRUE) ;
  gtk_tree_view_column_add_attribute (col, cr, "active", VECTOR_TABLE_MODEL_COLUMN_ACTIVE) ;
  g_object_set (G_OBJECT (cr), "activatable", TRUE, NULL) ;
  gtk_cell_renderer_toggle_set_active (GTK_CELL_RENDERER_TOGGLE (cr), TRUE) ;
  gtk_widget_show (dialog->tv) ;
  gtk_container_add (GTK_CONTAINER (dialog->sw), dialog->tv) ;
  qcad_tree_view_container_freeze_columns (QCAD_TREE_VIEW_CONTAINER (dialog->sw), 2) ;

  g_signal_connect (G_OBJECT (dialog->tv),     "style-set",    (GCallback)tree_view_style_set,                          NULL) ;
  g_signal_connect (G_OBJECT (cr),             "toggled",      (GCallback)vt_model_active_toggled,                      dialog->tv) ;
  g_signal_connect (G_OBJECT (dialog->dialog), "delete-event", (GCallback)vector_table_options_dialog_btnClose_clicked, NULL) ;

  gtk_window_add_accel_group (GTK_WINDOW (dialog->dialog), accel_group) ;
  }
CChartDlg::CChartDlg(GtkWindow *pParent):m_pParent(pParent), m_ChartData(NULL), m_ImageData(NULL)
{
	GtkWidget *scrwnd, *tbox;
	GdkRectangle rc;

	m_DisplayMode = (tDisplayMode)g_Project->GetInt("ChartDlg", "Mode", DISPLAY_IMAGE, 0, DISPLAY_FULL);
	m_Negative = CConfig::GetBool(CConfig::NEGATIVE_CHARTS);
	m_RowsUpward = CConfig::GetBool(CConfig::ROWS_UPWARD);

	// Dialog with buttons
	m_pDlg = gtk_dialog_new_with_buttons("Chart", pParent, 
		(GtkDialogFlags)(GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_NO_SEPARATOR),
		GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE, GTK_STOCK_SAVE, GTK_RESPONSE_NONE, 
		GTK_STOCK_HELP, GTK_RESPONSE_HELP, NULL);
	gtk_dialog_widget_standard_tooltips(GTK_DIALOG(m_pDlg));
	gtk_dialog_set_tooltip_by_response(GTK_DIALOG(m_pDlg), GTK_RESPONSE_NONE, "Export the chart to a file");
	g_signal_connect(G_OBJECT(m_pDlg), "response", G_CALLBACK(response_dialog), this);

	// Dialog icon
	gchar *icon = get_icon_file("muniwin");
	gtk_window_set_icon(GTK_WINDOW(m_pDlg), gdk_pixbuf_new_from_file(icon, NULL));
	g_free(icon);

	// Dialog size
	GdkScreen *scr = gtk_window_get_screen(pParent);
	int mon = gdk_screen_get_monitor_at_window(scr, GTK_WIDGET(pParent)->window);
	gdk_screen_get_monitor_geometry(scr, mon, &rc);
	if (rc.width>0 && rc.height>0)
		gtk_window_set_default_size(GTK_WINDOW(m_pDlg), RoundToInt(0.7*rc.width), RoundToInt(0.7*rc.height));

	// Toolbar
	tbox = gtk_toolbar_new();
	gtk_toolbar_set_style(GTK_TOOLBAR(tbox), GTK_TOOLBAR_ICONS);
	gtk_toolbar_set_orientation(GTK_TOOLBAR(tbox), GTK_ORIENTATION_HORIZONTAL);
	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(m_pDlg)->vbox), tbox, FALSE, FALSE, 0);

	m_ViewLabel = toolbar_new_label(tbox, "View");
	m_ShowImage = toolbar_new_radio_button(tbox, NULL, "Image", "Display an image only");
	g_signal_connect(G_OBJECT(m_ShowImage), "toggled", G_CALLBACK(button_clicked), this);
	m_ShowChart = toolbar_new_radio_button(tbox, m_ShowImage, "Chart", "Display objects on a flat background");
	g_signal_connect(G_OBJECT(m_ShowChart), "toggled", G_CALLBACK(button_clicked), this);
	m_ShowMixed = toolbar_new_radio_button(tbox, m_ShowImage, "Mixed", "Display objects over an image");
	g_signal_connect(G_OBJECT(m_ShowMixed), "toggled", G_CALLBACK(button_clicked), this);

	toolbar_new_separator(tbox);

	toolbar_new_label(tbox, "Zoom");
	m_ZoomFit = toolbar_new_button_from_stock(tbox, GTK_STOCK_ZOOM_FIT, "Fit the frame to the window");
	g_signal_connect(G_OBJECT(m_ZoomFit), "clicked", G_CALLBACK(button_clicked), this);
	m_ZoomOut = toolbar_new_button_from_stock(tbox, GTK_STOCK_ZOOM_OUT, "Zoom out");
	g_signal_connect(G_OBJECT(m_ZoomOut), "clicked", G_CALLBACK(button_clicked), this);
	m_ZoomIn = toolbar_new_button_from_stock(tbox, GTK_STOCK_ZOOM_IN, "Zoom in");
	g_signal_connect(G_OBJECT(m_ZoomIn), "clicked", G_CALLBACK(button_clicked), this);

	// Chart
	m_Chart = cmpack_chart_view_new();
	scrwnd = gtk_scrolled_window_new(NULL, NULL);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrwnd), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scrwnd), GTK_SHADOW_ETCHED_IN);
	gtk_container_add(GTK_CONTAINER(scrwnd), m_Chart);
	gtk_widget_set_size_request(m_Chart, 300, 200);
	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(m_pDlg)->vbox), scrwnd, TRUE, TRUE, 0);

	gtk_widget_show_all(GTK_DIALOG(m_pDlg)->vbox);
}
Exemple #19
0
int WebBrowserObject::BrowserOpen(void)
{
    Lock();
    if (!area.w) {
        area.w = systemObject->configGetInt("video_width", systemObject->GetScreenWidth());
    }
    if (!area.h) {
        area.h = systemObject->configGetInt("video_height", systemObject->GetScreenHeight());
    }
    if (!toplevel) {
        toplevel = gtk_window_new(GTK_WINDOW_TOPLEVEL);
        gtk_widget_realize(toplevel);
        gdk_window_set_decorations(toplevel->window, (GdkWMDecoration)0);
        toplevelVBox = gtk_vbox_new(FALSE, 0);
        gtk_container_add(GTK_CONTAINER(toplevel), toplevelVBox);

        mozilla = gtk_moz_embed_new();
        gtk_moz_embed_set_chrome_mask(GTK_MOZ_EMBED(mozilla), GTK_MOZ_EMBED_FLAG_ALLCHROME);

        toolbarHBox = gtk_hbox_new(FALSE, 0);
        gtk_box_pack_start(GTK_BOX(toplevelVBox), toolbarHBox, FALSE, FALSE, 0);
        toolbar = gtk_toolbar_new();
        g_object_ref(toolbar);
        gtk_toolbar_set_orientation(GTK_TOOLBAR(toolbar), GTK_ORIENTATION_HORIZONTAL);
        gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_BOTH);
        if (toolbar_flag) {
            gtk_box_pack_start(GTK_BOX(toolbarHBox), toolbar, FALSE, FALSE, 0);
        }
        backButton = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Back", "Go Back", "Go Back", 0, GTK_SIGNAL_FUNC(back_clicked_cb), this);
        stopButton = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Stop", "Stop", "Stop", 0, GTK_SIGNAL_FUNC(stop_clicked_cb), this);
        forwardButton = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Forward", "Forward", "Forward", 0, GTK_SIGNAL_FUNC(forward_clicked_cb), this);
        reloadButton = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Reload", "Reload", "Reload", 0, GTK_SIGNAL_FUNC(reload_clicked_cb), this);
        closeButton = gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), "Close", "Close window", "Close window", 0, GTK_SIGNAL_FUNC(close_clicked_cb), this);
        urlEntry = gtk_entry_new();
        g_object_ref(urlEntry);
        if (toolbar_flag) {
            gtk_box_pack_start(GTK_BOX(toolbarHBox), urlEntry, TRUE, TRUE, 0);
        }
        gtk_box_pack_start(GTK_BOX(toplevelVBox), mozilla, TRUE, TRUE, 0);
        progressAreaHBox = gtk_hbox_new(FALSE, 0);
        gtk_box_pack_start(GTK_BOX(toplevelVBox), progressAreaHBox, FALSE, FALSE, 0);
        progressBar = gtk_progress_bar_new();
        gtk_box_pack_start(GTK_BOX(progressAreaHBox), progressBar, FALSE, FALSE, 0);
        statusAlign = gtk_alignment_new(0, 0, 1, 1);
        gtk_widget_set_usize(statusAlign, 1, -1);
        statusBar = gtk_statusbar_new();
        gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(statusBar), 0);
        gtk_container_add(GTK_CONTAINER(statusAlign), statusBar);
        gtk_box_pack_start(GTK_BOX(progressAreaHBox), statusAlign, TRUE, TRUE, 0);

        gtk_widget_set_sensitive(closeButton, TRUE);
        gtk_widget_set_sensitive(backButton, FALSE);
        gtk_widget_set_sensitive(stopButton, FALSE);
        gtk_widget_set_sensitive(forwardButton, FALSE);
        gtk_widget_set_sensitive(reloadButton, FALSE);

        gtk_signal_connect(GTK_OBJECT(urlEntry), "activate", GTK_SIGNAL_FUNC(url_activate_cb), this);
        
        gtk_signal_connect(GTK_OBJECT(toplevel), "delete_event", GTK_SIGNAL_FUNC(delete_cb), this);
        gtk_signal_connect(GTK_OBJECT(mozilla), "destroy", GTK_SIGNAL_FUNC(destroy_cb), this);
        gtk_signal_connect(GTK_OBJECT(mozilla), "destroy_browser", GTK_SIGNAL_FUNC(destroy_cb), this);
        gtk_signal_connect(GTK_OBJECT(mozilla), "title", GTK_SIGNAL_FUNC(title_changed_cb), this);
        gtk_signal_connect(GTK_OBJECT(mozilla), "new_window", GTK_SIGNAL_FUNC(new_window_cb), this);
        gtk_signal_connect(GTK_OBJECT(mozilla), "visibility", GTK_SIGNAL_FUNC(visibility_cb), this);
        gtk_signal_connect(GTK_OBJECT(mozilla), "size_to", GTK_SIGNAL_FUNC(size_to_cb), this);
        gtk_signal_connect(GTK_OBJECT(mozilla), "location", GTK_SIGNAL_FUNC(location_cb), this);
        gtk_signal_connect(GTK_OBJECT(mozilla), "net_start", GTK_SIGNAL_FUNC(net_start_cb), this);
        gtk_signal_connect(GTK_OBJECT(mozilla), "net_stop", GTK_SIGNAL_FUNC(net_stop_cb), this);
        gtk_signal_connect(GTK_OBJECT(mozilla), "net_state",  GTK_SIGNAL_FUNC(net_state_cb), this);
        gtk_signal_connect(GTK_OBJECT(mozilla), "progress", GTK_SIGNAL_FUNC(progress_cb), this);
        gtk_signal_connect(GTK_OBJECT(mozilla), "link_message", GTK_SIGNAL_FUNC(link_message_cb), this);
        gtk_signal_connect(GTK_OBJECT(mozilla), "js_status", GTK_SIGNAL_FUNC(js_status_cb), this);
        gtk_signal_connect(GTK_OBJECT(mozilla), "open_uri", GTK_SIGNAL_FUNC(open_uri_cb), this);
        gtk_signal_connect(GTK_OBJECT(mozilla), "dom_key_down", GTK_SIGNAL_FUNC(dom_key_down_cb), this);
        gtk_signal_connect(GTK_OBJECT(mozilla), "dom_key_up", GTK_SIGNAL_FUNC(dom_key_up_cb), this);
        gtk_signal_connect(GTK_OBJECT(mozilla), "dom_mouse_down", GTK_SIGNAL_FUNC(dom_mouse_down_cb), this);
        gtk_signal_connect(GTK_OBJECT(mozilla), "dom_mouse_up", GTK_SIGNAL_FUNC(dom_mouse_up_cb), this);
        gtk_signal_connect(GTK_OBJECT(mozilla), "dom_key_press", GTK_SIGNAL_FUNC(dom_key_press_cb), this);
        gtk_signal_connect(GTK_OBJECT(mozilla), "dom_mouse_click", GTK_SIGNAL_FUNC(dom_mouse_click_cb), this);
        gtk_signal_connect(GTK_OBJECT(mozilla), "dom_mouse_dbl_click", GTK_SIGNAL_FUNC(dom_mouse_dbl_click_cb), this);
        gtk_signal_connect(GTK_OBJECT(mozilla), "dom_mouse_over", GTK_SIGNAL_FUNC(dom_mouse_over_cb), this);
        gtk_signal_connect(GTK_OBJECT(mozilla), "dom_mouse_out", GTK_SIGNAL_FUNC(dom_mouse_out_cb), this);
    }
    Unlock();
    SetPosition(area.x, area.y, area.w, area.h);
    SetVisible(1);
    if (location) {
        gtk_moz_embed_load_url(GTK_MOZ_EMBED(mozilla), location);
    }
    systemObject->RegisterExternalEventHandler(this);
    return 0;
}
Exemple #20
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);
}
Exemple #21
0
void GUI_CreateSpeedDialWindow(void)
{
	int nmenu_items = sizeof(menu_items) / sizeof(menu_items[0]);
	GtkItemFactory *item_factory;
	GtkAccelGroup *accel_group;
	SortColumn *sColumn;
	GtkWidget *menubar;
	GtkWidget *main_vbox;
	GtkWidget *toolbar;
	GtkWidget *clistScrolledWindow;
	register gint i;
	gchar *titles[3] = { _("Key"), _("Name"), _("Number") };


	InitMainMenu();
	GUI_SpeedDialWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_wmclass(GTK_WINDOW(GUI_SpeedDialWindow), "SpeedDialWindow", "Xgnokii");
	gtk_window_set_title(GTK_WINDOW(GUI_SpeedDialWindow), _("Speed Dial"));
	gtk_widget_set_usize(GTK_WIDGET(GUI_SpeedDialWindow), 350, 220);
	//gtk_container_set_border_width (GTK_CONTAINER (GUI_SpeedDialWindow), 10);
	gtk_signal_connect(GTK_OBJECT(GUI_SpeedDialWindow), "delete_event",
			   GTK_SIGNAL_FUNC(DeleteEvent), NULL);
	gtk_widget_realize(GUI_SpeedDialWindow);

	accel_group = gtk_accel_group_new();
	item_factory = gtk_item_factory_new(GTK_TYPE_MENU_BAR, "<main>", accel_group);

	gtk_item_factory_create_items(item_factory, nmenu_items, menu_items, NULL);

	gtk_window_add_accel_group(GTK_WINDOW(GUI_SpeedDialWindow), accel_group);

	/* Finally, return the actual menu bar created by the item factory. */
	menubar = gtk_item_factory_get_widget(item_factory, "<main>");

	main_vbox = gtk_vbox_new(FALSE, 1);
	gtk_container_border_width(GTK_CONTAINER(main_vbox), 1);
	gtk_container_add(GTK_CONTAINER(GUI_SpeedDialWindow), main_vbox);
	gtk_widget_show(main_vbox);

	gtk_box_pack_start(GTK_BOX(main_vbox), menubar, FALSE, FALSE, 0);
	gtk_widget_show(menubar);

	/* Create the toolbar */

	toolbar = gtk_toolbar_new();
	gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);
	gtk_toolbar_set_orientation(GTK_TOOLBAR(toolbar), GTK_ORIENTATION_HORIZONTAL);

	gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), NULL, _("Read from phone"), NULL,
				NewPixmap(Read_xpm, GUI_SpeedDialWindow->window,
					  &GUI_SpeedDialWindow->style->bg[GTK_STATE_NORMAL]),
				(GtkSignalFunc) ReadSpeedDial, NULL);
	gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), NULL, _("Save to phone"), NULL,
				NewPixmap(Send_xpm, GUI_SpeedDialWindow->window,
					  &GUI_SpeedDialWindow->style->bg[GTK_STATE_NORMAL]),
				(GtkSignalFunc) SaveSpeedDial, NULL);

	gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));

	gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), NULL, _("Import from file"), NULL,
				NewPixmap(Open_xpm, GUI_SpeedDialWindow->window,
					  &GUI_SpeedDialWindow->style->bg[GTK_STATE_NORMAL]),
				(GtkSignalFunc) ImportSpeedDial, NULL);
	gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), NULL, _("Export to file"), NULL,
				NewPixmap(Save_xpm, GUI_SpeedDialWindow->window,
					  &GUI_SpeedDialWindow->style->bg[GTK_STATE_NORMAL]),
				(GtkSignalFunc) ExportSpeedDial, NULL);

	gtk_toolbar_append_space(GTK_TOOLBAR(toolbar));

	gtk_toolbar_append_item(GTK_TOOLBAR(toolbar), NULL, _("Edit entry"), NULL,
				NewPixmap(Edit_xpm, GUI_SpeedDialWindow->window,
					  &GUI_SpeedDialWindow->style->bg[GTK_STATE_NORMAL]),
				(GtkSignalFunc) EditKey, NULL);

	gtk_box_pack_start(GTK_BOX(main_vbox), toolbar, FALSE, FALSE, 0);
	gtk_widget_show(toolbar);

	clist = gtk_clist_new_with_titles(3, titles);
	gtk_clist_set_shadow_type(GTK_CLIST(clist), GTK_SHADOW_OUT);
//  gtk_clist_set_compare_func (GTK_CLIST (clist), CListCompareFunc);
	gtk_clist_set_sort_column(GTK_CLIST(clist), 0);
	gtk_clist_set_sort_type(GTK_CLIST(clist), GTK_SORT_ASCENDING);
	gtk_clist_set_auto_sort(GTK_CLIST(clist), FALSE);
	//gtk_clist_set_selection_mode (GTK_CLIST (clist), GTK_SELECTION_EXTENDED);

	gtk_clist_set_column_width(GTK_CLIST(clist), 1, 150);
	gtk_clist_set_column_width(GTK_CLIST(clist), 2, 115);
	gtk_clist_set_column_justification(GTK_CLIST(clist), 0, GTK_JUSTIFY_CENTER);
//  gtk_clist_set_column_visibility (GTK_CLIST (clist), 3, xgnokiiConfig.callerGroupsSupported);

	for (i = 0; i < 3; i++) {
		if ((sColumn = g_malloc(sizeof(SortColumn))) == NULL) {
			g_print(_("Error: %s: line %d: Can't allocate memory!\n"), __FILE__, __LINE__);
			gtk_main_quit();
		}
		sColumn->clist = clist;
		sColumn->column = i;
		gtk_signal_connect(GTK_OBJECT(GTK_CLIST(clist)->column[i].button), "clicked",
				   GTK_SIGNAL_FUNC(SetSortColumn), (gpointer) sColumn);
	}

	gtk_signal_connect(GTK_OBJECT(clist), "select_row", GTK_SIGNAL_FUNC(ClickEntry), NULL);

	clistScrolledWindow = gtk_scrolled_window_new(NULL, NULL);
	gtk_container_add(GTK_CONTAINER(clistScrolledWindow), clist);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(clistScrolledWindow),
				       GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	gtk_box_pack_start(GTK_BOX(main_vbox), clistScrolledWindow, TRUE, TRUE, 0);

	gtk_widget_show(clist);
	gtk_widget_show(clistScrolledWindow);

	questMark.pixmap = gdk_pixmap_create_from_xpm_d(GUI_SpeedDialWindow->window,
							&questMark.mask,
							&GUI_SpeedDialWindow->style->
							bg[GTK_STATE_NORMAL], quest_xpm);

	CreateErrorDialog(&errorDialog, GUI_SpeedDialWindow);
	CreateInfoDialog(&infoDialog, GUI_SpeedDialWindow);
	speedDialInitialized = FALSE;
}
Exemple #22
0
GtkWidget *merge_dialog_new (merge_dialog_struct *mrg,
	gboolean hide_control,
	GtkWidget *parent_window,
	gchar *frame_title,
	gchar *source_title,
	gchar *result_title,
	gchar *mix_title) {
//	Standard controls for merging the source HF with the result of a transformation

	GtkWidget *frame, *frame2, *vbox,  *table, *hbox, *button, *scale, *but1, *but2, *but3, *but4, *but5, *but6;
	GtkObject *adj;

//	Titles default to predefined values when NULL
	if (!source_title)
		source_title = "Source";
	if (!result_title)
		result_title = "Result";
	if (!frame_title)
		frame_title = "Source & result merge";
	if (!mix_title)
		mix_title = "Mix";

	frame = frame_new (frame_title, DEF_PAD*0.5);

	vbox = gtk_vbox_new(FALSE,DEF_PAD*0.5);
	mrg->main_box = vbox;
	gtk_widget_show(vbox);
	if (hide_control) {
		frame = define_frame_with_hiding_arrows (frame_title, vbox, parent_window, TRUE);
	}
	else {
		frame = frame_new (frame_title, DEF_PAD*0.5);
		gtk_container_add(GTK_CONTAINER(frame),vbox);
	}
	
	hbox = gtk_hbox_new(FALSE,DEF_PAD);
	gtk_widget_show(hbox);
	define_label_in_box("Mode", hbox, FALSE, FALSE, DEF_PAD *0.5);

	mrg->op_toolbar = gtk_toolbar_new ();
	gtk_toolbar_set_orientation(GTK_TOOLBAR(mrg->op_toolbar),GTK_ORIENTATION_HORIZONTAL);
	gtk_toolbar_set_style(GTK_TOOLBAR(mrg->op_toolbar),GTK_TOOLBAR_TEXT);
	gtk_widget_show(GTK_WIDGET(mrg->op_toolbar));
	but1 = gtk_toolbar_append_element(GTK_TOOLBAR(mrg->op_toolbar),
		GTK_TOOLBAR_CHILD_RADIOBUTTON,NULL,"+",
		_("Add"),NULL,NULL,GTK_SIGNAL_FUNC(merge_add_callb),(gpointer) mrg->content);
	but2 = gtk_toolbar_append_element(GTK_TOOLBAR(mrg->op_toolbar),
		GTK_TOOLBAR_CHILD_RADIOBUTTON, but1,"-",
		_("Subtract"),NULL,NULL,GTK_SIGNAL_FUNC(merge_subtract_callb),(gpointer) mrg->content);
	but3 = gtk_toolbar_append_element(GTK_TOOLBAR(mrg->op_toolbar),
		GTK_TOOLBAR_CHILD_RADIOBUTTON,but1,"x",
		_("Multiply"),NULL,NULL,GTK_SIGNAL_FUNC(merge_multiply_callb),(gpointer) mrg->content);
	but4 = gtk_toolbar_append_element(GTK_TOOLBAR(mrg->op_toolbar),
		GTK_TOOLBAR_CHILD_RADIOBUTTON,but1,_("min"),
		_("Minimum"),NULL,NULL,GTK_SIGNAL_FUNC(merge_min_callb),(gpointer) mrg->content);
	but5 = gtk_toolbar_append_element(GTK_TOOLBAR(mrg->op_toolbar),
		GTK_TOOLBAR_CHILD_RADIOBUTTON,but1,_("max"),
		_("Maximum"),NULL,NULL,GTK_SIGNAL_FUNC(merge_max_callb),(gpointer) mrg->content);
	but6 = gtk_toolbar_append_element(GTK_TOOLBAR(mrg->op_toolbar),
		GTK_TOOLBAR_CHILD_RADIOBUTTON,but1,_("alt"),
		_("Altitude"),NULL,NULL,GTK_SIGNAL_FUNC(merge_altitude_callb),(gpointer) mrg->content);
	
	merge_set_op (mrg, mrg->content->merge_op);
//	XOR doesn't seem interesting enough...
//	gtk_toolbar_append_element(GTK_TOOLBAR(mrg->op_toolbar),
//		GTK_TOOLBAR_CHILD_RADIOBUTTON,but1,"^",
//		_("Exclusive OR (XOR)"),NULL,NULL,GTK_SIGNAL_FUNC(merge_xor_callb),(gpointer) mrg);

	gtk_box_pack_start(GTK_BOX(hbox),mrg->op_toolbar, TRUE, TRUE, DEF_PAD *0.5);

	gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);

	hbox = gtk_hbox_new(FALSE,DEF_PAD);
	gtk_widget_show(hbox);
	gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
	define_label_in_box(mix_title,hbox,FALSE,FALSE,DEF_PAD);
	define_label_in_box(source_title, hbox, FALSE, FALSE, 0);
	adj = gtk_adjustment_new (mrg->content->mix, -100, 100, 1, 1, 0.01);
	scale = define_scale_in_box(adj,hbox,0, 0);
	optimize_on_mouse_click (scale, mrg->content->data);
	gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
		GTK_SIGNAL_FUNC (mix_upd), (gpointer) mrg->content);
	mrg->adj_mix = adj;
	define_label_in_box(result_title, hbox,FALSE, FALSE, 0);
	button = gtk_button_new_with_label ("0");
	gtk_signal_connect (GTK_OBJECT (button), "clicked",
	       (GtkSignalFunc) zero_callb, adj);
	gtk_widget_show(button);	
	gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, DEF_PAD);

	hbox = gtk_hbox_new(FALSE,DEF_PAD);
	gtk_widget_show(hbox);
	gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
	define_label_in_box("Hardness",hbox, FALSE, FALSE, DEF_PAD);
	adj = gtk_adjustment_new (mrg->content->hardness, 0.0, 1.0, 0.01, 0.01, 0.01);
	scale = define_scale_in_box(adj,hbox,2,DEF_PAD);
	optimize_on_mouse_click (scale, mrg->content->data);
	gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
		GTK_SIGNAL_FUNC (hardness_upd), (gpointer) mrg->content);
	mrg->adj_hardness = adj;
	// Display the hardness scale only for altitude merge:
	gtk_widget_hide (GTK_WIDGET(scale));
	gtk_signal_connect (GTK_OBJECT (but1), "clicked", (GtkSignalFunc) hide_callb, scale);
	gtk_signal_connect (GTK_OBJECT (but2), "clicked", (GtkSignalFunc) hide_callb, scale);
	gtk_signal_connect (GTK_OBJECT (but3), "clicked", (GtkSignalFunc) hide_callb, scale);
	gtk_signal_connect (GTK_OBJECT (but4), "clicked", (GtkSignalFunc) hide_callb, scale);
	gtk_signal_connect (GTK_OBJECT (but5), "clicked", (GtkSignalFunc) hide_callb, scale);
	gtk_signal_connect (GTK_OBJECT (but6), "clicked", (GtkSignalFunc) show_callb, scale);

	table = gtk_table_new(2, 3, FALSE);
	gtk_widget_show(GTK_WIDGET(table));
	frame2 = define_frame_with_hiding_arrows ("Brightness",table, parent_window, FALSE);
	gtk_box_pack_start(GTK_BOX(vbox), frame2, TRUE, TRUE, 0);

	define_label_in_table(source_title,table,0, 1, 0, 1, DEF_PAD*0.5);
	adj = gtk_adjustment_new (mrg->content->source_offset, -100, 100, 1, 1, 0.01);
	scale = define_scale_in_table(adj,table,1, 2, 0, 1, 0, DEF_PAD*0.5);
	optimize_on_mouse_click (scale, mrg->content->data);
	gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
		GTK_SIGNAL_FUNC (source_offset_upd), (gpointer) mrg->content);
	mrg->adj_source_offset = adj;

	button = define_button_in_table ("0", table, 2, 3, 0, 1, DEF_PAD*0.5);
	gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) zero_callb, adj);

	define_label_in_table(result_title,table,0, 1, 1, 2, DEF_PAD*0.5);
	adj = gtk_adjustment_new (mrg->content->result_offset, -100, 100, 1, 1, 0.01);
	scale = define_scale_in_table(adj,table,1, 2, 1, 2, 0, DEF_PAD*0.5);
	gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
		GTK_SIGNAL_FUNC (result_offset_upd), (gpointer) mrg->content);
	optimize_on_mouse_click (scale, mrg->content->data);
	mrg->adj_result_offset = adj;

	button = define_button_in_table ("0", table, 2, 3, 1, 2, DEF_PAD*0.5);
	gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) zero_callb, adj);

	table = gtk_table_new(2, 3, FALSE);
	gtk_widget_show(GTK_WIDGET(table));
	frame2 = define_frame_with_hiding_arrows ("Translate",table, parent_window, FALSE);

	define_label_in_table("Horizontal",table,0, 1, 0, 1, DEF_PAD);
	adj = gtk_adjustment_new (mrg->content->x_translate, -100, 100, 1, 1, 0.01);
	scale = define_scale_in_table(adj,table,1, 2, 0, 1, 0, DEF_PAD);
	optimize_on_mouse_click (scale, mrg->content->data);
	mrg->adj_x_translate = adj;
	gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
		GTK_SIGNAL_FUNC (merge_x_translate_upd), (gpointer) mrg->content);
	button = define_button_in_table ("0", table, 2, 3, 0, 1, DEF_PAD*0.5);
	gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) zero_callb, adj);

	define_label_in_table("Vertical",table,0, 1, 1, 2, DEF_PAD);
	adj = gtk_adjustment_new (mrg->content->y_translate, -100, 100, 1, 1, 0.01);
	scale = define_scale_in_table(adj,table,1, 2, 1, 2, 0, DEF_PAD);
	optimize_on_mouse_click (scale, mrg->content->data);
	mrg->adj_y_translate = adj;
	gtk_signal_connect (GTK_OBJECT (adj), "value_changed",
		GTK_SIGNAL_FUNC (merge_y_translate_upd), (gpointer) mrg->content);
	button = define_button_in_table ("0", table, 2, 3, 1, 2, DEF_PAD*0.5);
	gtk_signal_connect (GTK_OBJECT (button), "clicked", (GtkSignalFunc) zero_callb, adj);

	gtk_box_pack_start(GTK_BOX(vbox), frame2, TRUE, TRUE, 0);

	return frame ;
}
GtkBrowser *
new_gtk_browser(guint32 chromeMask)
{
    guint32 actualChromeMask = chromeMask;
    GtkBrowser *browser = 0;

    browser = g_new0(GtkBrowser, 1);

    browser->menuBarOn = FALSE;
    browser->toolBarOn = FALSE;
    browser->locationBarOn = FALSE;
    browser->statusBarOn = FALSE;

    g_print("new_gtk_browser\n");

    if (chromeMask == GTK_MOZ_EMBED_FLAG_DEFAULTCHROME)
        actualChromeMask = GTK_MOZ_EMBED_FLAG_ALLCHROME;

    if (actualChromeMask & GTK_MOZ_EMBED_FLAG_MENUBARON)
    {
        browser->menuBarOn = TRUE;
        g_print("\tmenu bar\n");
    }
    if (actualChromeMask & GTK_MOZ_EMBED_FLAG_TOOLBARON)
    {
        browser->toolBarOn = TRUE;
        g_print("\ttool bar\n");
    }
    if (actualChromeMask & GTK_MOZ_EMBED_FLAG_LOCATIONBARON)
    {
        browser->locationBarOn = TRUE;
        g_print("\tlocation bar\n");
    }
    if (actualChromeMask & GTK_MOZ_EMBED_FLAG_STATUSBARON)
    {
        browser->statusBarOn = TRUE;
        g_print("\tstatus bar\n");
    }

    // create our new toplevel window
    browser->topLevelWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    // new vbox
    browser->topLevelVBox = gtk_vbox_new(FALSE, 0);
    // add it to the toplevel window
    gtk_container_add(GTK_CONTAINER(browser->topLevelWindow),
        browser->topLevelVBox);
    // create our menu bar
    browser->menuBar = gtk_menu_bar_new();
    // create the file menu
    browser->fileMenuItem = gtk_menu_item_new_with_label("File");
    browser->fileMenu = gtk_menu_new();
    gtk_menu_item_set_submenu (GTK_MENU_ITEM(browser->fileMenuItem),
        browser->fileMenu);

    browser->fileClose =
        gtk_menu_item_new_with_label("Close");
    gtk_menu_append(GTK_MENU(browser->fileMenu),
        browser->fileClose);

    // append it
    gtk_menu_bar_append(GTK_MENU_BAR(browser->menuBar), browser->fileMenuItem);

    // add it to the vbox
    gtk_box_pack_start(GTK_BOX(browser->topLevelVBox),
        browser->menuBar,
        FALSE, // expand
        FALSE, // fill
        0);    // padding
    // create the hbox that will contain the toolbar and the url text entry bar
    browser->toolbarHBox = gtk_hbox_new(FALSE, 0);
    // add that hbox to the vbox
    gtk_box_pack_start(GTK_BOX(browser->topLevelVBox),
        browser->toolbarHBox,
        FALSE, // expand
        FALSE, // fill
        0);    // padding

    // new horiz toolbar with buttons + icons
#ifdef MOZ_WIDGET_GTK
    browser->toolbar = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL,
        GTK_TOOLBAR_BOTH);
#endif /* MOZ_WIDGET_GTK */

#ifdef MOZ_WIDGET_GTK2
    browser->toolbar = gtk_toolbar_new();
    gtk_toolbar_set_orientation(GTK_TOOLBAR(browser->toolbar),
        GTK_ORIENTATION_HORIZONTAL);
    gtk_toolbar_set_style(GTK_TOOLBAR(browser->toolbar),
        GTK_TOOLBAR_BOTH);
#endif /* MOZ_WIDGET_GTK2 */

    // add it to the hbox
    gtk_box_pack_start(GTK_BOX(browser->toolbarHBox), browser->toolbar,
        FALSE, // expand
        FALSE, // fill
        0);    // padding
    // new back button
    browser->backButton =
        gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar),
        "Back",
        "Go Back",
        "Go Back",
        0, // XXX replace with icon
        GTK_SIGNAL_FUNC(back_clicked_cb),
        browser);
    // new stop button
    browser->stopButton =
        gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar),
        "Stop",
        "Stop",
        "Stop",
        0, // XXX replace with icon
        GTK_SIGNAL_FUNC(stop_clicked_cb),
        browser);
    // new forward button
    browser->forwardButton =
        gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar),
        "Forward",
        "Forward",
        "Forward",
        0, // XXX replace with icon
        GTK_SIGNAL_FUNC(forward_clicked_cb),
        browser);
    // new reload button
    browser->reloadButton =
        gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar),
        "Reload",
        "Reload",
        "Reload",
        0, // XXX replace with icon
        GTK_SIGNAL_FUNC(reload_clicked_cb),
        browser);
    // create the url text entry
    browser->urlEntry = gtk_entry_new();
    // add it to the hbox
    gtk_box_pack_start(GTK_BOX(browser->toolbarHBox), browser->urlEntry,
        TRUE, // expand
        TRUE, // fill
        0);    // padding

    // create our new gtk moz embed widget
    browser->mozEmbed = gtk_moz_embed_new();
    // add it to the toplevel vbox
    gtk_box_pack_start(GTK_BOX(browser->topLevelVBox), browser->mozEmbed,
        TRUE, // expand
        TRUE, // fill
        0);   // padding

    // create the new hbox for the progress area
    browser->progressAreaHBox = gtk_hbox_new(FALSE, 0);
    // add it to the vbox
    gtk_box_pack_start(GTK_BOX(browser->topLevelVBox), browser->progressAreaHBox,
        FALSE, // expand
        FALSE, // fill
        0);   // padding
    // create our new progress bar
    browser->progressBar = gtk_progress_bar_new();
    // add it to the hbox
    gtk_box_pack_start(GTK_BOX(browser->progressAreaHBox), browser->progressBar,
        FALSE, // expand
        FALSE, // fill
        0); // padding

    // create our status area and the alignment object that will keep it
    // from expanding
    browser->statusAlign = gtk_alignment_new(0, 0, 1, 1);
    gtk_widget_set_usize(browser->statusAlign, 1, -1);
    // create the status bar
    browser->statusBar = gtk_statusbar_new();
    gtk_container_add(GTK_CONTAINER(browser->statusAlign), browser->statusBar);
    // add it to the hbox
    gtk_box_pack_start(GTK_BOX(browser->progressAreaHBox), browser->statusAlign,
        TRUE, // expand
        TRUE, // fill
        0);   // padding
    // by default none of the buttons are marked as sensitive.
    gtk_widget_set_sensitive(browser->backButton, FALSE);
    gtk_widget_set_sensitive(browser->stopButton, FALSE);
    gtk_widget_set_sensitive(browser->forwardButton, FALSE);
    gtk_widget_set_sensitive(browser->reloadButton, FALSE);

    // catch the destruction of the toplevel window
    gtk_signal_connect(GTK_OBJECT(browser->topLevelWindow), "delete_event",
        GTK_SIGNAL_FUNC(delete_cb), browser);

    // hook up the activate signal to the right callback
    gtk_signal_connect(GTK_OBJECT(browser->urlEntry), "activate",
        GTK_SIGNAL_FUNC(url_activate_cb), browser);

    // close this window
    gtk_signal_connect(GTK_OBJECT(browser->fileClose), "activate",
        GTK_SIGNAL_FUNC(menu_close_cb), browser);

    install_mozembed_cb(browser);

    // set the chrome type so it's stored in the object
    gtk_moz_embed_set_chrome_mask(GTK_MOZ_EMBED(browser->mozEmbed),
        actualChromeMask);

    return browser;
}
Exemple #24
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() );
}
Exemple #25
0
static TestGtkBrowser *
new_gtk_browser(guint32 chromeMask)
{
    guint32         actualChromeMask = chromeMask;
    TestGtkBrowser *browser = 0;

    num_browsers++;

    browser = g_new0(TestGtkBrowser, 1);

    browser_list = g_list_prepend(browser_list, browser);

    browser->menuBarOn = FALSE;
    browser->toolBarOn = FALSE;
    browser->locationBarOn = FALSE;
    browser->statusBarOn = FALSE;

    g_print("new_gtk_browser\n");

    if (chromeMask == GTK_MOZ_EMBED_FLAG_DEFAULTCHROME)
        actualChromeMask = GTK_MOZ_EMBED_FLAG_ALLCHROME;

    if (actualChromeMask & GTK_MOZ_EMBED_FLAG_MENUBARON)
    {
        browser->menuBarOn = TRUE;
        g_print("\tmenu bar\n");
    }
    if (actualChromeMask & GTK_MOZ_EMBED_FLAG_TOOLBARON)
    {
        browser->toolBarOn = TRUE;
        g_print("\ttool bar\n");
    }
    if (actualChromeMask & GTK_MOZ_EMBED_FLAG_LOCATIONBARON)
    {
        browser->locationBarOn = TRUE;
        g_print("\tlocation bar\n");
    }
    if (actualChromeMask & GTK_MOZ_EMBED_FLAG_STATUSBARON)
    {
        browser->statusBarOn = TRUE;
        g_print("\tstatus bar\n");
    }

    // create our new toplevel window
    browser->topLevelWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    // new vbox
    browser->topLevelVBox = gtk_vbox_new(FALSE, 0);
    // add it to the toplevel window
    gtk_container_add(GTK_CONTAINER(browser->topLevelWindow),
                      browser->topLevelVBox);
    // create our menu bar
    browser->menuBar = gtk_menu_bar_new();
    // create the file menu
    browser->fileMenuItem = gtk_menu_item_new_with_label("File");
    browser->fileMenu = gtk_menu_new();
    gtk_menu_item_set_submenu (GTK_MENU_ITEM(browser->fileMenuItem),
                               browser->fileMenu);

    browser->fileOpenNewBrowser =
        gtk_menu_item_new_with_label("Open New Browser");
    gtk_menu_append(GTK_MENU(browser->fileMenu),
                    browser->fileOpenNewBrowser);

    browser->fileStream =
        gtk_menu_item_new_with_label("Test Stream");
    gtk_menu_append(GTK_MENU(browser->fileMenu),
                    browser->fileStream);

    browser->fileClose =
        gtk_menu_item_new_with_label("Close");
    gtk_menu_append(GTK_MENU(browser->fileMenu),
                    browser->fileClose);

    browser->fileQuit =
        gtk_menu_item_new_with_label("Quit");
    gtk_menu_append(GTK_MENU(browser->fileMenu),
                    browser->fileQuit);

    // append it
    gtk_menu_bar_append(GTK_MENU_BAR(browser->menuBar), browser->fileMenuItem);

    // add it to the vbox
    gtk_box_pack_start(GTK_BOX(browser->topLevelVBox),
                       browser->menuBar,
                       FALSE, // expand
                       FALSE, // fill
                       0);    // padding
    // create the hbox that will contain the toolbar and the url text entry bar
    browser->toolbarHBox = gtk_hbox_new(FALSE, 0);
    // add that hbox to the vbox
    gtk_box_pack_start(GTK_BOX(browser->topLevelVBox),
                       browser->toolbarHBox,
                       FALSE, // expand
                       FALSE, // fill
                       0);    // padding
    // new horiz toolbar with buttons + icons
#ifdef MOZ_WIDGET_GTK
    browser->toolbar = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL,
                                       GTK_TOOLBAR_BOTH);
#endif /* MOZ_WIDGET_GTK */

#ifdef MOZ_WIDGET_GTK2
    browser->toolbar = gtk_toolbar_new();
    gtk_toolbar_set_orientation(GTK_TOOLBAR(browser->toolbar),
                                GTK_ORIENTATION_HORIZONTAL);
    gtk_toolbar_set_style(GTK_TOOLBAR(browser->toolbar),
                          GTK_TOOLBAR_BOTH);
#endif /* MOZ_WIDGET_GTK2 */

    // add it to the hbox
    gtk_box_pack_start(GTK_BOX(browser->toolbarHBox), browser->toolbar,
                       FALSE, // expand
                       FALSE, // fill
                       0);    // padding
    // new back button
    browser->backButton =
        gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar),
                                "Back",
                                "Go Back",
                                "Go Back",
                                0, // XXX replace with icon
                                GTK_SIGNAL_FUNC(back_clicked_cb),
                                browser);
    // new stop button
    browser->stopButton =
        gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar),
                                "Stop",
                                "Stop",
                                "Stop",
                                0, // XXX replace with icon
                                GTK_SIGNAL_FUNC(stop_clicked_cb),
                                browser);
    // new forward button
    browser->forwardButton =
        gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar),
                                "Forward",
                                "Forward",
                                "Forward",
                                0, // XXX replace with icon
                                GTK_SIGNAL_FUNC(forward_clicked_cb),
                                browser);
    // new reload button
    browser->reloadButton =
        gtk_toolbar_append_item(GTK_TOOLBAR(browser->toolbar),
                                "Reload",
                                "Reload",
                                "Reload",
                                0, // XXX replace with icon
                                GTK_SIGNAL_FUNC(reload_clicked_cb),
                                browser);
    // create the url text entry
    browser->urlEntry = gtk_entry_new();
    // add it to the hbox
    gtk_box_pack_start(GTK_BOX(browser->toolbarHBox), browser->urlEntry,
                       TRUE, // expand
                       TRUE, // fill
                       0);    // padding
    // create our new gtk moz embed widget
    browser->mozEmbed = gtk_moz_embed_new();
    // add it to the toplevel vbox
    gtk_box_pack_start(GTK_BOX(browser->topLevelVBox), browser->mozEmbed,
                       TRUE, // expand
                       TRUE, // fill
                       0);   // padding
    // create the new hbox for the progress area
    browser->progressAreaHBox = gtk_hbox_new(FALSE, 0);
    // add it to the vbox
    gtk_box_pack_start(GTK_BOX(browser->topLevelVBox), browser->progressAreaHBox,
                       FALSE, // expand
                       FALSE, // fill
                       0);   // padding
    // create our new progress bar
    browser->progressBar = gtk_progress_bar_new();
    // add it to the hbox
    gtk_box_pack_start(GTK_BOX(browser->progressAreaHBox), browser->progressBar,
                       FALSE, // expand
                       FALSE, // fill
                       0); // padding

    // create our status area and the alignment object that will keep it
    // from expanding
    browser->statusAlign = gtk_alignment_new(0, 0, 1, 1);
    gtk_widget_set_usize(browser->statusAlign, 1, -1);
    // create the status bar
    browser->statusBar = gtk_statusbar_new();
    gtk_container_add(GTK_CONTAINER(browser->statusAlign), browser->statusBar);
    // add it to the hbox
    gtk_box_pack_start(GTK_BOX(browser->progressAreaHBox), browser->statusAlign,
                       TRUE, // expand
                       TRUE, // fill
                       0);   // padding
    // by default none of the buttons are marked as sensitive.
    gtk_widget_set_sensitive(browser->backButton, FALSE);
    gtk_widget_set_sensitive(browser->stopButton, FALSE);
    gtk_widget_set_sensitive(browser->forwardButton, FALSE);
    gtk_widget_set_sensitive(browser->reloadButton, FALSE);

    // catch the destruction of the toplevel window
    gtk_signal_connect(GTK_OBJECT(browser->topLevelWindow), "delete_event",
                       GTK_SIGNAL_FUNC(delete_cb), browser);

    // hook up the activate signal to the right callback
    gtk_signal_connect(GTK_OBJECT(browser->urlEntry), "activate",
                       GTK_SIGNAL_FUNC(url_activate_cb), browser);

    // hook up to the open new browser activation
    gtk_signal_connect(GTK_OBJECT(browser->fileOpenNewBrowser), "activate",
                       GTK_SIGNAL_FUNC(menu_open_new_cb), browser);
    // hook up to the stream test
    gtk_signal_connect(GTK_OBJECT(browser->fileStream), "activate",
                       GTK_SIGNAL_FUNC(menu_stream_cb), browser);
    // close this window
    gtk_signal_connect(GTK_OBJECT(browser->fileClose), "activate",
                       GTK_SIGNAL_FUNC(menu_close_cb), browser);
    // quit the application
    gtk_signal_connect(GTK_OBJECT(browser->fileQuit), "activate",
                       GTK_SIGNAL_FUNC(menu_quit_cb), browser);

    // hook up the location change to update the urlEntry
    gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "location",
                       GTK_SIGNAL_FUNC(location_changed_cb), browser);
    // hook up the title change to update the window title
    gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "title",
                       GTK_SIGNAL_FUNC(title_changed_cb), browser);
    // hook up the start and stop signals
    gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "net_start",
                       GTK_SIGNAL_FUNC(load_started_cb), browser);
    gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "net_stop",
                       GTK_SIGNAL_FUNC(load_finished_cb), browser);
    // hook up to the change in network status
    gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "net_state",
                       GTK_SIGNAL_FUNC(net_state_change_cb), browser);
    gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "net_state_all",
                       GTK_SIGNAL_FUNC(net_state_change_all_cb), browser);
    // hookup to changes in progress
    gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "progress",
                       GTK_SIGNAL_FUNC(progress_change_cb), browser);
    gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "progress_all",
                       GTK_SIGNAL_FUNC(progress_change_all_cb), browser);
    // hookup to changes in over-link message
    gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "link_message",
                       GTK_SIGNAL_FUNC(link_message_cb), browser);
    // hookup to changes in js status message
    gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "js_status",
                       GTK_SIGNAL_FUNC(js_status_cb), browser);
    // hookup to see whenever a new window is requested
    gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "new_window",
                       GTK_SIGNAL_FUNC(new_window_cb), browser);
    // hookup to any requested visibility changes
    gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "visibility",
                       GTK_SIGNAL_FUNC(visibility_cb), browser);
    // hookup to the signal that says that the browser requested to be
    // destroyed
    gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "destroy_browser",
                       GTK_SIGNAL_FUNC(destroy_brsr_cb), browser);
    // hookup to the signal that is called when someone clicks on a link
    // to load a new uri
    gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "open_uri",
                       GTK_SIGNAL_FUNC(open_uri_cb), browser);
    // this signal is emitted when there's a request to change the
    // containing browser window to a certain height, like with width
    // and height args for a window.open in javascript
    gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "size_to",
                       GTK_SIGNAL_FUNC(size_to_cb), browser);
    // key event signals
    gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_key_down",
                       GTK_SIGNAL_FUNC(dom_key_down_cb), browser);
    gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_key_press",
                       GTK_SIGNAL_FUNC(dom_key_press_cb), browser);
    gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_key_up",
                       GTK_SIGNAL_FUNC(dom_key_up_cb), browser);
    gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_down",
                       GTK_SIGNAL_FUNC(dom_mouse_down_cb), browser);
    gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_up",
                       GTK_SIGNAL_FUNC(dom_mouse_up_cb), browser);
    gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_click",
                       GTK_SIGNAL_FUNC(dom_mouse_click_cb), browser);
    gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_dbl_click",
                       GTK_SIGNAL_FUNC(dom_mouse_dbl_click_cb), browser);
    gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_over",
                       GTK_SIGNAL_FUNC(dom_mouse_over_cb), browser);
    gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_mouse_out",
                       GTK_SIGNAL_FUNC(dom_mouse_out_cb), browser);
    gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_activate",
                       GTK_SIGNAL_FUNC(dom_activate_cb), browser);
    gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_focus_in",
                       GTK_SIGNAL_FUNC(dom_focus_in_cb), browser);
    gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "dom_focus_out",
                       GTK_SIGNAL_FUNC(dom_focus_out_cb), browser);
    // hookup to when the window is destroyed
    gtk_signal_connect(GTK_OBJECT(browser->mozEmbed), "destroy",
                       GTK_SIGNAL_FUNC(destroy_cb), browser);

    // set the chrome type so it's stored in the object
    gtk_moz_embed_set_chrome_mask(GTK_MOZ_EMBED(browser->mozEmbed),
                                  actualChromeMask);

    return browser;
}
Exemple #26
0
void ay_edit_local_accounts(void)
{
	char *text[] = { _("C"),
		_("Screen Name"),
		_("Password"),
		_("Service")
	};
	GtkWidget *box;
	GtkWidget *window_box;
	GtkWidget *hbox;
	GtkWidget *button_box;
	GtkWidget *label;
	guint label_key;
	GtkWidget *toolbar;
	GtkToolItem *toolitem;
	GtkToolItem *tool_sep;
	GtkWidget *separator;
	LList *list;
	LList *l;

	GtkAccelGroup *accel_group;
	GtkCellRenderer *renderer;
	GtkTreeViewColumn *column;
	GtkTreeSelection *selection;

	if (is_open)
		return;

	is_open = 1;

	accel_group = gtk_accel_group_new();

	account_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_window_set_position(GTK_WINDOW(account_window), GTK_WIN_POS_MOUSE);
	gtk_widget_realize(account_window);

	account_list_store = gtk_list_store_new(COL_COUNT,
		G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);

	account_list =
		gtk_tree_view_new_with_model(GTK_TREE_MODEL
		(account_list_store));

	renderer = gtk_cell_renderer_toggle_new();
	column = gtk_tree_view_column_new_with_attributes(text[CONNECT],
		renderer, "active", CONNECT, NULL);

	gtk_tree_view_append_column(GTK_TREE_VIEW(account_list), column);

	renderer = gtk_cell_renderer_text_new();
	column = gtk_tree_view_column_new_with_attributes(text[USER_NAME],
		renderer, "text", USER_NAME, NULL);
	gtk_tree_view_column_set_sizing(column, GTK_TREE_VIEW_COLUMN_AUTOSIZE);
	gtk_tree_view_append_column(GTK_TREE_VIEW(account_list), column);

	renderer = gtk_cell_renderer_text_new();
	column = gtk_tree_view_column_new_with_attributes(text[SERVICE_TYPE],
		renderer, "text", SERVICE_TYPE, NULL);
	gtk_tree_view_append_column(GTK_TREE_VIEW(account_list), column);

	selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(account_list));
	gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);

	gtk_container_set_border_width(GTK_CONTAINER(account_window), 5);
	g_signal_connect(selection, "changed",
		G_CALLBACK(selection_made_callback), NULL);

	box = gtk_vbox_new(FALSE, 0);
	window_box = gtk_vbox_new(FALSE, 5);
	hbox = gtk_hbox_new(FALSE, 5);
	gtk_container_set_border_width(GTK_CONTAINER(hbox), 5);

	/*Screen Name Section */

	label = gtk_label_new_with_mnemonic(_("Screen _Name:"));
	label_key = gtk_label_get_mnemonic_keyval(GTK_LABEL(label));
	gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
	gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 5);
	gtk_widget_show(label);
	username = gtk_entry_new();
	gtk_box_pack_start(GTK_BOX(box), username, FALSE, FALSE, 2);
	gtk_widget_show(username);
	gtk_widget_add_accelerator(username, "grab_focus", accel_group,
		label_key, GDK_MOD1_MASK, (GtkAccelFlags) 0);

	/*Password Section */

	label = gtk_label_new_with_mnemonic(_("_Password:"******"grab_focus", accel_group,
		label_key, GDK_MOD1_MASK, (GtkAccelFlags) 0);

	/*Service Type Section */

	label = gtk_label_new_with_mnemonic(_("Service _Type:"));
	label_key = gtk_label_get_mnemonic_keyval(GTK_LABEL(label));
	gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
	gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 5);
	gtk_widget_show(label);

	service_type = gtk_combo_box_new_text();

	list = get_service_list();
	for (l = list; l; l = l_list_next(l)) {
		char *label = l->data;
		gtk_combo_box_append_text(GTK_COMBO_BOX(service_type), label);
	}
	l_list_free(list);

	gtk_widget_show(service_type);

	gtk_box_pack_start(GTK_BOX(box), service_type, FALSE, FALSE, 2);
	gtk_widget_add_accelerator(service_type, "grab_focus", accel_group,
		label_key, GDK_MOD1_MASK, (GtkAccelFlags) 0);

	/*Connect at startup Section */

	connect_at_startup =
		gtk_check_button_new_with_mnemonic(_("_Connect at startup"));
	label_key =
		gtk_label_get_mnemonic_keyval(GTK_LABEL(GTK_BIN
			(connect_at_startup)->child));
	gtk_widget_show(connect_at_startup);
	gtk_widget_add_accelerator(connect_at_startup, "clicked", accel_group,
		label_key, GDK_MOD1_MASK, (GtkAccelFlags) 0);
	gtk_box_pack_start(GTK_BOX(box), connect_at_startup, FALSE, FALSE, 5);

	gtk_box_pack_start(GTK_BOX(hbox), box, FALSE, FALSE, 2);
	gtk_widget_show(box);

	box = gtk_vbox_new(FALSE, 0);

	read_contacts();

	gtk_box_pack_start(GTK_BOX(box), account_list, TRUE, TRUE, 0);
	gtk_widget_show(account_list);

	gtk_box_pack_start(GTK_BOX(hbox), box, TRUE, TRUE, 2);
	gtk_widget_show(box);

	gtk_box_pack_start(GTK_BOX(window_box), hbox, TRUE, TRUE, 0);
	gtk_widget_show(hbox);

	separator = gtk_hseparator_new();
	gtk_box_pack_start(GTK_BOX(window_box), separator, TRUE, TRUE, 0);
	gtk_widget_show(separator);

	/*Initialize Toolbar */

	toolbar = gtk_toolbar_new();
	gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_BOTH);
	gtk_toolbar_set_show_arrow(GTK_TOOLBAR(toolbar), FALSE);
	gtk_toolbar_set_orientation(GTK_TOOLBAR(toolbar),
		GTK_ORIENTATION_HORIZONTAL);
	gtk_container_set_border_width(GTK_CONTAINER(toolbar), 0);

	/*Add Button */

#define TOOLBAR_APPEND(titem,stock,tip,callback,cb_data) { \
	titem = gtk_tool_button_new_from_stock(stock); \
	gtk_tool_item_set_tooltip_text(titem, tip); \
	g_signal_connect(titem, "clicked", G_CALLBACK(callback), cb_data); \
	gtk_widget_show(GTK_WIDGET(titem)); \
	gtk_toolbar_insert(GTK_TOOLBAR(toolbar), titem, -1); \
}

/* line will tell whether to draw the separator line or not */
#define TOOLBAR_APPEND_SEPARATOR(line) { \
	tool_sep = gtk_separator_tool_item_new(); \
	gtk_separator_tool_item_set_draw(GTK_SEPARATOR_TOOL_ITEM(tool_sep), line); \
	gtk_widget_show(GTK_WIDGET(tool_sep)); \
	gtk_toolbar_insert(GTK_TOOLBAR(toolbar), tool_sep, -1); \
}

	TOOLBAR_APPEND(toolitem, GTK_STOCK_HELP, _("Help"), help_callback,
		NULL);

	TOOLBAR_APPEND_SEPARATOR(TRUE);

	TOOLBAR_APPEND(toolitem, GTK_STOCK_ADD, _("Add Account"), add_callback,
		NULL);

	TOOLBAR_APPEND_SEPARATOR(FALSE);

	/*Delete Button */

	TOOLBAR_APPEND(del_button, GTK_STOCK_DELETE, _("Delete Account"),
		remove_callback, NULL);

	gtk_widget_set_sensitive(GTK_WIDGET(del_button), FALSE);
	TOOLBAR_APPEND_SEPARATOR(FALSE);

	/* Modify Button */

	TOOLBAR_APPEND(mod_button, GTK_STOCK_EDIT, _("Modify Account"),
		modify_callback, NULL);

	gtk_widget_set_sensitive(GTK_WIDGET(mod_button), FALSE);

	TOOLBAR_APPEND_SEPARATOR(TRUE);

	/*Okay Button */

	TOOLBAR_APPEND(toolitem, GTK_STOCK_OK, _("Ok"), ok_callback, NULL);

	TOOLBAR_APPEND_SEPARATOR(FALSE);

	/*Cancel Button */

	TOOLBAR_APPEND(toolitem, GTK_STOCK_CANCEL, _("Cancel"), cancel_callback,
		NULL);

#undef TOOLBAR_APPEND_SEPARATOR
#undef TOOLBAR_APPEND
	/*Buttons End */

	button_box = gtk_hbox_new(FALSE, 0);

	gtk_box_pack_end(GTK_BOX(button_box), toolbar, FALSE, FALSE, 0);
	gtk_widget_show(toolbar);

	gtk_box_pack_start(GTK_BOX(window_box), button_box, FALSE, FALSE, 0);
	gtk_widget_show(button_box);

	gtk_widget_show(window_box);

	gtk_container_add(GTK_CONTAINER(account_window), window_box);

	gtk_window_set_title(GTK_WINDOW(account_window),
		_("Ayttm Account Editor"));

	g_signal_connect(account_window, "destroy", G_CALLBACK(destroy), NULL);

	gtk_window_add_accel_group(GTK_WINDOW(account_window), accel_group);

	gtk_widget_show(account_window);
	gtk_widget_grab_focus(username);
}
/**
 * grg_list_run:
 *
 * Creates, manages and displays a dialog with the entry list
 */
void
grg_list_run (void)
{
	GtkWidget *dialog, *sw, *tbar, *hbox, *bup, *bdown;
	GtkTreePath *path = gtk_tree_path_new ();
	guint res;

	dialog = gtk_dialog_new_with_buttons (_("Index of entries"), NULL,
					      GTK_DIALOG_MODAL, GTK_STOCK_OK,
					      GTK_RESPONSE_OK, NULL);
	gtk_container_set_border_width (GTK_CONTAINER (dialog), GRG_PAD);
	gtk_box_set_spacing (GTK_BOX (GTK_DIALOG (dialog)->vbox), GRG_PAD);

	sw = gtk_scrolled_window_new (NULL, NULL);
	gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw),
					     GTK_SHADOW_ETCHED_IN);
	gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw),
					GTK_POLICY_NEVER,
					GTK_POLICY_AUTOMATIC);

	model = create_model ();

	treeview = gtk_tree_view_new_with_model (model);
	gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview), TRUE);
	gtk_tree_view_set_search_column (GTK_TREE_VIEW (treeview), COL_ID);
	g_signal_connect (G_OBJECT (treeview), "button-press-event",
			  G_CALLBACK (double_click), (gpointer) dialog);
	g_object_unref (G_OBJECT (model));

	gtk_container_add (GTK_CONTAINER (sw), treeview);

	add_columns (GTK_TREE_VIEW (treeview));

	tbar = gtk_toolbar_new ();
	gtk_toolbar_set_orientation (GTK_TOOLBAR (tbar),
				     GTK_ORIENTATION_VERTICAL);
#if 0
	gtk_toolbar_set_icon_size (GTK_TOOLBAR (tbar),
				   GTK_ICON_SIZE_LARGE_TOOLBAR);
#endif
	bup = grg_toolbar_insert_stock (GTK_TOOLBAR (tbar), GTK_STOCK_GO_UP,
					_("Move up"),
					(GtkSignalFunc) move_row,
					GINT_TO_POINTER (TRUE), -1);
	bdown = grg_toolbar_insert_stock (GTK_TOOLBAR (tbar),
					  GTK_STOCK_GO_DOWN, _("Move down"),
					  (GtkSignalFunc) move_row,
					  GINT_TO_POINTER (FALSE), -1);

	hbox = gtk_hbox_new (FALSE, GRG_PAD);
	gtk_box_set_homogeneous (GTK_BOX (hbox), FALSE);
	gtk_box_pack_start (GTK_BOX (hbox), tbar, FALSE, TRUE, 0);
	gtk_box_pack_start (GTK_BOX (hbox), sw, TRUE, TRUE, 0);

	gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, TRUE,
			    TRUE, 0);
	gtk_window_set_default_size (GTK_WINDOW (dialog), 180, 250);

	gtk_tree_path_append_index (path, grg_entries_position ());
	gtk_tree_view_set_cursor (GTK_TREE_VIEW (treeview), path, NULL,
				  FALSE);
	gtk_tree_path_free (path);

	gtk_widget_show_all (dialog);
	res = gtk_dialog_run (GTK_DIALOG (dialog));

	if (res == GTK_RESPONSE_OK)
		grg_entries_nth (get_sel_row_num ());
	else
		grg_entries_nth (0);

	gtk_widget_destroy (dialog);
}
GtkWidget       *create_filterMain (void)
{
  GtkWidget *dialog1;
  GtkWidget *dialog_vbox1;
  GtkWidget *scrolledwindow1;
  GtkWidget *viewport1;
  GtkWidget *hbox1;
  GtkWidget *scrolledwindow2;
  GtkWidget *treeview2;
  GtkWidget *toolbar1;
  GtkIconSize tmp_toolbar_icon_size;
  GtkWidget *toolbuttonAdd;
  GtkWidget *toolbuttonRemove;
  GtkWidget *toolbuttonProperties;
  GtkWidget *toolbuttonUp;
  GtkWidget *toolbuttonDown;
  GtkWidget *tmp_image;
  GtkWidget *toolbuttonVCD;
  GtkWidget *toolbuttonSVCD;
  GtkWidget *toolbuttonDVD;
  GtkWidget *toolbuttonHD1;
  GtkWidget *toolbuttonOpen;
  GtkWidget *toolbuttonSave;
  GtkWidget *toolbuttonPartial;
  GtkWidget *toolbuttonPreview;
  GtkWidget *toolbutton13;
  GtkWidget *dialog_action_area1;
  GtkWidget *cancelbutton1;
  GtkWidget *okbutton1;

  dialog1 = gtk_dialog_new ();
  gtk_window_set_title (GTK_WINDOW (dialog1), QT_TR_NOOP("Video Filters"));
  gtk_window_set_type_hint (GTK_WINDOW (dialog1), GDK_WINDOW_TYPE_HINT_DIALOG);

  dialog_vbox1 = GTK_DIALOG (dialog1)->vbox;
  gtk_widget_show (dialog_vbox1);

  scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL);
  gtk_widget_show (scrolledwindow1);
  gtk_box_pack_start (GTK_BOX (dialog_vbox1), scrolledwindow1, TRUE, TRUE, 0);
  gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow1), GTK_POLICY_NEVER, GTK_POLICY_NEVER);
  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow1), GTK_SHADOW_IN);

  viewport1 = gtk_viewport_new (NULL, NULL);
  gtk_widget_show (viewport1);
  gtk_container_add (GTK_CONTAINER (scrolledwindow1), viewport1);

  hbox1 = gtk_hbox_new (FALSE, 0);
  gtk_widget_show (hbox1);
  gtk_container_add (GTK_CONTAINER (viewport1), hbox1);

  scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL);
  gtk_widget_show (scrolledwindow2);
  gtk_box_pack_start (GTK_BOX (hbox1), scrolledwindow2, TRUE, TRUE, 0);
  gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_SHADOW_IN);

  treeview2 = gtk_tree_view_new ();
  gtk_widget_show (treeview2);
  gtk_container_add (GTK_CONTAINER (scrolledwindow2), treeview2);
  gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview2), FALSE);
  gtk_tree_view_set_enable_search (GTK_TREE_VIEW (treeview2), FALSE);

  toolbar1 = gtk_toolbar_new ();
  gtk_widget_show (toolbar1);
  gtk_box_pack_start (GTK_BOX (hbox1), toolbar1, FALSE, FALSE, 0);
  gtk_toolbar_set_style (GTK_TOOLBAR (toolbar1), GTK_TOOLBAR_BOTH_HORIZ);
  gtk_toolbar_set_orientation (GTK_TOOLBAR (toolbar1), GTK_ORIENTATION_VERTICAL);
  tmp_toolbar_icon_size = gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar1));

  toolbuttonAdd = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-add");
  gtk_widget_show (toolbuttonAdd);
  gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonAdd);

  toolbuttonRemove = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-remove");
  gtk_widget_show (toolbuttonRemove);
  gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonRemove);

  toolbuttonProperties = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-properties");
  gtk_widget_show (toolbuttonProperties);
  gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonProperties);

  toolbuttonUp = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-go-up");
  gtk_widget_show (toolbuttonUp);
  gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonUp);

  toolbuttonDown = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-go-down");
  gtk_widget_show (toolbuttonDown);
  gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonDown);

  tmp_image = gtk_image_new_from_stock ("gtk-zoom-fit", tmp_toolbar_icon_size);
  gtk_widget_show (tmp_image);
  toolbuttonVCD = (GtkWidget*) gtk_tool_button_new (tmp_image, QT_TR_NOOP("VCD res"));
  gtk_widget_show (toolbuttonVCD);
  gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonVCD);

  tmp_image = gtk_image_new_from_stock ("gtk-zoom-fit", tmp_toolbar_icon_size);
  gtk_widget_show (tmp_image);
  toolbuttonSVCD = (GtkWidget*) gtk_tool_button_new (tmp_image, QT_TR_NOOP("SVCD res"));
  gtk_widget_show (toolbuttonSVCD);
  gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonSVCD);

  tmp_image = gtk_image_new_from_stock ("gtk-zoom-fit", tmp_toolbar_icon_size);
  gtk_widget_show (tmp_image);
  toolbuttonDVD = (GtkWidget*) gtk_tool_button_new (tmp_image, QT_TR_NOOP("DVD res"));
  gtk_widget_show (toolbuttonDVD);
  gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonDVD);

  tmp_image = gtk_image_new_from_stock ("gtk-zoom-fit", tmp_toolbar_icon_size);
  gtk_widget_show (tmp_image);
  toolbuttonHD1 = (GtkWidget*) gtk_tool_button_new (tmp_image, QT_TR_NOOP("Half D1 res"));
  gtk_widget_show (toolbuttonHD1);
  gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonHD1);

  toolbuttonOpen = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-open");
  gtk_widget_show (toolbuttonOpen);
  gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonOpen);

  toolbuttonSave = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-save");
  gtk_widget_show (toolbuttonSave);
  gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonSave);

  tmp_image = gtk_image_new_from_stock ("gtk-dnd-multiple", tmp_toolbar_icon_size);
  gtk_widget_show (tmp_image);
  toolbuttonPartial = (GtkWidget*) gtk_tool_button_new (tmp_image, QT_TR_NOOP("Partial"));
  gtk_widget_show (toolbuttonPartial);
  gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonPartial);

  tmp_image = gtk_image_new_from_stock ("gtk-print-preview", tmp_toolbar_icon_size);
  gtk_widget_show (tmp_image);
  toolbuttonPreview = (GtkWidget*) gtk_tool_button_new (tmp_image, QT_TR_NOOP("Preview"));
  gtk_widget_show (toolbuttonPreview);
  gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonPreview);

  tmp_image = gtk_image_new_from_stock ("gtk-save-as", tmp_toolbar_icon_size);
  gtk_widget_show (tmp_image);
  toolbutton13 = (GtkWidget*) gtk_tool_button_new (tmp_image, QT_TR_NOOP("Save as script"));
  gtk_widget_show (toolbutton13);
  gtk_container_add (GTK_CONTAINER (toolbar1), toolbutton13);

  dialog_action_area1 = GTK_DIALOG (dialog1)->action_area;
  gtk_widget_show (dialog_action_area1);
  gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END);

  cancelbutton1 = gtk_button_new_from_stock ("gtk-cancel");
  gtk_widget_show (cancelbutton1);
  gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), cancelbutton1, GTK_RESPONSE_CANCEL);
  GTK_WIDGET_SET_FLAGS (cancelbutton1, GTK_CAN_DEFAULT);

  okbutton1 = gtk_button_new_from_stock ("gtk-ok");
  gtk_widget_show (okbutton1);
  gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), okbutton1, GTK_RESPONSE_OK);
  GTK_WIDGET_SET_FLAGS (okbutton1, GTK_CAN_DEFAULT);

  /* Store pointers to all widgets, for use by lookup_widget(). */
  GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1");
  GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1");
  GLADE_HOOKUP_OBJECT (dialog1, scrolledwindow1, "scrolledwindow1");
  GLADE_HOOKUP_OBJECT (dialog1, viewport1, "viewport1");
  GLADE_HOOKUP_OBJECT (dialog1, hbox1, "hbox1");
  GLADE_HOOKUP_OBJECT (dialog1, scrolledwindow2, "scrolledwindow2");
  GLADE_HOOKUP_OBJECT (dialog1, treeview2, "treeview2");
  GLADE_HOOKUP_OBJECT (dialog1, toolbar1, "toolbar1");
  GLADE_HOOKUP_OBJECT (dialog1, toolbuttonAdd, "toolbuttonAdd");
  GLADE_HOOKUP_OBJECT (dialog1, toolbuttonRemove, "toolbuttonRemove");
  GLADE_HOOKUP_OBJECT (dialog1, toolbuttonProperties, "toolbuttonProperties");
  GLADE_HOOKUP_OBJECT (dialog1, toolbuttonUp, "toolbuttonUp");
  GLADE_HOOKUP_OBJECT (dialog1, toolbuttonDown, "toolbuttonDown");
  GLADE_HOOKUP_OBJECT (dialog1, toolbuttonVCD, "toolbuttonVCD");
  GLADE_HOOKUP_OBJECT (dialog1, toolbuttonSVCD, "toolbuttonSVCD");
  GLADE_HOOKUP_OBJECT (dialog1, toolbuttonDVD, "toolbuttonDVD");
  GLADE_HOOKUP_OBJECT (dialog1, toolbuttonHD1, "toolbuttonHD1");
  GLADE_HOOKUP_OBJECT (dialog1, toolbuttonOpen, "toolbuttonOpen");
  GLADE_HOOKUP_OBJECT (dialog1, toolbuttonSave, "toolbuttonSave");
  GLADE_HOOKUP_OBJECT (dialog1, toolbuttonPartial, "toolbuttonPartial");
  GLADE_HOOKUP_OBJECT (dialog1, toolbuttonPreview, "toolbuttonPreview");
  GLADE_HOOKUP_OBJECT (dialog1, toolbutton13, "toolbutton13");
  GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1");
  GLADE_HOOKUP_OBJECT (dialog1, cancelbutton1, "cancelbutton1");
  GLADE_HOOKUP_OBJECT (dialog1, okbutton1, "okbutton1");

  return dialog1;
}