← Back to branch summary

~ubuntu-branches/ubuntu/precise/vte/precise

« back to all changes in this revision

Viewing changes to src/vteapp.c

  • Committer: Bazaar Package Importer
  • Author(s): Michael Terry
  • Date: 2010-12-13 17:00:11 UTC
  • mfrom: (1.1.59 upstream)
  • Revision ID: james.westby@ubuntu.com-20101213170011-lp89kb01cvvzlpzq
Tags: 1:0.27.2-0ubuntu1
* fix_gtk3_api_changes.patch:
  - Fix GTK3 API breakage
* debian/control:
  - Drop libvte-bin package, after consulting with Debian
* debian/rules:
  - Use separate libexecdir to put binaries in separate folder
    for the gtk3 version of the library

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/vteapp.c
71
71
        VteTerminal *terminal;
72
72
        GtkWindow *window;
73
73
        GdkGeometry geometry;
74
 
        GtkBorder *inner_border;
 
74
        GtkBorder *inner_border;
75
75
 
76
76
        g_assert(GTK_IS_WINDOW(data));
77
77
        g_assert(VTE_IS_TERMINAL(widget));
81
81
        if (!gtk_widget_get_realized (GTK_WIDGET (window)))
82
82
                return;
83
83
 
84
 
        gtk_widget_style_get (widget, "inner-border", &inner_border, NULL);
 
84
        gtk_widget_style_get (widget, "inner-border", &inner_border, NULL);
85
85
        geometry.width_inc = width;
86
86
        geometry.height_inc = height;
87
87
        geometry.base_width = inner_border ? (inner_border->left + inner_border->right) : 0;
88
88
        geometry.base_height = inner_border ? (inner_border->top + inner_border->bottom) : 0;
89
89
        geometry.min_width = geometry.base_width + width * 2;
90
90
        geometry.min_height = geometry.base_height + height * 2;
91
 
        gtk_border_free (inner_border);
 
91
        gtk_border_free (inner_border);
92
92
 
93
93
        gtk_window_set_geometry_hints(window, widget, &geometry,
94
94
                                      GDK_HINT_RESIZE_INC |
103
103
        GtkWindow *window;
104
104
        GdkGeometry geometry;
105
105
        guint width, height;
106
 
        GtkBorder *inner_border;
 
106
        GtkBorder *inner_border;
107
107
 
108
108
        g_assert(GTK_IS_WINDOW(data));
109
109
        g_assert(VTE_IS_TERMINAL(widget));
113
113
        if (!gtk_widget_get_realized (GTK_WIDGET(window)))
114
114
                return;
115
115
 
116
 
        gtk_widget_style_get (widget, "inner-border", &inner_border, NULL);
 
116
        gtk_widget_style_get (widget, "inner-border", &inner_border, NULL);
117
117
        width = vte_terminal_get_char_width (terminal);
118
118
        height = vte_terminal_get_char_height (terminal);
119
119
        geometry.width_inc = width;
122
122
        geometry.base_height = inner_border ? (inner_border->top + inner_border->bottom) : 0;
123
123
        geometry.min_width = geometry.base_width + width * 2;
124
124
        geometry.min_height = geometry.base_height + height * 2;
125
 
        gtk_border_free (inner_border);
 
125
        gtk_border_free (inner_border);
126
126
 
127
127
        gtk_window_set_geometry_hints(window, widget, &geometry,
128
128
                                      GDK_HINT_RESIZE_INC |
188
188
        VteTerminal *terminal;
189
189
        char *match;
190
190
        int tag;
191
 
        GtkBorder *inner_border;
192
 
        int char_width, char_height;
 
191
        GtkBorder *inner_border;
 
192
        int char_width, char_height;
193
193
 
194
194
        switch (event->button) {
195
195
        case 3:
196
196
                terminal = VTE_TERMINAL(widget);
197
197
 
198
 
                gtk_widget_style_get (widget, "inner-border", &inner_border, NULL);
199
 
                char_width = vte_terminal_get_char_width (terminal);
200
 
                char_height = vte_terminal_get_char_height (terminal);
 
198
                gtk_widget_style_get (widget, "inner-border", &inner_border, NULL);
 
199
                char_width = vte_terminal_get_char_width (terminal);
 
200
                char_height = vte_terminal_get_char_height (terminal);
201
201
                match = vte_terminal_match_check(terminal,
202
202
                                                 (event->x - (inner_border ? inner_border->left : 0)) / char_width,
203
203
                                                 (event->y - (inner_border ? inner_border->top : 0)) / char_height,
204
204
                                                 &tag);
205
 
                gtk_border_free (inner_border);
 
205
                gtk_border_free (inner_border);
206
206
                if (match != NULL) {
207
207
                        g_print("Matched `%s' (%d).\n", match, tag);
208
208
                        g_free(match);
308
308
        VteTerminal *terminal;
309
309
 
310
310
        if ((GTK_IS_WINDOW(data)) && (width >= 2) && (height >= 2)) {
311
 
                gint owidth, oheight, char_width, char_height, column_count, row_count;
312
 
                GtkBorder *inner_border;
 
311
                gint owidth, oheight, char_width, char_height, column_count, row_count;
 
312
                GtkBorder *inner_border;
313
313
 
314
314
                terminal = VTE_TERMINAL(widget);
315
315
 
316
316
                gtk_window_get_size(GTK_WINDOW(data), &owidth, &oheight);
317
317
 
318
318
                /* Take into account border overhead. */
319
 
                char_width = vte_terminal_get_char_width (terminal);
320
 
                char_height = vte_terminal_get_char_height (terminal);
321
 
                column_count = vte_terminal_get_column_count (terminal);
322
 
                row_count = vte_terminal_get_row_count (terminal);
323
 
                gtk_widget_style_get (widget, "inner-border", &inner_border, NULL);
 
319
                char_width = vte_terminal_get_char_width (terminal);
 
320
                char_height = vte_terminal_get_char_height (terminal);
 
321
                column_count = vte_terminal_get_column_count (terminal);
 
322
                row_count = vte_terminal_get_row_count (terminal);
 
323
                gtk_widget_style_get (widget, "inner-border", &inner_border, NULL);
324
324
 
325
 
                owidth -= char_width * column_count;
326
 
                oheight -= char_height * row_count;
327
 
                if (inner_border != NULL) {
328
 
                        owidth -= inner_border->left + inner_border->right;
329
 
                        oheight -= inner_border->top + inner_border->bottom;
330
 
                }
 
325
                owidth -= char_width * column_count;
 
326
                oheight -= char_height * row_count;
 
327
                if (inner_border != NULL) {
 
328
                        owidth -= inner_border->left + inner_border->right;
 
329
                        oheight -= inner_border->top + inner_border->bottom;
 
330
                }
331
331
                gtk_window_resize(GTK_WINDOW(data),
332
332
                                  width + owidth, height + oheight);
333
 
                gtk_border_free (inner_border);
 
333
                gtk_border_free (inner_border);
334
334
        }
335
335
}
336
336
 
462
462
 
463
463
static void
464
464
terminal_notify_cb(GObject *object,
465
 
                   GParamSpec *pspec,
466
 
                   gpointer user_data)
 
465
                   GParamSpec *pspec,
 
466
                   gpointer user_data)
467
467
{
468
468
  GValue value = { 0, };
469
469
  char *value_string;
483
483
 
484
484
static void
485
485
child_exit_cb(VteTerminal *terminal,
486
 
                 gpointer user_data)
 
486
                 gpointer user_data)
487
487
{
488
488
}
489
489
 
490
490
static int
491
491
parse_enum(GType type,
492
 
           const char *string)
 
492
           const char *string)
493
493
{
494
494
  GEnumClass *enum_klass;
495
495
  const GEnumValue *enum_value;
508
508
 
509
509
static guint
510
510
parse_flags(GType type,
511
 
            const char *string)
 
511
            const char *string)
512
512
{
513
513
  GFlagsClass *flags_klass;
514
514
  guint value = 0;
521
521
 
522
522
  flags_klass = (GFlagsClass*)g_type_class_ref(type);
523
523
  for (i = 0; flags[i] != NULL; ++i) {
524
 
          const GFlagsValue *flags_value;
 
524
          const GFlagsValue *flags_value;
525
525
 
526
 
          flags_value = g_flags_get_value_by_nick(flags_klass, flags[i]);
527
 
          if (flags_value)
528
 
                  value |= flags_value->value;
529
 
          else
530
 
                  g_warning("Unknown flag '%s'\n", flags[i]);
 
526
          flags_value = g_flags_get_value_by_nick(flags_klass, flags[i]);
 
527
          if (flags_value)
 
528
                  value |= flags_value->value;
 
529
          else
 
530
                  g_warning("Unknown flag '%s'\n", flags[i]);
531
531
  }
532
532
  g_type_class_unref(flags_klass);
533
533
 
538
538
main(int argc, char **argv)
539
539
{
540
540
        GdkScreen *screen;
 
541
#if GTK_CHECK_VERSION (2, 90, 8)
 
542
        GdkVisual *visual;
 
543
#else
541
544
        GdkColormap *colormap;
 
545
#endif
542
546
        GtkWidget *window, *widget,*hbox = NULL, *scrollbar, *scrolled_window = NULL;
543
547
        VteTerminal *terminal;
544
548
        char *env_add[] = {
553
557
                 icon_title = FALSE, shell = TRUE, highlight_set = FALSE,
554
558
                 cursor_set = FALSE, reverse = FALSE, use_geometry_hints = TRUE,
555
559
                 antialias = TRUE, use_scrolled_window = FALSE,
556
 
                 show_object_notifications = FALSE;
557
 
        char *geometry = NULL;
 
560
                 show_object_notifications = FALSE;
 
561
        char *geometry = NULL;
558
562
        gint lines = 100;
559
563
        const char *message = "Launching interactive shell...\r\n";
560
564
        const char *font = NULL;
562
566
        const char *command = NULL;
563
567
        const char *working_directory = NULL;
564
568
        const char *output_file = NULL;
565
 
        char *pty_flags_string = NULL;
566
 
        char *cursor_blink_mode_string = NULL;
567
 
        char *cursor_shape_string = NULL;
568
 
        char *scrollbar_policy_string = NULL;
 
569
        char *pty_flags_string = NULL;
 
570
        char *cursor_blink_mode_string = NULL;
 
571
        char *cursor_shape_string = NULL;
 
572
        char *scrollbar_policy_string = NULL;
569
573
        GdkColor fore, back, tint, highlight, cursor;
570
574
        const GOptionEntry options[]={
571
575
                {
649
653
                        G_OPTION_ARG_INT, &lines,
650
654
                        "Specify the number of scrollback-lines", NULL
651
655
                },
652
 
                {
653
 
                        "cursor-blink", 0, 0,
654
 
                        G_OPTION_ARG_STRING, &cursor_blink_mode_string,
655
 
                        "Cursor blink mode (system|on|off)", "MODE"
656
 
                },
 
656
                {
 
657
                        "cursor-blink", 0, 0,
 
658
                        G_OPTION_ARG_STRING, &cursor_blink_mode_string,
 
659
                        "Cursor blink mode (system|on|off)", "MODE"
 
660
                },
657
661
                {
658
662
                        "color-cursor", 'r', 0,
659
663
                        G_OPTION_ARG_NONE, &cursor_set,
723
727
        };
724
728
        GOptionContext *context;
725
729
        GError *error = NULL;
726
 
        VteTerminalCursorBlinkMode cursor_blink_mode = VTE_CURSOR_BLINK_SYSTEM;
727
 
        VteTerminalCursorShape cursor_shape = VTE_CURSOR_SHAPE_BLOCK;
728
 
        GtkPolicyType scrollbar_policy = GTK_POLICY_ALWAYS;
729
 
        VtePtyFlags pty_flags = VTE_PTY_DEFAULT;
 
730
        VteTerminalCursorBlinkMode cursor_blink_mode = VTE_CURSOR_BLINK_SYSTEM;
 
731
        VteTerminalCursorShape cursor_shape = VTE_CURSOR_SHAPE_BLOCK;
 
732
        GtkPolicyType scrollbar_policy = GTK_POLICY_ALWAYS;
 
733
        VtePtyFlags pty_flags = VTE_PTY_DEFAULT;
730
734
 
731
735
        /* Have to do this early. */
732
736
        if (getenv("VTE_PROFILE_MEMORY")) {
747
751
                return 1;
748
752
        }
749
753
 
750
 
        if (cursor_blink_mode_string) {
751
 
                cursor_blink_mode = parse_enum(VTE_TYPE_TERMINAL_CURSOR_BLINK_MODE, cursor_blink_mode_string);
752
 
                g_free(cursor_blink_mode_string);
753
 
        }
754
 
        if (cursor_shape_string) {
755
 
                cursor_shape = parse_enum(VTE_TYPE_TERMINAL_CURSOR_SHAPE, cursor_shape_string);
756
 
                g_free(cursor_shape_string);
757
 
        }
758
 
        if (scrollbar_policy_string) {
759
 
                scrollbar_policy = parse_enum(GTK_TYPE_POLICY_TYPE, scrollbar_policy_string);
760
 
                g_free(scrollbar_policy_string);
761
 
        }
762
 
        if (pty_flags_string) {
763
 
                pty_flags |= parse_flags(VTE_TYPE_PTY_FLAGS, pty_flags_string);
764
 
                g_free(pty_flags_string);
765
 
        }
 
754
        if (cursor_blink_mode_string) {
 
755
                cursor_blink_mode = parse_enum(VTE_TYPE_TERMINAL_CURSOR_BLINK_MODE, cursor_blink_mode_string);
 
756
                g_free(cursor_blink_mode_string);
 
757
        }
 
758
        if (cursor_shape_string) {
 
759
                cursor_shape = parse_enum(VTE_TYPE_TERMINAL_CURSOR_SHAPE, cursor_shape_string);
 
760
                g_free(cursor_shape_string);
 
761
        }
 
762
        if (scrollbar_policy_string) {
 
763
                scrollbar_policy = parse_enum(GTK_TYPE_POLICY_TYPE, scrollbar_policy_string);
 
764
                g_free(scrollbar_policy_string);
 
765
        }
 
766
        if (pty_flags_string) {
 
767
                pty_flags |= parse_flags(VTE_TYPE_PTY_FLAGS, pty_flags_string);
 
768
                g_free(pty_flags_string);
 
769
        }
766
770
 
767
771
        if (!reverse) {
768
772
                back.red = back.green = back.blue = 0xffff;
788
792
 
789
793
        /* Set ARGB colormap */
790
794
        screen = gtk_widget_get_screen (window);
 
795
#if GTK_CHECK_VERSION (2, 90, 8)
 
796
        visual = gdk_screen_get_rgba_visual(screen);
 
797
        if (visual)
 
798
                gtk_widget_set_visual(GTK_WIDGET(window), visual);
 
799
#else
791
800
        colormap = gdk_screen_get_rgba_colormap (screen);
792
801
        if (colormap)
793
802
            gtk_widget_set_colormap(window, colormap);
 
803
#endif
794
804
 
795
 
        if (use_scrolled_window) {
796
 
                scrolled_window = gtk_scrolled_window_new (NULL, NULL);
797
 
                gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
798
 
                                               GTK_POLICY_NEVER, scrollbar_policy);
799
 
                gtk_container_add(GTK_CONTAINER(window), scrolled_window);
800
 
        } else {
801
 
                /* Create a box to hold everything. */
802
 
                hbox = gtk_hbox_new(0, FALSE);
803
 
                gtk_container_add(GTK_CONTAINER(window), hbox);
804
 
        }
 
805
        if (use_scrolled_window) {
 
806
                scrolled_window = gtk_scrolled_window_new (NULL, NULL);
 
807
                gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
 
808
                                               GTK_POLICY_NEVER, scrollbar_policy);
 
809
                gtk_container_add(GTK_CONTAINER(window), scrolled_window);
 
810
        } else {
 
811
                /* Create a box to hold everything. */
 
812
                hbox = gtk_hbox_new(0, FALSE);
 
813
                gtk_container_add(GTK_CONTAINER(window), hbox);
 
814
        }
805
815
 
806
816
        /* Create the terminal widget and add it to the scrolling shell. */
807
817
        widget = vte_terminal_new();
809
819
        if (!dbuffer) {
810
820
                gtk_widget_set_double_buffered(widget, dbuffer);
811
821
        }
812
 
        g_signal_connect(terminal, "child-exited", G_CALLBACK(child_exit_cb), NULL);
813
 
        if (show_object_notifications)
814
 
                g_signal_connect(terminal, "notify", G_CALLBACK(terminal_notify_cb), NULL);
815
 
        if (use_scrolled_window) {
816
 
                gtk_container_add(GTK_CONTAINER(scrolled_window), GTK_WIDGET(terminal));
817
 
        } else {
818
 
                gtk_box_pack_start(GTK_BOX(hbox), widget, TRUE, TRUE, 0);
819
 
        }
 
822
        g_signal_connect(terminal, "child-exited", G_CALLBACK(child_exit_cb), NULL);
 
823
        if (show_object_notifications)
 
824
                g_signal_connect(terminal, "notify", G_CALLBACK(terminal_notify_cb), NULL);
 
825
        if (use_scrolled_window) {
 
826
                gtk_container_add(GTK_CONTAINER(scrolled_window), GTK_WIDGET(terminal));
 
827
        } else {
 
828
                gtk_box_pack_start(GTK_BOX(hbox), widget, TRUE, TRUE, 0);
 
829
        }
820
830
 
821
831
        /* Connect to the "char_size_changed" signal to set geometry hints
822
832
         * whenever the font used by the terminal is changed. */
871
881
        g_signal_connect(widget, "decrease-font-size",
872
882
                         G_CALLBACK(decrease_font_size), window);
873
883
 
874
 
        if (!use_scrolled_window) {
875
 
                /* Create the scrollbar for the widget. */
876
 
                scrollbar = gtk_vscrollbar_new(terminal->adjustment);
877
 
                gtk_box_pack_start(GTK_BOX(hbox), scrollbar, FALSE, FALSE, 0);
878
 
        }
 
884
        if (!use_scrolled_window) {
 
885
                /* Create the scrollbar for the widget. */
 
886
                scrollbar = gtk_vscrollbar_new(terminal->adjustment);
 
887
                gtk_box_pack_start(GTK_BOX(hbox), scrollbar, FALSE, FALSE, 0);
 
888
        }
879
889
 
880
890
        /* Set some defaults. */
881
891
        vte_terminal_set_audible_bell(terminal, audible);
907
917
        if (termcap != NULL) {
908
918
                vte_terminal_set_emulation(terminal, termcap);
909
919
        }
910
 
        vte_terminal_set_cursor_shape(terminal, cursor_shape);
 
920
        vte_terminal_set_cursor_shape(terminal, cursor_shape);
911
921
 
912
922
        /* Set the default font. */
913
923
        vte_terminal_set_font_from_string_full(terminal, font,
976
986
 
977
987
        if (!console) {
978
988
                if (shell) {
979
 
                        GError *err = NULL;
980
 
                        char **command_argv = NULL;
981
 
                        int command_argc;
982
 
                        GPid pid = -1;
 
989
                        GError *err = NULL;
 
990
                        char **command_argv = NULL;
 
991
                        int command_argc;
 
992
                        GPid pid = -1;
983
993
 
984
994
                        _VTE_DEBUG_IF(VTE_DEBUG_MISC)
985
995
                                vte_terminal_feed(terminal, message, -1);
986
996
 
987
 
                        if (command == NULL)
988
 
                                command = "/bin/sh"; // FIXMEchpe
989
 
 
990
 
                        if (command != NULL) {
991
 
                                if (!g_shell_parse_argv(command, &command_argc, &command_argv, &err) ||
992
 
                                    !vte_terminal_fork_command_full(terminal,
993
 
                                                                    pty_flags,
994
 
                                                                    NULL,
995
 
                                                                    command_argv,
996
 
                                                                    env_add,
997
 
                                                                    G_SPAWN_SEARCH_PATH,
998
 
                                                                    NULL, NULL,
999
 
                                                                    &pid,
1000
 
                                                                    &err)) {
1001
 
                                        g_warning("Failed to fork: %s\n", err->message);
1002
 
                                        g_error_free(err);
1003
 
                                } else {
1004
 
                                        g_print("Fork succeeded, PID %d\n", pid);
1005
 
                                }
1006
 
                        }
1007
 
                        g_strfreev(command_argv);
 
997
                        if (command == NULL || *command == '\0')
 
998
                                command = g_getenv ("SHELL");
 
999
 
 
1000
                        if (command == NULL || *command == '\0')
 
1001
                                command = "/bin/sh";
 
1002
 
 
1003
                        if (!g_shell_parse_argv(command, &command_argc, &command_argv, &err) ||
 
1004
                            !vte_terminal_fork_command_full(terminal,
 
1005
                                                            pty_flags,
 
1006
                                                            NULL,
 
1007
                                                            command_argv,
 
1008
                                                            env_add,
 
1009
                                                            G_SPAWN_SEARCH_PATH,
 
1010
                                                            NULL, NULL,
 
1011
                                                            &pid,
 
1012
                                                            &err)) {
 
1013
                                g_warning("Failed to fork: %s\n", err->message);
 
1014
                                g_error_free(err);
 
1015
                        } else {
 
1016
                                g_print("Fork succeeded, PID %d\n", pid);
 
1017
                        }
 
1018
 
 
1019
                        g_strfreev(command_argv);
1008
1020
        #ifdef VTE_DEBUG
1009
1021
                        if (command == NULL) {
1010
1022
                                vte_terminal_feed_child(terminal,
1056
1068
        add_weak_pointer(G_OBJECT(widget), &widget);
1057
1069
        add_weak_pointer(G_OBJECT(window), &window);
1058
1070
 
1059
 
        gtk_widget_realize(widget);
1060
 
        if (geometry) {
1061
 
                if (!gtk_window_parse_geometry (GTK_WINDOW(window), geometry)) {
1062
 
                        g_warning (_("Could not parse the geometry spec passed to --geometry"));
1063
 
                }
1064
 
        }
 
1071
        gtk_widget_realize(widget);
 
1072
        if (geometry) {
 
1073
                if (!gtk_window_parse_geometry (GTK_WINDOW(window), geometry)) {
 
1074
                        g_warning (_("Could not parse the geometry spec passed to --geometry"));
 
1075
                }
 
1076
        }
 
1077
#if GTK_CHECK_VERSION(2, 91, 0)
 
1078
        else {
 
1079
                /* As of GTK+ 2.91.0, the default size of a window comes from its minimum
 
1080
                 * size not its natural size, so we need to set the right default size
 
1081
                 * explicitly */
 
1082
                gtk_window_set_default_geometry (GTK_WINDOW (window),
 
1083
                                                 vte_terminal_get_column_count (terminal),
 
1084
                                                 vte_terminal_get_row_count (terminal));
 
1085
        }
 
1086
#endif
1065
1087
 
1066
1088
        gtk_widget_show_all(window);
1067
1089