libjava/jni/gtk-peer/gnu_java_awt_peer_gtk_GtkTextComponentPeer.c

   1 /* gtktextcomponentpeer.c -- Native implementation of GtkTextComponentPeer
   2    Copyright (C) 1998, 1999 Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 #include "gtkpeer.h"
  40 #include "gnu_java_awt_peer_gtk_GtkComponentPeer.h"
  41 #include "gnu_java_awt_peer_gtk_GtkTextComponentPeer.h"
  42
  43 static void textcomponent_commit_cb (GtkIMContext *context,
  44                                  const gchar  *str,
  45                                  jobject peer);
  46
  47 static void textcomponent_changed_cb (GtkEditable *editable,
  48                                   jobject peer);
  49
  50 JNIEXPORT void JNICALL
  51 Java_gnu_java_awt_peer_gtk_GtkTextComponentPeer_connectSignals
  52   (JNIEnv *env, jobject obj)
  53 {
  54   GtkTextView *text = NULL;
  55   GtkTextBuffer *buf;
  56   void *ptr = NSA_GET_PTR (env, obj);
  57   jobject *gref = NSA_GET_GLOBAL_REF (env, obj);
  58   g_assert (gref);
  59
  60   gdk_threads_enter ();
  61
  62   if (GTK_IS_ENTRY(ptr))
  63     {
  64       g_signal_connect (GTK_ENTRY (ptr)->im_context, "commit",
  65                         G_CALLBACK (textcomponent_commit_cb), *gref);
  66
  67       g_signal_connect (GTK_EDITABLE (ptr), "changed",
  68                         G_CALLBACK (textcomponent_changed_cb), *gref);
  69
  70       gdk_threads_leave ();
  71
  72       /* Connect the superclass signals.  */
  73       Java_gnu_java_awt_peer_gtk_GtkComponentPeer_connectSignals (env, *gref);
  74     }
  75   else
  76     {
  77       if (GTK_IS_SCROLLED_WINDOW (ptr))
  78         {
  79           text = GTK_TEXT_VIEW (GTK_SCROLLED_WINDOW (ptr)->container.child);
  80         }
  81       else if (GTK_IS_TEXT_VIEW (ptr))
  82         {
  83           text = GTK_TEXT_VIEW (ptr);
  84         }
  85
  86       if (text)
  87         {
  88           g_signal_connect (text->im_context, "commit",
  89                             G_CALLBACK (textcomponent_commit_cb), *gref);
  90
  91           buf = gtk_text_view_get_buffer (text);
  92           if (buf)
  93             g_signal_connect (buf, "changed",
  94                               G_CALLBACK (textcomponent_changed_cb), *gref);
  95
  96           /* Connect the superclass signals.  */
  97           /* FIXME: Cannot do that here or it will get the sw and not the list.
  98              We must a generic way of doing this. */
  99           /* Java_gnu_java_awt_peer_gtk_GtkComponentPeer_connectSignals (env,
 100                                                                          obj); */
 101           g_signal_connect (GTK_OBJECT (text), "event",
 102                     G_CALLBACK (pre_event_handler), *gref);
 103
 104           gdk_threads_leave ();
 105         }
 106     }
 107 }
 108
 109 JNIEXPORT jint JNICALL
 110 Java_gnu_java_awt_peer_gtk_GtkTextComponentPeer_getCaretPosition
 111   (JNIEnv *env, jobject obj)
 112 {
 113   void *ptr;
 114   int pos = 0;
 115   GtkEditable *editable;    // type of GtkEntry    (TextField)
 116   GtkWidget *text = NULL;   // type of GtkTextView (TextArea)
 117   GtkTextBuffer *buf;
 118   GtkTextMark *mark;
 119   GtkTextIter iter;
 120
 121   ptr = NSA_GET_PTR (env, obj);
 122
 123   gdk_threads_enter ();
 124
 125   if (GTK_IS_EDITABLE (ptr))
 126     {
 127       editable = GTK_EDITABLE (ptr);
 128       pos = gtk_editable_get_position (editable);
 129     }
 130   else
 131     {
 132       if (GTK_IS_SCROLLED_WINDOW (ptr))
 133         {
 134           text = GTK_WIDGET (GTK_TEXT_VIEW (GTK_SCROLLED_WINDOW (ptr)->container.child));
 135         }
 136       else if (GTK_IS_TEXT_VIEW (ptr))
 137         {
 138           text = GTK_WIDGET (ptr);
 139         }
 140
 141       if (text)
 142         {
 143           buf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text));
 144           mark = gtk_text_buffer_get_insert (buf);
 145           gtk_text_buffer_get_iter_at_mark (buf, &iter, mark);
 146           pos = gtk_text_iter_get_offset (&iter);
 147         }
 148     }
 149
 150   gdk_threads_leave ();
 151
 152   return pos;
 153 }
 154
 155 JNIEXPORT void JNICALL
 156 Java_gnu_java_awt_peer_gtk_GtkTextComponentPeer_setCaretPosition
 157   (JNIEnv *env, jobject obj, jint pos)
 158 {
 159   void *ptr;
 160   GtkEditable *editable;    // type of GtkEntry    (TextField)
 161   GtkWidget *text = NULL;   // type of GtkTextView (TextArea)
 162   GtkTextBuffer *buf;
 163   GtkTextIter iter;
 164
 165   ptr = NSA_GET_PTR (env, obj);
 166
 167   gdk_threads_enter ();
 168   if (GTK_IS_EDITABLE (ptr))
 169     {
 170       editable = GTK_EDITABLE (ptr);
 171       gtk_editable_set_position (editable, pos);
 172     }
 173   else
 174     {
 175       if (GTK_IS_SCROLLED_WINDOW (ptr))
 176         {
 177           text = GTK_WIDGET (GTK_TEXT_VIEW (GTK_SCROLLED_WINDOW (ptr)->container.child));
 178         }
 179       else if (GTK_IS_TEXT_VIEW (ptr))
 180         {
 181           text = GTK_WIDGET (ptr);
 182         }
 183
 184       if (text)
 185         {
 186           buf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text));
 187           gtk_text_buffer_get_iter_at_offset (buf, &iter, pos);
 188           gtk_text_buffer_place_cursor (buf, &iter);
 189         }
 190     }
 191
 192   gdk_threads_leave ();
 193 }
 194
 195 JNIEXPORT jint JNICALL
 196 Java_gnu_java_awt_peer_gtk_GtkTextComponentPeer_getSelectionStart
 197   (JNIEnv *env, jobject obj)
 198 {
 199   void *ptr;
 200   int pos = 0;
 201   GtkEditable *editable;    // type of GtkEntry    (TextField)
 202   GtkWidget *text = NULL;   // type of GtkTextView (TextArea)
 203   GtkTextBuffer *buf;
 204   GtkTextIter start;
 205   GtkTextIter end;
 206   int starti, endi;
 207   GtkTextMark *mark;
 208   GtkTextIter iter;
 209
 210   ptr = NSA_GET_PTR (env, obj);
 211
 212   gdk_threads_enter ();
 213
 214   if (GTK_IS_EDITABLE (ptr))
 215     {
 216       editable = GTK_EDITABLE (ptr);
 217       if (gtk_editable_get_selection_bounds (editable, &starti, &endi))
 218         pos = starti;
 219       else
 220         pos = gtk_editable_get_position (editable);
 221     }
 222   else
 223     {
 224       if (GTK_IS_SCROLLED_WINDOW (ptr))
 225         {
 226           text = GTK_WIDGET (GTK_TEXT_VIEW (GTK_SCROLLED_WINDOW (ptr)->container.child));
 227         }
 228       else if (GTK_IS_TEXT_VIEW (ptr))
 229         {
 230           text = GTK_WIDGET (ptr);
 231         }
 232
 233       if (text)
 234         {
 235           buf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text));
 236           if (gtk_text_buffer_get_selection_bounds(buf, &start, &end))
 237             pos = gtk_text_iter_get_offset (&start);
 238           else
 239            {
 240             mark = gtk_text_buffer_get_insert (buf);
 241             gtk_text_buffer_get_iter_at_mark (buf, &iter, mark);
 242             pos = gtk_text_iter_get_offset (&iter);
 243            }
 244         }
 245     }
 246
 247   gdk_threads_leave ();
 248
 249   return pos;
 250 }
 251
 252 JNIEXPORT jint JNICALL
 253 Java_gnu_java_awt_peer_gtk_GtkTextComponentPeer_getSelectionEnd
 254   (JNIEnv *env, jobject obj)
 255 {
 256   void *ptr;
 257   int pos = 0;
 258   GtkEditable *editable;    // type of GtkEntry    (TextField)
 259   GtkWidget *text = NULL;   // type of GtkTextView (TextArea)
 260   GtkTextBuffer *buf;
 261   GtkTextIter start;
 262   GtkTextIter end;
 263   int starti, endi;
 264   GtkTextMark *mark;
 265   GtkTextIter iter;
 266
 267   ptr = NSA_GET_PTR (env, obj);
 268
 269   gdk_threads_enter ();
 270
 271   if (GTK_IS_EDITABLE (ptr))
 272     {
 273       editable = GTK_EDITABLE (ptr);
 274       if (gtk_editable_get_selection_bounds (editable, &starti, &endi))
 275         pos = endi;
 276       else
 277         pos = gtk_editable_get_position (editable);
 278     }
 279   else
 280     {
 281       if (GTK_IS_SCROLLED_WINDOW (ptr))
 282         {
 283           text = GTK_WIDGET (GTK_TEXT_VIEW (GTK_SCROLLED_WINDOW (ptr)->container.child));
 284         }
 285       else if (GTK_IS_TEXT_VIEW (ptr))
 286         {
 287           text = GTK_WIDGET (ptr);
 288         }
 289
 290       if (text)
 291         {
 292           buf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text));
 293           if (gtk_text_buffer_get_selection_bounds(buf, &start, &end))
 294             pos = gtk_text_iter_get_offset (&end);
 295           else
 296            {
 297             mark = gtk_text_buffer_get_insert (buf);
 298             gtk_text_buffer_get_iter_at_mark (buf, &iter, mark);
 299             pos = gtk_text_iter_get_offset (&iter);
 300            }
 301         }
 302     }
 303
 304   gdk_threads_leave ();
 305
 306   return pos;
 307 }
 308
 309 JNIEXPORT void JNICALL
 310 Java_gnu_java_awt_peer_gtk_GtkTextComponentPeer_select
 311   (JNIEnv *env, jobject obj, jint start, jint end)
 312 {
 313   void *ptr;
 314   GtkEditable *editable;    // type of GtkEntry    (TextField)
 315   GtkWidget *text = NULL;   // type of GtkTextView (TextArea)
 316   GtkTextBuffer *buf;
 317   GtkTextIter iter;
 318
 319   ptr = NSA_GET_PTR (env, obj);
 320
 321   gdk_threads_enter ();
 322
 323
 324   if (GTK_IS_EDITABLE (ptr))
 325     {
 326       editable = GTK_EDITABLE (ptr);
 327       gtk_editable_select_region (editable, start, end);
 328     }
 329   else
 330     {
 331       if (GTK_IS_SCROLLED_WINDOW (ptr))
 332         {
 333           text = GTK_WIDGET (GTK_TEXT_VIEW (GTK_SCROLLED_WINDOW (ptr)->container.child));
 334         }
 335       else if (GTK_IS_TEXT_VIEW (ptr))
 336         {
 337           text = GTK_WIDGET (ptr);
 338         }
 339
 340       if (text)
 341         {
 342           buf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text));
 343           gtk_text_buffer_get_iter_at_offset (buf, &iter, start);
 344           /* quickly move both 'insert' and 'selection_bound' to the
 345              same position */
 346           gtk_text_buffer_place_cursor (buf, &iter);
 347           gtk_text_buffer_get_iter_at_offset (buf, &iter, end);
 348           gtk_text_buffer_move_mark_by_name (buf, "selection_bound", &iter);
 349         }
 350     }
 351
 352   gdk_threads_leave ();
 353 }
 354
 355 JNIEXPORT void JNICALL
 356 Java_gnu_java_awt_peer_gtk_GtkTextComponentPeer_setEditable
 357   (JNIEnv *env, jobject obj, jboolean state)
 358 {
 359   void *ptr;
 360   GtkEditable *editable;    // type of GtkEntry    (TextField)
 361   GtkWidget *text = NULL;   // type of GtkTextView (TextArea)
 362
 363   ptr = NSA_GET_PTR (env, obj);
 364
 365   gdk_threads_enter ();
 366
 367   if (GTK_IS_EDITABLE (ptr))
 368     {
 369       editable = GTK_EDITABLE (ptr);
 370       gtk_editable_set_editable (editable, state);
 371     }
 372   else
 373     {
 374       if (GTK_IS_SCROLLED_WINDOW (ptr))
 375         {
 376           text = GTK_WIDGET (GTK_TEXT_VIEW (GTK_SCROLLED_WINDOW (ptr)->container.child));
 377         }
 378       else if (GTK_IS_TEXT_VIEW (ptr))
 379         {
 380           text = GTK_WIDGET (ptr);
 381         }
 382
 383       if (text)
 384         {
 385           gtk_text_view_set_editable (GTK_TEXT_VIEW (text), state);
 386         }
 387     }
 388
 389   gdk_threads_leave ();
 390 }
 391
 392 JNIEXPORT jstring JNICALL
 393 Java_gnu_java_awt_peer_gtk_GtkTextComponentPeer_getText
 394   (JNIEnv *env, jobject obj)
 395 {
 396   void *ptr;
 397   char *contents = NULL;
 398   jstring jcontents;
 399   GtkEditable *editable;    // type of GtkEntry    (TextField)
 400   GtkWidget *text = NULL;   // type of GtkTextView (TextArea)
 401   GtkTextBuffer *buf;
 402   GtkTextIter start, end;
 403
 404   ptr = NSA_GET_PTR (env, obj);
 405
 406   gdk_threads_enter ();
 407
 408   if (GTK_IS_EDITABLE (ptr))
 409     {
 410       editable = GTK_EDITABLE (ptr);
 411       contents = gtk_editable_get_chars (editable, 0, -1);
 412     }
 413   else
 414     {
 415       if (GTK_IS_SCROLLED_WINDOW (ptr))
 416         {
 417           text = GTK_WIDGET (GTK_TEXT_VIEW (GTK_SCROLLED_WINDOW (ptr)->container.child));
 418         }
 419       else if (GTK_IS_TEXT_VIEW (ptr))
 420         {
 421           text = GTK_WIDGET (ptr);
 422         }
 423
 424       if (text)
 425         {
 426           buf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text));
 427           gtk_text_buffer_get_start_iter (buf, &start);
 428           gtk_text_buffer_get_end_iter (buf, &end);
 429           contents = gtk_text_buffer_get_text (buf, &start, &end, FALSE);
 430         }
 431     }
 432
 433   gdk_threads_leave ();
 434
 435   jcontents = (*env)->NewStringUTF (env, contents);
 436   g_free (contents);
 437
 438   return jcontents;
 439 }
 440
 441 JNIEXPORT void JNICALL
 442 Java_gnu_java_awt_peer_gtk_GtkTextComponentPeer_setText
 443   (JNIEnv *env, jobject obj, jstring contents)
 444 {
 445   void *ptr;
 446   const char *str;
 447   GtkWidget *text = NULL;   // type of GtkTextView (TextArea)
 448   GtkTextBuffer *buf;
 449
 450   ptr = NSA_GET_PTR (env, obj);
 451   str = (*env)->GetStringUTFChars (env, contents, NULL);
 452
 453   gdk_threads_enter ();
 454
 455   if (GTK_IS_EDITABLE (ptr))
 456     {
 457       gtk_entry_set_text (GTK_ENTRY (ptr), str);
 458     }
 459   else
 460     {
 461       if (GTK_IS_SCROLLED_WINDOW (ptr))
 462         {
 463           text = GTK_WIDGET (GTK_TEXT_VIEW (GTK_SCROLLED_WINDOW (ptr)->container.child));
 464         }
 465       else if (GTK_IS_TEXT_VIEW (ptr))
 466         {
 467           text = GTK_WIDGET (ptr);
 468         }
 469
 470       if (text)
 471         {
 472           buf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text));
 473           gtk_text_buffer_set_text (buf, str, strlen (str));
 474         }
 475     }
 476
 477   gdk_threads_leave ();
 478
 479   (*env)->ReleaseStringUTFChars (env, contents, str);
 480 }
 481
 482 static void
 483 textcomponent_commit_cb (GtkIMContext *context __attribute__((unused)),
 484                          const gchar  *str,
 485                          jobject peer)
 486 {
 487   /* str is a \0-terminated UTF-8 encoded character. */
 488   gunichar2 *jc = g_utf8_to_utf16 (str, -1, NULL, NULL, NULL);
 489   GdkEvent *event = gtk_get_current_event ();
 490
 491   if (jc)
 492     (*gdk_env)->CallVoidMethod (gdk_env, peer,
 493                                 postKeyEventID,
 494                                 (jint) AWT_KEY_TYPED,
 495                                 (jlong) event->key.time,
 496                                 keyevent_state_to_awt_mods (event),
 497                                 VK_UNDEFINED,
 498                                 (jchar) jc[0],
 499                                 AWT_KEY_LOCATION_UNKNOWN);
 500   g_free (jc);
 501   gdk_event_free (event);
 502 }
 503
 504 static void
 505 textcomponent_changed_cb (GtkEditable *editable __attribute__((unused)),
 506                           jobject peer)
 507 {
 508   (*gdk_env)->CallVoidMethod (gdk_env, peer, postTextEventID);
 509 }