Ejemplo n.º 1
0
GtkWidget * gw_status_bar_create ( GtkWindow *w)
{
    GtkWidget *gw_status_bar_box;
    GtkWidget *hbox;
    GtkWidget *status_bar1;
    GtkWidget *status_bar2;


#ifdef GW_DEBUG_GUI_COMPONENT
    g_print ( "*** GW - %s (%d) :: %s()\n", __FILE__, __LINE__, __PRETTY_FUNCTION__);
#endif

    gw_status_bar_box = gtk_viewport_new ( NULL, NULL);
    gtk_viewport_set_shadow_type ( GTK_VIEWPORT ( gw_status_bar_box), GTK_SHADOW_NONE);

    hbox = gtk_hbox_new ( FALSE, 0);
    gtk_container_add ( GTK_CONTAINER ( gw_status_bar_box), hbox);

    /* First status bar */
    status_bar1 = gtk_statusbar_new ( );
    gtk_widget_ref ( status_bar1);
    gtk_object_set_data_full ( GTK_OBJECT ( w), GW_REF_STATUS_BAR_FIRST_STATUS, status_bar1, (GtkDestroyNotify) gtk_widget_unref);
    gtk_box_pack_start ( GTK_BOX ( hbox), status_bar1, FALSE, FALSE, 0);
    gtk_widget_set_usize ( status_bar1, 500, -2);

    /* Second status bar */
    status_bar2 = gtk_statusbar_new ( );
    gtk_widget_ref ( status_bar2);
    gtk_object_set_data_full ( GTK_OBJECT ( w), GW_REF_STATUS_BAR_SECOND_STATUS, status_bar2, (GtkDestroyNotify) gtk_widget_unref);
    gtk_box_pack_start ( GTK_BOX ( hbox), status_bar2, TRUE, TRUE, 0);

    return gw_status_bar_box;
}
Ejemplo n.º 2
0
StatusBar_t*
make_statusbar(GtkWidget *main_vbox, GtkWidget *window)
{
   StatusBar_t  *statusbar = g_new(StatusBar_t, 1);
   GtkWidget    *hbox, *iconw;

   hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 1);
   gtk_box_pack_start(GTK_BOX(main_vbox), hbox, FALSE, FALSE, 0);

   /* Status info */
   statusbar->status = gtk_statusbar_new();
   statusbar->status_id = gtk_statusbar_get_context_id(
      GTK_STATUSBAR(statusbar->status), "general_status");
   gtk_box_pack_start(GTK_BOX(hbox), statusbar->status, TRUE, TRUE, 0);
   gtk_widget_show(statusbar->status);

   /* (x, y) coordinate */
   iconw = gtk_image_new_from_stock(IMAP_STOCK_COORD,
                                    GTK_ICON_SIZE_SMALL_TOOLBAR);

   gtk_box_pack_start(GTK_BOX(hbox), iconw, FALSE, FALSE, 10);
   gtk_widget_show(iconw);

   statusbar->xy = gtk_entry_new();
   gtk_widget_set_size_request(statusbar->xy, 96, -1);
   gtk_editable_set_editable(GTK_EDITABLE(statusbar->xy), FALSE);
   gtk_widget_set_can_focus (statusbar->xy, FALSE);
   gtk_box_pack_start(GTK_BOX(hbox), statusbar->xy, FALSE, FALSE, 0);
   gtk_widget_show(statusbar->xy);

   /* Dimension info */
   iconw = gtk_image_new_from_stock(IMAP_STOCK_DIMENSION,
                                    GTK_ICON_SIZE_SMALL_TOOLBAR);
   gtk_box_pack_start(GTK_BOX(hbox), iconw, FALSE, FALSE, 10);
   gtk_widget_show(iconw);

   statusbar->dimension = gtk_entry_new();
   gtk_widget_set_size_request(statusbar->dimension, 96, -1);
   gtk_editable_set_editable(GTK_EDITABLE(statusbar->dimension), FALSE);
   gtk_widget_set_can_focus (statusbar->dimension, FALSE);
   gtk_box_pack_start(GTK_BOX(hbox), statusbar->dimension, FALSE, FALSE, 0);
   gtk_widget_show(statusbar->dimension);

   /* Zoom info */
   statusbar->zoom = gtk_statusbar_new();
   gtk_widget_set_size_request(statusbar->zoom, 48, -1);
   statusbar->zoom_id = gtk_statusbar_get_context_id(
      GTK_STATUSBAR(statusbar->zoom), "zoom_status");
   gtk_box_pack_start(GTK_BOX(hbox), statusbar->zoom, FALSE, FALSE, 5);
   gtk_widget_show(statusbar->zoom);

   gtk_widget_show(hbox);

   return statusbar;
}
Ejemplo n.º 3
0
int main(int argc, char **argv)
{
    GtkWidget *view;
    GtkWidget *window;
    GtkTreeSelection *selection;
    GtkWidget *vbox;
    GtkWidget *statusbar;
    
    gtk_init(&argc, &argv);

    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
    gtk_window_set_title(GTK_WINDOW(window), "Tree View");
    gtk_widget_set_size_request(window, 200, 500);
    
    vbox = gtk_vbox_new(FALSE, 2);
    gtk_container_add(GTK_CONTAINER(window), vbox);

    view = create_view_and_model();
    selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
        
    gtk_box_pack_start(GTK_BOX(vbox), view, TRUE, TRUE, 1);
    
    statusbar = gtk_statusbar_new();
    gtk_box_pack_start(GTK_BOX(vbox), statusbar, FALSE, TRUE, 1);
    
    g_signal_connect(view, "row-activated", (GCallback)view_onRowActivated, NULL);
    
    gtk_widget_show_all(window);
    
    gtk_main();

    return 0;
}
Ejemplo n.º 4
0
VikStatusbar *vik_statusbar_new ()
{
  VikStatusbar *vs = VIK_STATUSBAR ( g_object_new ( VIK_STATUSBAR_TYPE, NULL ) );
  gint i;

  for ( i = 0; i < VIK_STATUSBAR_NUM_TYPES; i++ ) {
    vs->empty[i] = TRUE;
    vs->status[i] = gtk_statusbar_new();
    gtk_statusbar_set_has_resize_grip ( GTK_STATUSBAR(vs->status[i]), FALSE );
  }

  gtk_box_pack_start ( GTK_BOX(vs), vs->status[VIK_STATUSBAR_TOOL], FALSE, FALSE, 1);
  gtk_widget_set_size_request ( vs->status[VIK_STATUSBAR_TOOL], 150, -1 );

  gtk_box_pack_start ( GTK_BOX(vs), vs->status[VIK_STATUSBAR_ITEMS], FALSE, FALSE, 1);
  gtk_widget_set_size_request ( vs->status[VIK_STATUSBAR_ITEMS], 100, -1 );

  gtk_box_pack_start ( GTK_BOX(vs), vs->status[VIK_STATUSBAR_ZOOM], FALSE, FALSE, 1);
  gtk_widget_set_size_request ( vs->status[VIK_STATUSBAR_ZOOM], 100, -1 );

  gtk_box_pack_start ( GTK_BOX(vs), vs->status[VIK_STATUSBAR_POSITION], FALSE, FALSE, 1);
  gtk_widget_set_size_request ( vs->status[VIK_STATUSBAR_POSITION], 250, -1 );

  gtk_box_pack_end ( GTK_BOX(vs), vs->status[VIK_STATUSBAR_INFO], TRUE, TRUE, 1);

  // Set minimum overall size
  //  otherwise the individual size_requests above create an implicit overall size,
  //  and so one can't downsize horizontally as much as may be desired when the statusbar is on
  gtk_widget_set_size_request ( GTK_WIDGET(vs), 50, -1 );

  return vs;
}
Ejemplo n.º 5
0
/*
static void cb_scroll_event(GtkAdjustment *adj, GtkWidget *view)
{
	gtk_text_view_place_cursor_onscreen(GTK_TEXT_VIEW(view));
}
*/
MainWin *create_main_window(void)
{
    GtkWidget *window;
    GtkWidget *vbox;
    GtkWidget *menubar;
    GtkWidget *sw;
    GtkWidget *view;
    GtkWidget *statusBar;
    guint statusBarContext;

    MainWin *mw = g_malloc(sizeof(MainWin));

    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_widget_set_name(window, PACKAGE_NAME);

#if GTK_CHECK_VERSION(2, 6, 0)
    gtk_window_set_default_icon_name(PACKAGE);
#else
    GdkPixbuf *icon = gdk_pixbuf_new_from_file(
                          ICONDIR G_DIR_SEPARATOR_S PACKAGE ".png", NULL);
    gtk_window_set_icon(GTK_WINDOW(window), icon);
    if (icon)
        g_object_unref(icon);
#endif

    g_signal_connect(G_OBJECT(window), "delete-event",
                     G_CALLBACK(on_file_quit), NULL);
    g_signal_connect_after(G_OBJECT(window), "delete-event",
                           G_CALLBACK(gtk_widget_hide_on_delete), NULL);

    vbox = gtk_vbox_new(FALSE, 0);
    gtk_container_add(GTK_CONTAINER(window), vbox);

    menubar = create_menu_bar(window);
    gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);

    sw = gtk_scrolled_window_new(NULL, NULL);
    gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
                                   GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
    gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw),
                                        GTK_SHADOW_IN);
    gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0);

    view = create_text_view();
    gtk_container_add(GTK_CONTAINER(sw), view);

    statusBar = gtk_statusbar_new();
    statusBarContext = gtk_statusbar_get_context_id( (GtkStatusbar *) statusBar, "status" );
    gtk_statusbar_push( (GtkStatusbar *) statusBar, statusBarContext, " " );
    gtk_box_pack_start(GTK_BOX(vbox), statusBar, FALSE, FALSE, 0);

    mw->window = window;
    mw->menubar = menubar;
    mw->view = view;
    mw->statusBar = (GtkStatusbar *) statusBar;
    mw->statusBarContext = statusBarContext;
    mw->buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view));

    return mw;
}
static GtkWidget* create_statusbar()
{
 main_statusbar=GTK_STATUSBAR(gtk_statusbar_new ());
 status_context_id=gtk_statusbar_get_context_id(main_statusbar, "Link Hover");

 return (GtkWidget*)main_statusbar;
}
Ejemplo n.º 7
0
int main(int argc, char *argv[])
{
    gtk_init(&argc, &argv);

    GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    g_signal_connect(window, "destroy", G_CALLBACK(destroy), NULL);

    GtkWidget *vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 2);
    gtk_container_add(GTK_CONTAINER(window), vbox);

    statusbar = gtk_statusbar_new();
    gtk_box_pack_end(GTK_BOX(vbox), statusbar, FALSE, TRUE, 0);
    gint context_id = gtk_statusbar_get_context_id(GTK_STATUSBAR(statusbar), "Statusbar example");

    GtkWidget *buttonPush = gtk_button_new_with_label("Push message");
    gtk_box_pack_start(GTK_BOX(vbox), buttonPush, FALSE, TRUE, 0);
    g_signal_connect(buttonPush, "clicked", G_CALLBACK(push_button_clicked), GINT_TO_POINTER (context_id));
    GtkWidget *buttonPop = gtk_button_new_with_label("Pop message");
    gtk_box_pack_start(GTK_BOX(vbox), buttonPop, FALSE, TRUE, 0);
    g_signal_connect(buttonPop, "clicked", G_CALLBACK(pop_button_clicked), GINT_TO_POINTER (context_id));

    gtk_widget_show_all(window);

    gtk_main();

    return 0;
}
Ejemplo n.º 8
0
static void
pidgin_media_init (PidginMedia *media)
{
	GtkWidget *vbox;
	media->priv = PIDGIN_MEDIA_GET_PRIVATE(media);

#ifdef HAVE_X11
	XSetErrorHandler(pidgin_x_error_handler);
#endif

	vbox = gtk_vbox_new(FALSE, 0);
	gtk_container_add(GTK_CONTAINER(media), vbox);

	media->priv->statusbar = gtk_statusbar_new();
	gtk_box_pack_end(GTK_BOX(vbox), media->priv->statusbar,
			FALSE, FALSE, 0);
	gtk_statusbar_push(GTK_STATUSBAR(media->priv->statusbar),
			0, _("Calling..."));
	gtk_widget_show(media->priv->statusbar);

	media->priv->menubar = setup_menubar(media);
	gtk_box_pack_start(GTK_BOX(vbox), media->priv->menubar,
			FALSE, TRUE, 0);

	media->priv->display = gtk_hbox_new(FALSE, PIDGIN_HIG_BOX_SPACE);
	gtk_container_set_border_width(GTK_CONTAINER(media->priv->display),
			PIDGIN_HIG_BOX_SPACE);
	gtk_box_pack_start(GTK_BOX(vbox), media->priv->display,
			TRUE, TRUE, PIDGIN_HIG_BOX_SPACE);
	gtk_widget_show(vbox);

	g_signal_connect(G_OBJECT(media), "delete-event",
			G_CALLBACK(pidgin_media_delete_event_cb), media);
}
Ejemplo n.º 9
0
static GtkWidget *build_status_bar(void)
{
	GtkWidget *vsep;

	app_bar = gtk_statusbar_new();
	gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(app_bar), TRUE);
	gtk_widget_show(app_bar);

	vp_target_status = gtk_label_new("");
	gtk_widget_show(vp_target_status);
	gtk_box_pack_start(GTK_BOX(app_bar), vp_target_status, FALSE, TRUE,
			   0);

	vsep = gtk_vseparator_new();
	gtk_widget_show(vsep);
	gtk_box_pack_start(GTK_BOX(app_bar), vsep, FALSE, TRUE, 0);

	/* Network status: offline */
	net_status = gtk_label_new(_("Offline"));
	gtk_widget_show(net_status);
	gtk_box_pack_start(GTK_BOX(app_bar), net_status, FALSE, TRUE, 0);

	vsep = gtk_vseparator_new();
	gtk_widget_show(vsep);
	gtk_box_pack_start(GTK_BOX(app_bar), vsep, FALSE, TRUE, 0);

	gtk_box_pack_start(GTK_BOX(app_bar),
			   player_build_turn_area(), FALSE, TRUE, 0);

	/* Initial text in status bar */
	gui_set_instructions(_("Welcome to Pioneers!"));

	return app_bar;
}
Ejemplo n.º 10
0
GtkWidget *gui_status_build(void)
{
	statusbar = gtk_statusbar_new();
	gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(statusbar), FALSE);
	context = gtk_statusbar_get_context_id(GTK_STATUSBAR(statusbar), "info");
	return statusbar;
}
Ejemplo n.º 11
0
/** Initialize the data structures of a gnucash embedded window.
 *
 *  @param window The object to initialize. */
static void
gnc_embedded_window_setup_window (GncEmbeddedWindow *window)
{
    GncEmbeddedWindowPrivate *priv;

    ENTER("window %p", window);
    priv = GNC_EMBEDDED_WINDOW_GET_PRIVATE(window);

    /* Create widgets and add them to the window */
    gtk_widget_show (GTK_WIDGET(window));

    priv->menu_dock = gtk_vbox_new (FALSE, 0);
    gtk_widget_show (priv->menu_dock);
    gtk_box_pack_start (GTK_BOX (window), priv->menu_dock, FALSE, TRUE, 0);

    priv->statusbar = gtk_statusbar_new ();
    gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR(priv->statusbar), FALSE);
    gtk_widget_show (priv->statusbar);
    gtk_box_pack_end (GTK_BOX (window), priv->statusbar, FALSE, TRUE, 0);

    window->ui_merge = gtk_ui_manager_new ();
    g_signal_connect (G_OBJECT (window->ui_merge), "add_widget",
                      G_CALLBACK (gnc_embedded_window_add_widget), window);

    priv->action_group = NULL;
    LEAVE(" ");
}
Ejemplo n.º 12
0
int main (int argc, char *argv[])
{
  GtkWidget *window, *vbox;
  GtkWidget *info, *pane;
  struct utt *utt;

  gtk_init (&argc, &argv);

  utt = utt_new ();

  logo_setup ();
  locale_setup ();
  utt_debug ();

  /* create home window */
  utt->ui.home_window = window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
  gtk_window_set_title (GTK_WINDOW (window), _("Universal Typing Training"));
  g_signal_connect (window, "destroy", gtk_main_quit, NULL);
  gtk_window_set_position (GTK_WINDOW (window), GTK_WIN_POS_CENTER);
  gtk_widget_set_size_request (window, 480, 320);

  vbox = gtk_vbox_new (FALSE, 0);
  gtk_container_add (GTK_CONTAINER (window), vbox);
  pane = gtk_hpaned_new ();
  gtk_box_pack_start (GTK_BOX (vbox), pane, TRUE, TRUE, 0);
  add_class_list (GTK_PANED (pane), utt);
  add_class_intro (GTK_PANED (pane), utt);
  info = gtk_statusbar_new ();
  gtk_box_pack_end (GTK_BOX (vbox), info, FALSE, FALSE, 0);

  gtk_widget_show_all (window);
  gtk_main ();
  utt_destroy (utt);
  exit (EXIT_SUCCESS);
}
Ejemplo n.º 13
0
int main(int argc, char *argv[]) {
    gtk_init(&argc, &argv);

    GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_widget_set_size_request(GTK_WIDGET(window), 200, 100);
    g_signal_connect_swapped(G_OBJECT(window), "delete_event", G_CALLBACK(gtk_main_quit), NULL);

    GtkWidget *vbox = gtk_vbox_new(FALSE, 1);
    gtk_container_add(GTK_CONTAINER(window), vbox);

    GtkWidget *pushButton = gtk_button_new_with_label("Push Item");
    GtkWidget *popButton  = gtk_button_new_with_label("Pop Item");
    status_bar            = gtk_statusbar_new();

    g_signal_connect(G_OBJECT(pushButton), "clicked", G_CALLBACK(click), (gpointer)"push");
    g_signal_connect(G_OBJECT(popButton),  "clicked", G_CALLBACK(click), (gpointer)"pop");

    gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(pushButton), FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(popButton), FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(status_bar), FALSE, FALSE, 0);

    context_id = gtk_statusbar_get_context_id(GTK_STATUSBAR(status_bar), "status");

    gtk_statusbar_push(GTK_STATUSBAR(status_bar), context_id, "This is a state");

    gtk_widget_show_all(window);
    gtk_main();
    return 0;
}
Ejemplo n.º 14
0
static void
gam_app_init (GamApp *gam_app)
{
    GamAppPrivate *priv;

    g_return_if_fail (GAM_IS_APP (gam_app));

    priv = GAM_APP_GET_PRIVATE (gam_app);

    priv->gconf_client = gconf_client_get_default ();
    /*gconf_client_add_dir (priv->gconf_client,
                          "/apps/PAW/PAWed/preferences",
                          GCONF_CLIENT_PRELOAD_NONE,
                          NULL);*/

    priv->ui_manager = gtk_ui_manager_new ();
    priv->ui_accel_group = gtk_ui_manager_get_accel_group (priv->ui_manager);

    priv->main_action_group = gtk_action_group_new ("MainActions");

#ifdef ENABLE_NLS
    gtk_action_group_set_translation_domain (priv->main_action_group, GETTEXT_PACKAGE);
#endif

    priv->status_bar = gtk_statusbar_new ();
    priv->tip_message_cid = gtk_statusbar_get_context_id (GTK_STATUSBAR (priv->status_bar),
                                                          "GamAppToolTips");

    priv->notebook = gtk_notebook_new ();
    gtk_notebook_set_scrollable (GTK_NOTEBOOK (priv->notebook), TRUE);
    gtk_notebook_set_tab_pos (GTK_NOTEBOOK (priv->notebook), GTK_POS_TOP);
    priv->view_mixers_cb_active=TRUE;
}
Ejemplo n.º 15
0
void show_account_list_config_dialog(SFLPhoneClient *client)
{
    account_list_dialog = GTK_DIALOG(gtk_dialog_new_with_buttons(_("Accounts"),
                                     GTK_WINDOW(client->win),
                                     GTK_DIALOG_DESTROY_WITH_PARENT, NULL,
                                     NULL));

    /* Set window properties */
    gtk_container_set_border_width(GTK_CONTAINER(account_list_dialog), 0);
    gtk_window_set_resizable(GTK_WINDOW(account_list_dialog), FALSE);

    GtkWidget *accountFrame = gnome_main_section_new(_("Configured Accounts"));
    gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(account_list_dialog)),
                       accountFrame, TRUE, TRUE, 0);
    gtk_widget_show(accountFrame);
    g_signal_connect(G_OBJECT(account_list_dialog), "destroy",
                     G_CALLBACK(dialog_destroy_cb), NULL);

    /* Accounts tab */
    GtkWidget *tab = create_account_list(client);
    gtk_widget_show(tab);
    gtk_container_add(GTK_CONTAINER(accountFrame), tab);

    /* Status bar for the account list */
    account_list_status_bar = gtk_statusbar_new();
    gtk_widget_show(account_list_status_bar);
    gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(account_list_dialog)), account_list_status_bar, TRUE, TRUE, 0);

    const gint num_accounts = account_list_get_registered_accounts();

    if (num_accounts) {
        gchar * message = g_strdup_printf(n_("There is %d active account",
                                             "There are %d active accounts",
                                             num_accounts), num_accounts);
        gtk_statusbar_push(GTK_STATUSBAR(account_list_status_bar), CONTEXT_ID_REGISTRATION,
                           message);
        g_free(message);
    } else {
        gtk_statusbar_push(GTK_STATUSBAR(account_list_status_bar), CONTEXT_ID_REGISTRATION,
                           _("You have no active accounts"));
    }

    gtk_dialog_run(account_list_dialog);

    status_bar_display_account();

    gtk_widget_destroy(GTK_WIDGET(account_list_dialog));

    /* Invalidate static pointers */
    account_list_dialog = NULL;
    account_list_status_bar = NULL;
    edit_button = NULL;
    delete_button = NULL;
    move_down_button = NULL;
    move_up_button = NULL;
    account_store = NULL;

    update_actions(client);
}
Ejemplo n.º 16
0
int main( int argc, char *argv[])
{

    GtkWidget *window;
    GtkWidget *vbox;

    GtkWidget *toolbar;
    GtkWidget *view;
    GtkWidget *statusbar;
    GtkToolItem *exit;
    GtkTextBuffer *buffer;

    gtk_init(&argc, &argv);

    window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
    gtk_window_set_default_size(GTK_WINDOW(window), 250, 200);
    gtk_window_set_title(GTK_WINDOW(window), "lines & cols");

    vbox = gtk_vbox_new(FALSE, 0);
    gtk_container_add(GTK_CONTAINER(window), vbox);

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

    exit = gtk_tool_button_new_from_stock(GTK_STOCK_QUIT);
    gtk_toolbar_insert(GTK_TOOLBAR(toolbar), exit, -1);

    gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 5);

    view = gtk_text_view_new();
    gtk_box_pack_start(GTK_BOX(vbox), view, TRUE, TRUE, 0);
    gtk_widget_grab_focus(view);

    buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view));

    statusbar = gtk_statusbar_new();
    gtk_box_pack_start(GTK_BOX(vbox), statusbar, FALSE, FALSE, 0);

    g_signal_connect(G_OBJECT(exit), "clicked", 
            G_CALLBACK(gtk_main_quit), NULL);

    g_signal_connect(buffer, "changed",
            G_CALLBACK(update_statusbar), statusbar);

    g_signal_connect_object(buffer, "mark_set", 
            G_CALLBACK(mark_set_callback), statusbar, 0);

    g_signal_connect_swapped(G_OBJECT(window), "destroy",
            G_CALLBACK(gtk_main_quit), NULL);

    gtk_widget_show_all(window);

    update_statusbar(buffer, GTK_STATUSBAR (statusbar));

    gtk_main();

    return 0;
}
Ejemplo n.º 17
0
static void
test_statusbar_basic (void)
{
  GtkWidget *widget;

  widget = gtk_statusbar_new ();
  g_assert (GTK_IS_STATUSBAR (widget));
  gtk_widget_destroy (widget);
}
Ejemplo n.º 18
0
/*
 * Class:     org_java_gtk_gtk_StatusBar
 * Method:    gtk_statusbar_new
 * Signature: ()J
 */
JNIEXPORT jlong JNICALL Java_org_java_1gtk_gtk_StatusBar_gtk_1statusbar_1new
  (JNIEnv *env, jclass cls)
{
	GtkWidget* widget;

	widget = gtk_statusbar_new();

	return (jlong)widget;
}
Ejemplo n.º 19
0
static GtkWidget* createStatusbar()
{
    GtkStatusbar *statusbar = GTK_STATUSBAR(gtk_statusbar_new());
    guint statusContextId = gtk_statusbar_get_context_id(statusbar, "Link Hover");
    g_object_set_data(G_OBJECT(statusbar), "link-hover-context",
        GUINT_TO_POINTER(statusContextId));

    return GTK_WIDGET(statusbar);
}
Ejemplo n.º 20
0
GtkWidget* construct_statusbar( void )
{


    bar = gtk_statusbar_new();
    gtk_statusbar_push( GTK_STATUSBAR( bar ), gtk_statusbar_get_context_id( GTK_STATUSBAR( bar ), "message1" ), "Plant generated" );

    return bar;
}
Ejemplo n.º 21
0
Archivo: mug.c Proyecto: Chris00/mu
static GtkWidget *
mug_statusbar (void)
{
	GtkWidget *statusbar;

	statusbar = gtk_statusbar_new ();

	return statusbar;
}
Ejemplo n.º 22
0
Archivo: myre.c Proyecto: vobiscum/myre
int make_status() {
    if(status)
        return 1;

    status = (GtkStatusbar *)gtk_statusbar_new();
    gtk_widget_set_no_show_all(GTK_WIDGET(status), TRUE);
    debug("make status");

    return 0;
}
Ejemplo n.º 23
0
/**
 * Create and return a new GtkStatusBar to hold various status
 * information.
 *
 * \return	A newly allocated GtkStatusBar.
 */
GtkWidget * gsb_new_statusbar ()
{
    main_statusbar = gtk_statusbar_new ();
    context_id = gtk_statusbar_get_context_id ( GTK_STATUSBAR (main_statusbar), "Grisbi" );
    message_id = -1;

    gtk_widget_show_all ( main_statusbar );

    return main_statusbar;
}
Ejemplo n.º 24
0
static void
tenso_properties_dialog(GtkButton * CodecButt, struct ALL_DATA *all_data)
{
  struct GWIDGET *gwidget = all_data->gwidget;
  GtkTextIter start, end;
  GtkTextIter iter;

  GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
      gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
      gtk_window_set_default_size(GTK_WINDOW(window), 400, 200);
      gtk_window_set_title(GTK_WINDOW(window), "Tenso incoming data");
      gtk_container_set_border_width(GTK_CONTAINER(window), 5);

  GtkWidget *vbox = gtk_vbox_new(FALSE, 0);

  //-------------------------tool bar--------------------------------------------
  GtkWidget *toolbar = gtk_toolbar_new();
    gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS);

  GtkToolItem *startBtn = gtk_tool_button_new_from_stock(GTK_STOCK_OK);
    gtk_toolbar_insert(GTK_TOOLBAR(toolbar), startBtn, -1);

  GtkToolItem *stopBtn = gtk_tool_button_new_from_stock(GTK_STOCK_CANCEL);
    gtk_toolbar_insert(GTK_TOOLBAR(toolbar), stopBtn, -1);

  gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 5);

  GtkWidget *view = gtk_text_view_new();
    gtk_box_pack_start(GTK_BOX(vbox), view, TRUE, TRUE, 0);

  gwidget->tenso_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view));
    gtk_text_buffer_create_tag(gwidget->tenso_buffer, "gap", "pixels_above_lines", 30, NULL);
    gtk_text_buffer_create_tag(gwidget->tenso_buffer, "lmarg", "left_margin", 5, NULL);
    gtk_text_buffer_create_tag(gwidget->tenso_buffer, "blue_fg", "foreground", "blue", NULL); 
    gtk_text_buffer_get_iter_at_offset(gwidget->tenso_buffer, &iter, 0);

    gtk_text_buffer_insert_with_tags_by_name(gwidget->tenso_buffer, &iter, "Tenso test output\n", -1, "blue_fg", "lmarg",  NULL);
    gtk_text_buffer_insert(gwidget->tenso_buffer, &iter, "Waiting...\n", -1);

  GtkWidget *statusbar = gtk_statusbar_new();
      gtk_box_pack_start(GTK_BOX(vbox), statusbar, FALSE, FALSE, 0);
      update_statusbar(gwidget->tenso_buffer, GTK_STATUSBAR (statusbar));

  gtk_container_add(GTK_CONTAINER(window), vbox);

 
  g_signal_connect(G_OBJECT(startBtn), "clicked", 
        G_CALLBACK(tenso_startBtn_clicked), all_data);
  
  g_signal_connect(G_OBJECT(stopBtn), "clicked", 
        G_CALLBACK(tenso_stopBtn_clicked), all_data);
  
  gtk_widget_show_all(window);

}
Ejemplo n.º 25
0
static void
gs_window_build_ui (GsWindow *window)
{
	GtkWidget *menubar;

	g_return_if_fail (GS_IS_WINDOW (window));

	window->priv->box = gtk_vbox_new (FALSE, 0);
	gtk_container_add (GTK_CONTAINER (window), window->priv->box);
	gtk_widget_show (window->priv->box);

	window->priv->ui_manager = gtk_ui_manager_new ();

	window->priv->ui_actions = gtk_action_group_new ("MenuActions");
	gtk_action_group_add_actions (window->priv->ui_actions,
				      action_entries,
				      G_N_ELEMENTS (action_entries),
				      window);
	gtk_action_group_add_toggle_actions (window->priv->ui_actions,
					     toggle_action_entries,
					     G_N_ELEMENTS (toggle_action_entries),
					     window);
	gtk_ui_manager_insert_action_group (window->priv->ui_manager, window->priv->ui_actions, 0);

	if (!gtk_ui_manager_add_ui_from_string (window->priv->ui_manager, UI_DEFINITION, -1, NULL)) {
		g_assert ("No se pudo cargar la UI");
	}

	menubar = gtk_ui_manager_get_widget (window->priv->ui_manager, "/MainMenu");
	g_assert (GTK_IS_WIDGET (menubar));
	gtk_box_pack_start (GTK_BOX (window->priv->box), menubar, FALSE, FALSE, 0);
	gtk_widget_show (menubar);

	gtk_window_add_accel_group (GTK_WINDOW (window),
				    gtk_ui_manager_get_accel_group (window->priv->ui_manager));

	window->priv->graph = gs_graph_new ();
	gtk_widget_show (window->priv->graph);

	window->priv->hpaned = gtk_hpaned_new ();
	gtk_paned_pack1 (GTK_PANED (window->priv->hpaned), window->priv->graph, TRUE, FALSE);

	window->priv->plot_list_panel = gs_plot_list_panel_new (GS_WINDOW (window));
	gtk_paned_pack2 (GTK_PANED (window->priv->hpaned), window->priv->plot_list_panel, TRUE, FALSE);
	gtk_widget_show (window->priv->plot_list_panel);
	gtk_widget_show (window->priv->hpaned);

	gtk_box_pack_start (GTK_BOX (window->priv->box), window->priv->hpaned, TRUE, TRUE, 0);

	window->priv->statusbar = gtk_statusbar_new ();
	gtk_box_pack_end (GTK_BOX (window->priv->box), window->priv->statusbar, FALSE, FALSE, 0);
	gtk_widget_show (window->priv->statusbar);

}
Ejemplo n.º 26
0
void ctk_statusbar_init(CtkStatusBar *status_bar)
{

    status_bar->widget = gtk_statusbar_new();
    status_bar->prev_message_id = 0;
    status_bar->enabled = TRUE;
#ifndef CTK_GTK3
    gtk_statusbar_set_has_resize_grip
        (GTK_STATUSBAR(status_bar->widget), FALSE);
#endif
}
Ejemplo n.º 27
0
static void
packets_bar_new(void)
{
    /* tip: tooltips don't work on statusbars! */
    packets_bar = gtk_statusbar_new();
    packets_ctx = gtk_statusbar_get_context_id(GTK_STATUSBAR(packets_bar), "packets");
    packets_bar_update();
    gtk_statusbar_set_has_resize_grip(GTK_STATUSBAR(packets_bar), FALSE);

    gtk_widget_show(packets_bar);
}
Ejemplo n.º 28
0
Archivo: utils.cpp Proyecto: dyne/MuSE
void putstatusbar(void)
{

	statusbar = gtk_statusbar_new();
	contextid = gtk_statusbar_get_context_id(GTK_STATUSBAR(statusbar),
			_("_The_ status bar"));
/*	g_signal_connect(GTK_OBJECT(statusbar), "button_press_event",
			(GtkSignalFunc) status_window, NULL);*/
	gtk_box_pack_start(GTK_BOX(vbox),  statusbar, FALSE, FALSE, 0);
	
}
Ejemplo n.º 29
0
int main (int argc, char *argv[]) {

  GtkWidget *window;
  GtkWidget *vbox;

  GtkWidget *menubar;
  GtkWidget *viewmenu; 
  GtkWidget *view; 
  GtkWidget *tog_stat; 
  GtkWidget *statusbar; 


  gtk_init(&argc, &argv);

  window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
  gtk_window_set_default_size(GTK_WINDOW(window), 250, 200);
  gtk_window_set_title(GTK_WINDOW(window), "view statusbar");
  
  vbox = gtk_vbox_new(FALSE, 0);
  gtk_container_add(GTK_CONTAINER(window), vbox);
 
  menubar = gtk_menu_bar_new();
  viewmenu = gtk_menu_new();

  view = gtk_menu_item_new_with_label("View");

  // check menu item
  tog_stat = gtk_check_menu_item_new_with_label ("View Statusbar");
  gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(tog_stat), TRUE);

  gtk_menu_item_set_submenu(GTK_MENU_ITEM(view), viewmenu);
  gtk_menu_shell_append(GTK_MENU_SHELL(viewmenu), tog_stat);
  gtk_menu_shell_append(GTK_MENU_SHELL(menubar), view);

  gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 3);

  statusbar = gtk_statusbar_new();
  gtk_box_pack_end(GTK_BOX(vbox), statusbar, FALSE, TRUE, 1);


  g_signal_connect_swapped(G_OBJECT(window), "destroy", 
			   G_CALLBACK(gtk_main_quit), NULL);

  g_signal_connect(G_OBJECT(tog_stat), "activate", 
		   G_CALLBACK(toggle_statusbar), statusbar);

  gtk_widget_show_all(window);

  gtk_main();

  return 0;

}
Ejemplo n.º 30
0
void init_statusBar(t_window * window)
{
  window->pStatusBar = gtk_statusbar_new();
  gtk_box_pack_start(GTK_BOX(window->pVBox),
		     window->pStatusBar,
		     FALSE, FALSE, 0);
  window->icid1 = gtk_statusbar_get_context_id(GTK_STATUSBAR(window->pStatusBar), "ExitMsg");
  window->icid2 = gtk_statusbar_get_context_id(GTK_STATUSBAR(window->pStatusBar), "AboutMsg");
  /*MSN*/
  gtk_statusbar_push (GTK_STATUSBAR (window->pStatusBar), GPOINTER_TO_INT(window->icid2), "MSN offline");
}