plugins/sourceview/anjuta-view.c

   1 /*
   2  * anjuta-view.c
   3  *
   4  * Copyright (C) 1998, 1999 Alex Roberts, Evan Lawrence
   5  * Copyright (C) 2000, 2002 Chema Celorio, Paolo Maggi
   6  * Copyright (C) 2003-2005 Paolo Maggi
   7  * Copyright (C) 2006 Johannes Schmid
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor,
  22  * Boston, MA 02110-1301, USA.
  23  */
  24
  25 /*
  26  * Modified by the anjuta Team, 1998-2005. See the AUTHORS file for a
  27  * list of people on the anjuta Team.
  28  * See the ChangeLog files for a list of changes.
  29  *
  30  * $Id$
  31  */
  32
  33 #ifdef HAVE_CONFIG_H
  34 #include <config.h>
  35 #endif
  36
  37 #include <string.h>
  38 #include <stdlib.h>
  39
  40 #include <gdk/gdkkeysyms.h>
  41
  42 #include <glib/gi18n.h>
  43 #include <glib.h>
  44
  45 #include <libanjuta/anjuta-debug.h>
  46 #include <libanjuta/anjuta-encodings.h>
  47
  48 #include "anjuta-view.h"
  49 #include "sourceview.h"
  50 #include "sourceview-private.h"
  51 #include "anjuta-marshal.h"
  52
  53 #define ANJUTA_VIEW_SCROLL_MARGIN 0.02
  54
  55 #define ANJUTA_VIEW_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object), ANJUTA_TYPE_VIEW, AnjutaViewPrivate))
  56
  57 enum
  58 {
  59         ANJUTA_VIEW_POPUP = 1
  60 };
  61
  62 struct _AnjutaViewPrivate
  63 {
  64         GtkWidget* popup;
  65         guint scroll_idle;
  66   Sourceview* sv;
  67 };
  68
  69 static void     anjuta_view_destroy             (GtkObject       *object);
  70 static void     anjuta_view_finalize            (GObject         *object);
  71 static void     anjuta_view_move_cursor         (GtkTextView     *text_view,
  72                                                  GtkMovementStep  step,
  73                                                  gint             count,
  74                                                  gboolean         extend_selection);
  75 static gint     anjuta_view_focus_out           (GtkWidget       *widget,
  76                                                  GdkEventFocus   *event);
  77
  78 static gint     anjuta_view_expose              (GtkWidget       *widget,
  79                                                  GdkEventExpose  *event);
  80
  81 static gboolean anjuta_view_key_press_event             (GtkWidget         *widget,
  82                                                          GdkEventKey       *event);
  83 static gboolean anjuta_view_button_press_event          (GtkWidget         *widget,
  84                                                          GdkEventButton       *event);
  85
  86 G_DEFINE_TYPE(AnjutaView, anjuta_view, GTK_TYPE_SOURCE_VIEW)
  87
  88 static gboolean
  89 scroll_to_cursor_real (AnjutaView *view)
  90 {
  91         GtkTextBuffer* buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
  92         g_return_val_if_fail (buffer != NULL, FALSE);
  93
  94         gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (view),
  95                                       gtk_text_buffer_get_insert (buffer),
  96                                       0.25,
  97                                       FALSE,
  98                                       0.0,
  99                                       0.0);
 100
 101         view->priv->scroll_idle = 0;
 102         return FALSE;
 103 }
 104
 105 static void
 106 anjuta_view_set_property (GObject * object,
 107                            guint property_id,
 108                            const GValue * value, GParamSpec * pspec)
 109 {
 110         AnjutaView *self = ANJUTA_VIEW (object);
 111         g_return_if_fail(value != NULL);
 112         g_return_if_fail(pspec != NULL);
 113
 114         switch (property_id)
 115         {
 116                 case ANJUTA_VIEW_POPUP:
 117                 {
 118                         GtkWidget* widget;
 119                         self->priv->popup = g_value_get_object (value);
 120                         widget = gtk_menu_get_attach_widget(GTK_MENU(self->priv->popup));
 121                         /* This is a very ugly hack, maybe somebody more familiar with gtk menus
 122                         can fix this */
 123                         if (widget != NULL)
 124                                 gtk_menu_detach(GTK_MENU(self->priv->popup));
 125                         gtk_menu_attach_to_widget(GTK_MENU(self->priv->popup), GTK_WIDGET(self), NULL);
 126                         break;
 127                 }
 128                 default:
 129                 {
 130                         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
 131                         break;
 132                 }
 133         }
 134 }
 135
 136 static void
 137 anjuta_view_get_property (GObject * object,
 138                            guint property_id,
 139                            GValue * value, GParamSpec * pspec)
 140 {
 141         AnjutaView *self = ANJUTA_VIEW (object);
 142
 143         g_return_if_fail(value != NULL);
 144         g_return_if_fail(pspec != NULL);
 145
 146         switch (property_id)
 147         {
 148                 case ANJUTA_VIEW_POPUP:
 149                 {
 150                         g_value_set_object (value, self->priv->popup);
 151                         break;
 152                 }
 153                 default:
 154                 {
 155                         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
 156                         break;
 157                 }
 158         }
 159 }
 160
 161 static void
 162 anjuta_view_class_init (AnjutaViewClass *klass)
 163 {
 164         GObjectClass     *object_class = G_OBJECT_CLASS (klass);
 165         GtkObjectClass   *gtkobject_class = GTK_OBJECT_CLASS (klass);
 166         GtkTextViewClass *textview_class = GTK_TEXT_VIEW_CLASS (klass);
 167         GtkWidgetClass   *widget_class = GTK_WIDGET_CLASS (klass);
 168         GtkBindingSet    *binding_set;
 169         GParamSpec *anjuta_view_spec_popup;
 170
 171         gtkobject_class->destroy = anjuta_view_destroy;
 172         object_class->finalize = anjuta_view_finalize;
 173         object_class->set_property = anjuta_view_set_property;
 174         object_class->get_property = anjuta_view_get_property;
 175
 176         widget_class->focus_out_event = anjuta_view_focus_out;
 177         widget_class->expose_event = anjuta_view_expose;
 178         widget_class->key_press_event = anjuta_view_key_press_event;
 179         widget_class->button_press_event = anjuta_view_button_press_event;
 180
 181         textview_class->move_cursor = anjuta_view_move_cursor;
 182
 183         g_type_class_add_private (klass, sizeof (AnjutaViewPrivate));
 184
 185         anjuta_view_spec_popup = g_param_spec_object ("popup",
 186                                                        "Popup menu",
 187                                                        "The popup-menu to show",
 188                                                        GTK_TYPE_WIDGET,
 189                                                        G_PARAM_READWRITE);
 190         g_object_class_install_property (object_class,
 191                                          ANJUTA_VIEW_POPUP,
 192                                          anjuta_view_spec_popup);
 193
 194         binding_set = gtk_binding_set_by_class (klass);
 195 }
 196
 197 static void
 198 move_cursor (GtkTextView       *text_view,
 199              const GtkTextIter *new_location,
 200              gboolean           extend_selection)
 201 {
 202         GtkTextBuffer *buffer = text_view->buffer;
 203
 204         if (extend_selection)
 205                 gtk_text_buffer_move_mark_by_name (buffer,
 206                                                    "insert",
 207                                                    new_location);
 208         else
 209                 gtk_text_buffer_place_cursor (buffer, new_location);
 210
 211         gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (text_view),
 212                                       gtk_text_buffer_get_insert (buffer),
 213                                       ANJUTA_VIEW_SCROLL_MARGIN,
 214                                       FALSE,
 215                                       0.0,
 216                                       0.0);
 217 }
 218
 219 static void
 220 anjuta_view_move_cursor (GtkTextView    *text_view,
 221                         GtkMovementStep step,
 222                         gint            count,
 223                         gboolean        extend_selection)
 224 {
 225         GtkTextBuffer *buffer = text_view->buffer;
 226         GtkTextMark *mark;
 227         GtkTextIter cur, iter;
 228
 229         /* really make sure gtksourceview's home/end is disabled */
 230         g_return_if_fail (!gtk_source_view_get_smart_home_end (
 231                                                 GTK_SOURCE_VIEW (text_view)));
 232
 233         mark = gtk_text_buffer_get_insert (buffer);
 234         gtk_text_buffer_get_iter_at_mark (buffer, &cur, mark);
 235         iter = cur;
 236
 237         if (step == GTK_MOVEMENT_DISPLAY_LINE_ENDS &&
 238             (count == -1) && gtk_text_iter_starts_line (&iter))
 239         {
 240                 /* Find the iter of the first character on the line. */
 241                 while (!gtk_text_iter_ends_line (&cur))
 242                 {
 243                         gunichar c;
 244
 245                         c = gtk_text_iter_get_char (&cur);
 246                         if (g_unichar_isspace (c))
 247                                 gtk_text_iter_forward_char (&cur);
 248                         else
 249                                 break;
 250                 }
 251
 252                 /* if we are clearing selection, we need to move_cursor even
 253                  * if we are at proper iter because selection_bound may need
 254                  * to be moved */
 255                 if (!gtk_text_iter_equal (&cur, &iter) || !extend_selection)
 256                         move_cursor (text_view, &cur, extend_selection);
 257         }
 258         else if (step == GTK_MOVEMENT_DISPLAY_LINE_ENDS &&
 259                  (count == 1) && gtk_text_iter_ends_line (&iter))
 260         {
 261                 /* Find the iter of the last character on the line. */
 262                 while (!gtk_text_iter_starts_line (&cur))
 263                 {
 264                         gunichar c;
 265
 266                         gtk_text_iter_backward_char (&cur);
 267                         c = gtk_text_iter_get_char (&cur);
 268                         if (!g_unichar_isspace (c))
 269                         {
 270                                 /* We've gone one character too far. */
 271                                 gtk_text_iter_forward_char (&cur);
 272                                 break;
 273                         }
 274                 }
 275
 276                 /* if we are clearing selection, we need to move_cursor even
 277                  * if we are at proper iter because selection_bound may need
 278                  * to be moved */
 279                 if (!gtk_text_iter_equal (&cur, &iter) || !extend_selection)
 280                         move_cursor (text_view, &cur, extend_selection);
 281         }
 282         else
 283         {
 284                 /* note that we chain up to GtkTextView skipping GtkSourceView */
 285                 (* GTK_TEXT_VIEW_CLASS (anjuta_view_parent_class)->move_cursor) (text_view,
 286                                                                                 step,
 287                                                                                 count,
 288                                                                                 extend_selection);
 289         }
 290 }
 291
 292 static void
 293 anjuta_view_init (AnjutaView *view)
 294 {
 295         view->priv = ANJUTA_VIEW_GET_PRIVATE (view);
 296
 297         /*
 298          *  Set tab, fonts, wrap mode, colors, etc. according
 299          *  to preferences
 300          */
 301
 302         g_object_set (G_OBJECT (view),
 303                       "wrap-mode", FALSE,
 304                       "show-line-numbers", TRUE,
 305                       "auto-indent", TRUE,
 306                       "tab-width", 4,
 307                       "insert-spaces-instead-of-tabs", FALSE,
 308                       "highlight-current-line", TRUE,
 309           "indent-on-tab", TRUE, /* Fix #388727 */
 310                       "smart-home-end", FALSE, /* Never changes this */
 311                       NULL);
 312 }
 313
 314 static void
 315 anjuta_view_destroy (GtkObject *object)
 316 {
 317         AnjutaView *view;
 318
 319         view = ANJUTA_VIEW (object);
 320
 321         (* GTK_OBJECT_CLASS (anjuta_view_parent_class)->destroy) (object);
 322 }
 323
 324 static void
 325 anjuta_view_finalize (GObject *object)
 326 {
 327         AnjutaView *view;
 328
 329         view = ANJUTA_VIEW (object);
 330
 331         if (view->priv->popup != NULL)
 332         {
 333             GtkWidget* widget = gtk_menu_get_attach_widget (GTK_MENU (view->priv->popup));
 334             if (widget != NULL)
 335                 gtk_menu_detach (GTK_MENU (view->priv->popup));
 336         }
 337
 338         (* G_OBJECT_CLASS (anjuta_view_parent_class)->finalize) (object);
 339 }
 340
 341 static gint
 342 anjuta_view_focus_out (GtkWidget *widget, GdkEventFocus *event)
 343 {
 344         AnjutaView *view = ANJUTA_VIEW (widget);
 345         AssistWindow* assist_win = view->priv->sv->priv->assist_win;
 346         AssistTip* assist_tip = view->priv->sv->priv->assist_tip;
 347
 348         if (assist_win)
 349                 gtk_widget_destroy(GTK_WIDGET(assist_win));
 350
 351         if (assist_tip)
 352                 gtk_widget_destroy(GTK_WIDGET(assist_tip));
 353
 354         gtk_widget_queue_draw (widget);
 355
 356
 357         (* GTK_WIDGET_CLASS (anjuta_view_parent_class)->focus_out_event) (widget, event);
 358
 359         return FALSE;
 360 }
 361
 362
 363 /**
 364  * anjuta_view_new:
 365  * @sv: a #Sourceview
 366  *
 367  * Creates a new #AnjutaView object displaying the @sv->priv->doc document.
 368  * @doc cannot be NULL.
 369  *
 370  * Return value: a new #AnjutaView
 371  **/
 372 GtkWidget *
 373 anjuta_view_new (Sourceview *sv)
 374 {
 375         GtkWidget *view;
 376
 377         view = GTK_WIDGET (g_object_new (ANJUTA_TYPE_VIEW, NULL));
 378
 379         gtk_text_view_set_buffer (GTK_TEXT_VIEW (view),
 380                                   GTK_TEXT_BUFFER (sv->priv->document));
 381
 382         gtk_widget_show_all (view);
 383
 384   ANJUTA_VIEW(view)->priv->sv = sv;
 385
 386         return view;
 387 }
 388
 389 void
 390 anjuta_view_cut_clipboard (AnjutaView *view)
 391 {
 392         GtkTextBuffer *buffer;
 393         GtkClipboard *clipboard;
 394
 395         g_return_if_fail (ANJUTA_IS_VIEW (view));
 396
 397         buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
 398         g_return_if_fail (buffer != NULL);
 399
 400         if (!gtk_text_view_get_editable (GTK_TEXT_VIEW(view)))
 401                 return;
 402
 403         clipboard = gtk_widget_get_clipboard (GTK_WIDGET (view),
 404                                               GDK_SELECTION_CLIPBOARD);
 405
 406         /* FIXME: what is default editability of a buffer? */
 407         gtk_text_buffer_cut_clipboard (buffer,
 408                                        clipboard,
 409                                        TRUE);
 410
 411         gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (view),
 412                                       gtk_text_buffer_get_insert (buffer),
 413                                       ANJUTA_VIEW_SCROLL_MARGIN,
 414                                       FALSE,
 415                                       0.0,
 416                                       0.0);
 417 }
 418
 419 void
 420 anjuta_view_copy_clipboard (AnjutaView *view)
 421 {
 422         GtkTextBuffer *buffer;
 423         GtkClipboard *clipboard;
 424
 425         g_return_if_fail (ANJUTA_IS_VIEW (view));
 426
 427         buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
 428         g_return_if_fail (buffer != NULL);
 429
 430         clipboard = gtk_widget_get_clipboard (GTK_WIDGET (view),
 431                                               GDK_SELECTION_CLIPBOARD);
 432
 433         gtk_text_buffer_copy_clipboard (buffer, clipboard);
 434
 435         /* on copy do not scroll, we are already on screen */
 436 }
 437
 438 void
 439 anjuta_view_paste_clipboard (AnjutaView *view)
 440 {
 441         GtkTextBuffer *buffer;
 442         GtkClipboard *clipboard;
 443
 444         g_return_if_fail (ANJUTA_IS_VIEW (view));
 445
 446         buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
 447         g_return_if_fail (buffer != NULL);
 448
 449         clipboard = gtk_widget_get_clipboard (GTK_WIDGET (view),
 450                                               GDK_SELECTION_CLIPBOARD);
 451
 452         /* FIXME: what is default editability of a buffer? */
 453         gtk_text_buffer_paste_clipboard (buffer,
 454                                          clipboard,
 455                                          NULL,
 456                                          TRUE);
 457
 458         gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (view),
 459                                       gtk_text_buffer_get_insert (buffer),
 460                                       ANJUTA_VIEW_SCROLL_MARGIN,
 461                                       FALSE,
 462                                       0.0,
 463                                       0.0);
 464 }
 465
 466 void
 467 anjuta_view_delete_selection (AnjutaView *view)
 468 {
 469         GtkTextBuffer *buffer = NULL;
 470
 471         g_return_if_fail (ANJUTA_IS_VIEW (view));
 472
 473         buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
 474         g_return_if_fail (buffer != NULL);
 475
 476         /* FIXME: what is default editability of a buffer? */
 477         gtk_text_buffer_delete_selection (buffer,
 478                                           TRUE,
 479                                           TRUE);
 480
 481         gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (view),
 482                                       gtk_text_buffer_get_insert (buffer),
 483                                       ANJUTA_VIEW_SCROLL_MARGIN,
 484                                       FALSE,
 485                                       0.0,
 486                                       0.0);
 487 }
 488
 489 void
 490 anjuta_view_select_all (AnjutaView *view)
 491 {
 492         GtkTextBuffer *buffer = NULL;
 493         GtkTextIter start, end;
 494
 495         g_return_if_fail (ANJUTA_IS_VIEW (view));
 496
 497         buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
 498         g_return_if_fail (buffer != NULL);
 499
 500         gtk_text_buffer_get_bounds (buffer, &start, &end);
 501         gtk_text_buffer_select_range (buffer, &start, &end);
 502 }
 503
 504 void
 505 anjuta_view_scroll_to_cursor (AnjutaView *view)
 506 {
 507         g_return_if_fail (ANJUTA_IS_VIEW (view));
 508
 509         view->priv->scroll_idle = g_idle_add ((GSourceFunc) scroll_to_cursor_real, view);
 510 }
 511
 512 void
 513 anjuta_view_set_font (AnjutaView   *view,
 514                      gboolean     def,
 515                      const gchar *font_name)
 516 {
 517
 518         g_return_if_fail (ANJUTA_IS_VIEW (view));
 519
 520         if (!def)
 521         {
 522                 PangoFontDescription *font_desc = NULL;
 523
 524                 g_return_if_fail (font_name != NULL);
 525
 526                 font_desc = pango_font_description_from_string (font_name);
 527                 g_return_if_fail (font_desc != NULL);
 528
 529                 gtk_widget_modify_font (GTK_WIDGET (view), font_desc);
 530
 531                 pango_font_description_free (font_desc);
 532         }
 533         else
 534         {
 535                 GtkRcStyle *rc_style;
 536
 537                 rc_style = gtk_widget_get_modifier_style (GTK_WIDGET (view));
 538
 539                 if (rc_style->font_desc)
 540                         pango_font_description_free (rc_style->font_desc);
 541
 542                 rc_style->font_desc = NULL;
 543
 544                 gtk_widget_modify_style (GTK_WIDGET (view), rc_style);
 545         }
 546 }
 547
 548 static gint
 549 anjuta_view_expose (GtkWidget      *widget,
 550                    GdkEventExpose *event)
 551 {
 552         GtkTextView *text_view;
 553         GtkTextBuffer *doc;
 554
 555         text_view = GTK_TEXT_VIEW (widget);
 556
 557         doc = gtk_text_view_get_buffer (text_view);
 558
 559         if ((event->window == gtk_text_view_get_window (text_view, GTK_TEXT_WINDOW_TEXT)))
 560         {
 561                 GdkRectangle visible_rect;
 562                 GtkTextIter iter1, iter2;
 563
 564                 gtk_text_view_get_visible_rect (text_view, &visible_rect);
 565                 gtk_text_view_get_line_at_y (text_view, &iter1,
 566                                              visible_rect.y, NULL);
 567                 gtk_text_view_get_line_at_y (text_view, &iter2,
 568                                              visible_rect.y
 569                                              + visible_rect.height, NULL);
 570                 gtk_text_iter_forward_line (&iter2);
 571         }
 572
 573         return (* GTK_WIDGET_CLASS (anjuta_view_parent_class)->expose_event)(widget, event);
 574 }
 575
 576 static gboolean
 577 anjuta_view_key_press_event             (GtkWidget *widget, GdkEventKey       *event)
 578 {
 579         GtkTextBuffer *buffer;
 580         AnjutaView* view = ANJUTA_VIEW(widget);
 581         AssistWindow* assist_win;
 582         AssistTip* assist_tip;
 583
 584         buffer  = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
 585
 586         assist_win = view->priv->sv->priv->assist_win;
 587         if (assist_win)
 588         {
 589                 if (assist_window_filter_keypress(assist_win, event->keyval))
 590                 {
 591                         DEBUG_PRINT("key filtered: %d", event->keyval);
 592                         return TRUE;
 593                 }
 594         }
 595         assist_tip = view->priv->sv->priv->assist_tip;
 596         if (assist_tip)
 597         {
 598     switch (event->keyval)
 599     {
 600       case GDK_Escape:
 601       case GDK_Up:
 602       case GDK_Down:
 603       case GDK_Page_Up:
 604       case GDK_Page_Down:
 605         gtk_widget_destroy (GTK_WIDGET(assist_tip));
 606         break;
 607                 }
 608         }
 609         return (* GTK_WIDGET_CLASS (anjuta_view_parent_class)->key_press_event)(widget, event);
 610 }
 611
 612 static gboolean
 613 anjuta_view_button_press_event  (GtkWidget *widget, GdkEventButton *event)
 614 {
 615         AnjutaView* view = ANJUTA_VIEW(widget);
 616
 617   /* If we have a calltip shown - hide it */
 618   AssistTip* assist_tip = view->priv->sv->priv->assist_tip;
 619   AssistWindow* assist_win = view->priv->sv->priv->assist_win;
 620   if (assist_win)
 621   {
 622     gtk_widget_destroy (GTK_WIDGET (assist_win));
 623   }
 624         if (assist_tip)
 625         {
 626     gtk_widget_destroy (GTK_WIDGET (assist_tip));
 627   }
 628
 629         switch(event->button)
 630         {
 631                 case 3: /* Right Button */
 632                 {
 633                         GtkTextBuffer* buffer = GTK_TEXT_BUFFER (view->priv->sv->priv->document);
 634                         if (!gtk_text_buffer_get_has_selection (buffer))
 635                         {
 636                                 /* Move cursor to set breakpoints at correct line (#530689) */
 637                                 GtkTextIter iter;
 638                                 gint buffer_x, buffer_y;
 639                                 GtkTextWindowType type =  gtk_text_view_get_window_type (GTK_TEXT_VIEW (view),
 640                                                                                                                                                                                                                                                                  event->window);
 641                                 gtk_text_view_window_to_buffer_coords (GTK_TEXT_VIEW (view),
 642                                                                                                                                                                                          type,
 643                                                                                                                                                                                          event->x,
 644                                                                                                                                                                                          event->y,
 645                                                                                                                                                                                          &buffer_x,
 646                                                                                                                                                                                          &buffer_y);
 647                                 gtk_text_view_get_iter_at_location (GTK_TEXT_VIEW (view),
 648                                                                                                                                                                                 &iter, buffer_x, buffer_y);
 649                                 gtk_text_buffer_place_cursor (buffer, &iter);
 650                         }
 651                         gtk_menu_popup (GTK_MENU (view->priv->popup), NULL, NULL, NULL, NULL,
 652                   event->button, event->time);
 653                         return TRUE;
 654                 }
 655                 default:
 656                         return (* GTK_WIDGET_CLASS (anjuta_view_parent_class)->button_press_event)(widget, event);
 657         }
 658 }