src/sciwrappers.c

   1 /*
   2  *      sciwrappers.c - this file is part of Geany, a fast and lightweight IDE
   3  *
   4  *      Copyright 2005 The Geany contributors
   5  *
   6  *      This program 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 of the License, or
   9  *      (at your option) any later version.
  10  *
  11  *      This program is distributed in the hope that it will be useful,
  12  *      but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *      GNU General Public License for more details.
  15  *
  16  *      You should have received a copy of the GNU General Public License along
  17  *      with this program; if not, write to the Free Software Foundation, Inc.,
  18  *      51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  19  */
  20
  21 /** @file sciwrappers.h
  22  * Wrapper functions for the Scintilla editor widget @c SCI_* messages.
  23  * You should also check the http://scintilla.org documentation, as it is more detailed.
  24  *
  25  * To get Scintilla notifications, use the
  26  * @link pluginsignals.c @c "editor-notify" signal @endlink.
  27  *
  28  * @note These functions were originally from the cssed project
  29  * (http://cssed.sf.net, thanks).
  30  * @see scintilla_send_message().
  31  */
  32
  33 #ifdef HAVE_CONFIG_H
  34 # include "config.h"
  35 #endif
  36
  37 #include "sciwrappers.h"
  38 #include <Lexilla.h> /* ILexer5 */
  39
  40 #include "utils.h"
  41
  42 #include <string.h>
  43
  44
  45 #ifndef NDEBUG
  46
  47 sptr_t sci_send_message_internal (const gchar *file, guint line, ScintillaObject *sci,
  48         guint msg, uptr_t wparam, sptr_t lparam)
  49 {
  50         sptr_t result;
  51         gint status;
  52
  53         scintilla_send_message(sci, SCI_SETSTATUS, 0, 0);
  54         result = scintilla_send_message(sci, msg, wparam, lparam);
  55         status = scintilla_send_message(sci, SCI_GETSTATUS, 0, 0);
  56
  57         if (status != 0)
  58         {
  59                 const gchar *sub_msg = "unknown";
  60                 switch (status)
  61                 {
  62                         case SC_STATUS_FAILURE:
  63                                 sub_msg = "generic failure";
  64                                 break;
  65                         case SC_STATUS_BADALLOC:
  66                                 sub_msg = "memory is exhausted";
  67                                 break;
  68                         case SC_STATUS_WARN_REGEX:
  69                                 sub_msg = "regular expression is invalid";
  70                                 break;
  71                         default:
  72                                 if (status >= SC_STATUS_WARN_START)
  73                                         sub_msg = "unknown warning";
  74                                 else
  75                                         sub_msg = "unknown failure";
  76                                 break;
  77                 }
  78 #define SCI_STATUS_FORMAT_STRING "%s:%u: scintilla has non-zero status " \
  79                         "code '%d' after sending message '%u' to instance '%p' with " \
  80                         "wParam='%lu' and lParam='%ld': %s"
  81                 if (status >= SC_STATUS_WARN_START)
  82                 {
  83                         g_warning(SCI_STATUS_FORMAT_STRING, file, line, status, msg,
  84                                 (gpointer)sci, wparam, lparam, sub_msg);
  85                 }
  86                 else
  87                 {
  88                         g_critical(SCI_STATUS_FORMAT_STRING, file, line, status, msg,
  89                                 (gpointer)sci, wparam, lparam, sub_msg);
  90                 }
  91         }
  92
  93         return result;
  94 }
  95 #endif
  96
  97
  98 /* line numbers visibility */
  99 void sci_set_line_numbers(ScintillaObject *sci, gboolean set)
 100 {
 101         if (set)
 102         {
 103                 gchar tmp_str[15];
 104                 gint len = (gint) SSM(sci, SCI_GETLINECOUNT, 0, 0);
 105                 gint width;
 106
 107                 g_snprintf(tmp_str, 15, "_%d", len);
 108                 width = sci_text_width(sci, STYLE_LINENUMBER, tmp_str);
 109                 SSM(sci, SCI_SETMARGINWIDTHN, 0, width);
 110                 SSM(sci, SCI_SETMARGINSENSITIVEN, 0, FALSE); /* use default behaviour */
 111         }
 112         else
 113         {
 114                 SSM(sci, SCI_SETMARGINWIDTHN, 0, 0);
 115         }
 116 }
 117
 118
 119 void sci_set_mark_long_lines(ScintillaObject *sci, gint type, gint column, const gchar *colour)
 120 {
 121         glong colour_val = utils_parse_color_to_bgr(colour); /* Scintilla uses a "long" value */
 122
 123         if (column == 0)
 124                 type = 2;
 125         switch (type)
 126         {
 127                 case 0:
 128                 {
 129                         SSM(sci, SCI_SETEDGEMODE, EDGE_LINE, 0);
 130                         break;
 131                 }
 132                 case 1:
 133                 {
 134                         SSM(sci, SCI_SETEDGEMODE, EDGE_BACKGROUND, 0);
 135                         break;
 136                 }
 137                 case 2:
 138                 {
 139                         SSM(sci, SCI_SETEDGEMODE, EDGE_NONE, 0);
 140                         return;
 141                 }
 142         }
 143         SSM(sci, SCI_SETEDGECOLUMN, (uptr_t) column, 0);
 144         SSM(sci, SCI_SETEDGECOLOUR, (uptr_t) colour_val, 0);
 145 }
 146
 147
 148 /* Calls SCI_TEXTHEIGHT but tries very hard to cache the result as it's a very
 149  * expensive operation */
 150 static gint sci_text_height_cached(ScintillaObject *sci)
 151 {
 152         struct height_spec {
 153                 gchar *font;
 154                 gint size;
 155                 gint zoom;
 156                 gint extra;
 157         };
 158         static struct height_spec cache = {0};
 159         static gint cache_value = 0;
 160         struct height_spec current;
 161
 162         current.font = sci_get_string(sci, SCI_STYLEGETFONT, 0);
 163         current.size = SSM(sci, SCI_STYLEGETSIZEFRACTIONAL, 0, 0);
 164         current.zoom = SSM(sci, SCI_GETZOOM, 0, 0);
 165         current.extra = SSM(sci, SCI_GETEXTRAASCENT, 0, 0) + SSM(sci, SCI_GETEXTRADESCENT, 0, 0);
 166
 167         if (g_strcmp0(current.font, cache.font) == 0 &&
 168                 current.size == cache.size &&
 169                 current.zoom == cache.zoom &&
 170                 current.extra == cache.extra)
 171         {
 172                 g_free(current.font);
 173         }
 174         else
 175         {
 176                 g_free(cache.font);
 177                 cache = current;
 178
 179                 cache_value = SSM(sci, SCI_TEXTHEIGHT, 0, 0);
 180         }
 181
 182         return cache_value;
 183 }
 184
 185 /* compute margin width based on ratio of line height */
 186 static gint margin_width_from_line_height(ScintillaObject *sci, gdouble ratio, gint threshold)
 187 {
 188         const gint line_height = sci_text_height_cached(sci);
 189         gint width;
 190
 191         width = line_height * ratio;
 192         /* round down to an even size */
 193         width = width - (width % 2);
 194         /* if under threshold, just use the line height */
 195         if (width < threshold)
 196                 width = MIN(threshold, line_height);
 197
 198         return width;
 199 }
 200
 201
 202 /* symbol margin visibility */
 203 void sci_set_symbol_margin(ScintillaObject *sci, gboolean set)
 204 {
 205         if (set)
 206         {
 207                 const gint width = margin_width_from_line_height(sci, 0.88, 16);
 208
 209                 SSM(sci, SCI_SETMARGINWIDTHN, 1, width);
 210                 SSM(sci, SCI_SETMARGINSENSITIVEN, 1, TRUE);
 211         }
 212         else
 213         {
 214                 SSM(sci, SCI_SETMARGINWIDTHN, 1, 0);
 215                 SSM(sci, SCI_SETMARGINSENSITIVEN, 1, FALSE);
 216         }
 217 }
 218
 219
 220 /* folding margin visibility */
 221 void sci_set_folding_margin_visible(ScintillaObject *sci, gboolean set)
 222 {
 223         if (set)
 224         {
 225                 const gint width = margin_width_from_line_height(sci, 0.66, 12);
 226
 227                 SSM(sci, SCI_SETMARGINWIDTHN, 2, width);
 228                 SSM(sci, SCI_SETMARGINSENSITIVEN, 2, TRUE);
 229         }
 230         else
 231         {
 232                 SSM(sci, SCI_SETMARGINSENSITIVEN, 2, FALSE);
 233                 SSM(sci, SCI_SETMARGINWIDTHN, 2, 0);
 234         }
 235 }
 236
 237
 238 /* end of lines */
 239 void sci_set_visible_eols(ScintillaObject *sci, gboolean set)
 240 {
 241         SSM(sci, SCI_SETVIEWEOL, set != FALSE, 0);
 242 }
 243
 244
 245 void sci_set_visible_white_spaces(ScintillaObject *sci, gboolean set)
 246 {
 247         if (set)
 248                 SSM(sci, SCI_SETVIEWWS, SCWS_VISIBLEALWAYS, 0);
 249         else
 250                 SSM(sci, SCI_SETVIEWWS, SCWS_INVISIBLE, 0);
 251 }
 252
 253
 254 void sci_set_lines_wrapped(ScintillaObject *sci, gboolean set)
 255 {
 256         if (set)
 257                 SSM(sci, SCI_SETWRAPMODE, SC_WRAP_WORD, 0);
 258         else
 259                 SSM(sci, SCI_SETWRAPMODE, SC_WRAP_NONE, 0);
 260 }
 261
 262
 263 gint sci_get_eol_mode(ScintillaObject *sci)
 264 {
 265         return (gint) SSM(sci, SCI_GETEOLMODE, 0, 0);
 266 }
 267
 268
 269 void sci_set_eol_mode(ScintillaObject *sci, gint eolmode)
 270 {
 271         SSM(sci, SCI_SETEOLMODE, (uptr_t) eolmode, 0);
 272 }
 273
 274
 275 void sci_convert_eols(ScintillaObject *sci, gint eolmode)
 276 {
 277         SSM(sci, SCI_CONVERTEOLS, (uptr_t) eolmode, 0);
 278 }
 279
 280
 281 void sci_add_text(ScintillaObject *sci, const gchar *text)
 282 {
 283         if (text != NULL)
 284         { /* if null text is passed scintilla will segfault */
 285                 SSM(sci, SCI_ADDTEXT, strlen(text), (sptr_t) text);
 286         }
 287 }
 288
 289
 290 /** Sets all text.
 291  * @param sci Scintilla widget.
 292  * @param text Text. */
 293 GEANY_API_SYMBOL
 294 void sci_set_text(ScintillaObject *sci, const gchar *text)
 295 {
 296         if( text != NULL ){ /* if null text is passed to scintilla will segfault */
 297                 SSM(sci, SCI_SETTEXT, 0, (sptr_t) text);
 298         }
 299 }
 300
 301
 302 gboolean sci_can_undo(ScintillaObject *sci)
 303 {
 304         return SSM(sci, SCI_CANUNDO, 0, 0) != FALSE;
 305 }
 306
 307
 308 gboolean sci_can_redo(ScintillaObject *sci)
 309 {
 310         return SSM(sci, SCI_CANREDO, 0, 0) != FALSE;
 311 }
 312
 313
 314 void sci_undo(ScintillaObject *sci)
 315 {
 316         if (sci_can_undo(sci))
 317                 SSM(sci, SCI_UNDO, 0, 0);
 318 }
 319
 320
 321 void sci_redo(ScintillaObject *sci)
 322 {
 323         if (sci_can_redo(sci))
 324                 SSM(sci, SCI_REDO, 0, 0);
 325 }
 326
 327
 328 /** Begins grouping a set of edits together as one Undo action.
 329  * You must call sci_end_undo_action() after making your edits.
 330  * @param sci Scintilla @c GtkWidget. */
 331 GEANY_API_SYMBOL
 332 void sci_start_undo_action(ScintillaObject *sci)
 333 {
 334         SSM(sci, SCI_BEGINUNDOACTION, 0, 0);
 335 }
 336
 337
 338 /** Ends grouping a set of edits together as one Undo action.
 339  * @param sci Scintilla @c GtkWidget.
 340  * @see sci_start_undo_action(). */
 341 GEANY_API_SYMBOL
 342 void sci_end_undo_action(ScintillaObject *sci)
 343 {
 344         SSM(sci, SCI_ENDUNDOACTION, 0, 0);
 345 }
 346
 347
 348 void sci_set_undo_collection(ScintillaObject *sci, gboolean set)
 349 {
 350         SSM(sci, SCI_SETUNDOCOLLECTION, set != FALSE, 0);
 351 }
 352
 353
 354 void sci_empty_undo_buffer(ScintillaObject *sci)
 355 {
 356         SSM(sci, SCI_EMPTYUNDOBUFFER, 0, 0);
 357 }
 358
 359
 360 gboolean sci_is_modified(ScintillaObject *sci)
 361 {
 362         return (SSM(sci, SCI_GETMODIFY, 0, 0) != 0);
 363 }
 364
 365
 366 void sci_zoom_in(ScintillaObject *sci)
 367 {
 368         SSM(sci, SCI_ZOOMIN, 0, 0);
 369 }
 370
 371
 372 void sci_zoom_out(ScintillaObject *sci)
 373 {
 374         SSM(sci, SCI_ZOOMOUT, 0, 0);
 375 }
 376
 377
 378 void sci_zoom_off(ScintillaObject *sci)
 379 {
 380         SSM(sci, SCI_SETZOOM, 0, 0);
 381 }
 382
 383
 384 /** Sets a line marker.
 385  * @param sci Scintilla widget.
 386  * @param line_number Line number.
 387  * @param marker Marker number. */
 388 GEANY_API_SYMBOL
 389 void sci_set_marker_at_line(ScintillaObject *sci, gint line_number, gint marker)
 390 {
 391         SSM(sci, SCI_MARKERADD, (uptr_t) line_number, marker);
 392 }
 393
 394
 395 /** Deletes a line marker.
 396  * @param sci Scintilla widget.
 397  * @param line_number Line number.
 398  * @param marker Marker number. */
 399 GEANY_API_SYMBOL
 400 void sci_delete_marker_at_line(ScintillaObject *sci, gint line_number, gint marker)
 401 {
 402         SSM(sci, SCI_MARKERDELETE, (uptr_t) line_number, marker);
 403 }
 404
 405
 406 /** Checks if a line has a marker set.
 407  * @param sci Scintilla widget.
 408  * @param line Line number.
 409  * @param marker Marker number.
 410  * @return Whether it's set. */
 411 GEANY_API_SYMBOL
 412 gboolean sci_is_marker_set_at_line(ScintillaObject *sci, gint line, gint marker)
 413 {
 414         gint state;
 415
 416         state = (gint) SSM(sci, SCI_MARKERGET, (uptr_t) line, 0);
 417         return (state & (1 << marker));
 418 }
 419
 420
 421 void sci_toggle_marker_at_line(ScintillaObject *sci, gint line, gint marker)
 422 {
 423         gboolean set = sci_is_marker_set_at_line(sci, line, marker);
 424
 425         if (!set)
 426                 sci_set_marker_at_line(sci, line, marker);
 427         else
 428                 sci_delete_marker_at_line(sci, line, marker);
 429 }
 430
 431
 432 /* Returns the line number of the next marker that matches marker_mask, or -1.
 433  * marker_mask is a bitor of 1 << marker_index. (See MarkerHandleSet::MarkValue()).
 434  * Note: If there is a marker on the line, it returns the same line. */
 435 gint sci_marker_next(ScintillaObject *sci, gint line, gint marker_mask, gboolean wrap)
 436 {
 437         gint marker_line;
 438
 439         marker_line = (gint) SSM(sci, SCI_MARKERNEXT, (uptr_t) line, marker_mask);
 440         if (wrap && marker_line == -1)
 441                 marker_line = (gint) SSM(sci, SCI_MARKERNEXT, 0, marker_mask);
 442         return marker_line;
 443 }
 444
 445
 446 /* Returns the line number of the previous marker that matches marker_mask, or -1.
 447  * marker_mask is a bitor of 1 << marker_index. (See MarkerHandleSet::MarkValue()).
 448  * Note: If there is a marker on the line, it returns the same line. */
 449 gint sci_marker_previous(ScintillaObject *sci, gint line, gint marker_mask, gboolean wrap)
 450 {
 451         gint marker_line;
 452
 453         marker_line = (gint) SSM(sci, SCI_MARKERPREVIOUS, (uptr_t) line, marker_mask);
 454         if (wrap && marker_line == -1)
 455         {
 456                 gint len = sci_get_length(sci);
 457                 gint last_line = sci_get_line_from_position(sci, len - 1);
 458
 459                 marker_line = (gint) SSM(sci, SCI_MARKERPREVIOUS, (uptr_t) last_line, marker_mask);
 460         }
 461         return marker_line;
 462 }
 463
 464
 465 /** Gets the line number from @a position.
 466  * @param sci Scintilla widget.
 467  * @param position Position.
 468  * @return The line. */
 469 GEANY_API_SYMBOL
 470 gint sci_get_line_from_position(ScintillaObject *sci, gint position)
 471 {
 472         return (gint) SSM(sci, SCI_LINEFROMPOSITION, (uptr_t) position, 0);
 473 }
 474
 475
 476 /** Gets the column number relative to the start of the line that @a position is on.
 477  * @param sci Scintilla widget.
 478  * @param position Position.
 479  * @return The column. */
 480 GEANY_API_SYMBOL
 481 gint sci_get_col_from_position(ScintillaObject *sci, gint position)
 482 {
 483         return (gint) SSM(sci, SCI_GETCOLUMN, (uptr_t) position, 0);
 484 }
 485
 486
 487 gint sci_get_position_from_col(ScintillaObject *sci, gint line, gint col)
 488 {
 489         return (gint) SSM(sci, SCI_FINDCOLUMN, line, col);
 490 }
 491
 492
 493 /** Gets the position for the start of @a line.
 494  * @param sci Scintilla widget.
 495  * @param line Line.
 496  * @return Position. */
 497 GEANY_API_SYMBOL
 498 gint sci_get_position_from_line(ScintillaObject *sci, gint line)
 499 {
 500         return (gint) SSM(sci, SCI_POSITIONFROMLINE, (uptr_t) line, 0);
 501 }
 502
 503
 504 /** Gets the cursor position.
 505  * @param sci Scintilla widget.
 506  * @return Position. */
 507 GEANY_API_SYMBOL
 508 gint sci_get_current_position(ScintillaObject *sci)
 509 {
 510         return (gint) SSM(sci, SCI_GETCURRENTPOS, 0, 0);
 511 }
 512
 513
 514 gint sci_get_cursor_virtual_space(ScintillaObject *sci)
 515 {
 516         gint selection_mode = sci_get_selection_mode(sci);
 517
 518         return selection_mode == SC_SEL_RECTANGLE || selection_mode == SC_SEL_THIN ?
 519                 SSM(sci, SCI_GETRECTANGULARSELECTIONCARETVIRTUALSPACE, 0, 0) :
 520                 SSM(sci, SCI_GETSELECTIONNCARETVIRTUALSPACE,
 521                         SSM(sci, SCI_GETMAINSELECTION, 0, 0), 0);
 522 }
 523
 524
 525 /** Sets the cursor position.
 526  * @param sci Scintilla widget.
 527  * @param position Position.
 528  * @param scroll_to_caret Whether to scroll the cursor in view. */
 529 GEANY_API_SYMBOL
 530 void sci_set_current_position(ScintillaObject *sci, gint position, gboolean scroll_to_caret)
 531 {
 532         if (scroll_to_caret)
 533                 SSM(sci, SCI_GOTOPOS, (uptr_t) position, 0);
 534         else
 535         {
 536                 SSM(sci, SCI_SETCURRENTPOS, (uptr_t) position, 0);
 537                 SSM(sci, SCI_SETANCHOR, (uptr_t) position, 0); /* to avoid creation of a selection */
 538         }
 539         SSM(sci, SCI_CHOOSECARETX, 0, 0);
 540 }
 541
 542
 543 /* Set the cursor line without scrolling the view.
 544  * Use sci_goto_line() to also scroll. */
 545 void sci_set_current_line(ScintillaObject *sci, gint line)
 546 {
 547         gint pos = sci_get_position_from_line(sci, line);
 548         sci_set_current_position(sci, pos, FALSE);
 549 }
 550
 551
 552 /** Gets the total number of lines.
 553  * @param sci Scintilla widget.
 554  * @return The line count. */
 555 GEANY_API_SYMBOL
 556 gint sci_get_line_count(ScintillaObject *sci)
 557 {
 558         return (gint) SSM(sci, SCI_GETLINECOUNT, 0, 0);
 559 }
 560
 561
 562 /** Sets the selection start position.
 563  * @param sci Scintilla widget.
 564  * @param position Position. */
 565 GEANY_API_SYMBOL
 566 void sci_set_selection_start(ScintillaObject *sci, gint position)
 567 {
 568         SSM(sci, SCI_SETSELECTIONSTART, (uptr_t) position, 0);
 569 }
 570
 571
 572 /** Sets the selection end position.
 573  * @param sci Scintilla widget.
 574  * @param position Position. */
 575 GEANY_API_SYMBOL
 576 void sci_set_selection_end(ScintillaObject *sci, gint position)
 577 {
 578         SSM(sci, SCI_SETSELECTIONEND, (uptr_t) position, 0);
 579 }
 580
 581
 582 void sci_set_selection(ScintillaObject *sci, gint anchorPos, gint currentPos)
 583 {
 584         SSM(sci, SCI_SETSEL, (uptr_t) anchorPos, currentPos);
 585 }
 586
 587
 588 /** Gets the position at the end of a line
 589  * @param sci Scintilla widget.
 590  * @param line Line.
 591  * @return The position at the end of the line. */
 592 GEANY_API_SYMBOL
 593 gint sci_get_line_end_position(ScintillaObject *sci, gint line)
 594 {
 595         return (gint) SSM(sci, SCI_GETLINEENDPOSITION, (uptr_t) line, 0);
 596 }
 597
 598
 599 void sci_cut(ScintillaObject *sci)
 600 {
 601         SSM(sci, SCI_CUT, 0, 0);
 602 }
 603
 604
 605 void sci_copy(ScintillaObject *sci)
 606 {
 607         SSM(sci, SCI_COPY, 0, 0);
 608 }
 609
 610
 611 void sci_paste(ScintillaObject *sci)
 612 {
 613         SSM(sci, SCI_PASTE, 0, 0);
 614 }
 615
 616
 617 void sci_clear(ScintillaObject *sci)
 618 {
 619         SSM(sci, SCI_CLEAR, 0, 0);
 620 }
 621
 622
 623 /** Gets the selection start position.
 624  * @param sci Scintilla widget.
 625  * @return Position. */
 626 GEANY_API_SYMBOL
 627 gint sci_get_selection_start(ScintillaObject *sci)
 628 {
 629         return (gint) SSM(sci, SCI_GETSELECTIONSTART, 0, 0);
 630 }
 631
 632
 633 /** Gets the selection end position.
 634  * @param sci Scintilla widget.
 635  * @return Position. */
 636 GEANY_API_SYMBOL
 637 gint sci_get_selection_end(ScintillaObject *sci)
 638 {
 639         return (gint) SSM(sci, SCI_GETSELECTIONEND, 0, 0);
 640 }
 641
 642
 643 /** Replaces selection.
 644  * @param sci Scintilla widget.
 645  * @param text Text. */
 646 GEANY_API_SYMBOL
 647 void sci_replace_sel(ScintillaObject *sci, const gchar *text)
 648 {
 649         SSM(sci, SCI_REPLACESEL, 0, (sptr_t) text);
 650 }
 651
 652
 653 /** Gets the length of all text.
 654  * @param sci Scintilla widget.
 655  * @return Length. */
 656 GEANY_API_SYMBOL
 657 gint sci_get_length(ScintillaObject *sci)
 658 {
 659         return (gint) SSM(sci, SCI_GETLENGTH, 0, 0);
 660 }
 661
 662
 663 /** Gets the currently used lexer
 664  * @param sci Scintilla widget.
 665  * @returns The lexer ID
 666  */
 667 GEANY_API_SYMBOL
 668 gint sci_get_lexer(ScintillaObject *sci)
 669 {
 670         return (gint) SSM(sci, SCI_GETLEXER, 0, 0);
 671 }
 672
 673
 674 void sci_set_lexer(ScintillaObject *sci, guint lexer_id)
 675 {
 676         gint old = sci_get_lexer(sci);
 677
 678         /* TODO, LexerNameFromID() is already deprecated */
 679         ILexer5 *lexer = CreateLexer(LexerNameFromID(lexer_id));
 680
 681         SSM(sci, SCI_SETILEXER, 0, (uintptr_t) lexer);
 682
 683         if (old != (gint)lexer_id)
 684                 SSM(sci, SCI_CLEARDOCUMENTSTYLE, 0, 0);
 685 }
 686
 687
 688 /** Gets line length.
 689  * @param sci Scintilla widget.
 690  * @param line Line number.
 691  * @return Length. */
 692 GEANY_API_SYMBOL
 693 gint sci_get_line_length(ScintillaObject *sci, gint line)
 694 {
 695         return (gint) SSM(sci, SCI_LINELENGTH, (uptr_t) line, 0);
 696 }
 697
 698
 699 /* safe way to read Scintilla string into new memory.
 700  * works with any string buffer messages that follow the Windows message convention. */
 701 gchar *sci_get_string(ScintillaObject *sci, guint msg, gulong wParam)
 702 {
 703         gint size = (gint) SSM(sci, msg, wParam, 0);
 704         gchar *str = g_malloc(size + 1);
 705
 706         SSM(sci, msg, wParam, (sptr_t) str);
 707         str[size] = '\0';       /* ensure termination, needed for SCI_GETLINE */
 708         return str;
 709 }
 710
 711
 712 /** Gets line contents.
 713  * @param sci Scintilla widget.
 714  * @param line_num Line number.
 715  * @return A @c NULL-terminated copy of the line text. */
 716 GEANY_API_SYMBOL
 717 gchar *sci_get_line(ScintillaObject *sci, gint line_num)
 718 {
 719         return sci_get_string(sci, SCI_GETLINE, (gulong) line_num);
 720 }
 721
 722
 723 /** Gets all text.
 724  * @deprecated sci_get_text is deprecated and should not be used in newly-written code.
 725  * Use sci_get_contents() instead.
 726  *
 727  * @param sci Scintilla widget.
 728  * @param len Length of @a text buffer, usually sci_get_length() + 1.
 729  * @param text Text buffer; must be allocated @a len bytes for null-termination. */
 730 GEANY_API_SYMBOL
 731 void sci_get_text(ScintillaObject *sci, gint len, gchar *text)
 732 {
 733         g_return_if_fail(len > 0);
 734         SSM(sci, SCI_GETTEXT, (uptr_t) len - 1, (sptr_t) text);
 735 }
 736
 737
 738 /** Allocates and fills a buffer with text from the start of the document.
 739  * @param sci Scintilla widget.
 740  * @param buffer_len Buffer length to allocate, including the terminating
 741  * null char, e.g. sci_get_length() + 1. Alternatively use @c -1 to get all
 742  * text (since Geany 1.23).
 743  * @return A copy of the text. Should be freed when no longer needed.
 744  *
 745  * @since 1.23 (0.17)
 746  */
 747 GEANY_API_SYMBOL
 748 gchar *sci_get_contents(ScintillaObject *sci, gint buffer_len)
 749 {
 750         gchar *text;
 751
 752         g_return_val_if_fail(buffer_len != 0, NULL);
 753
 754         if (buffer_len < 0)
 755                 buffer_len = sci_get_length(sci) + 1;
 756
 757         text = g_malloc(buffer_len);
 758         SSM(sci, SCI_GETTEXT, (uptr_t) buffer_len - 1, (sptr_t) text);
 759         return text;
 760 }
 761
 762
 763 /** Gets selected text.
 764  * @deprecated sci_get_selected_text is deprecated and should not be used in newly-written code.
 765  * Use sci_get_selection_contents() instead.
 766  *
 767  * @note You must ensure NUL termination yourself, this function does
 768  * not NUL terminate the buffer itself.
 769  *
 770  * @param sci Scintilla widget.
 771  * @param text Text buffer; must be allocated sci_get_selected_text_length() + 1 bytes
 772  * for null-termination. */
 773 GEANY_API_SYMBOL
 774 void sci_get_selected_text(ScintillaObject *sci, gchar *text)
 775 {
 776         SSM(sci, SCI_GETSELTEXT, 0, (sptr_t) text);
 777 }
 778
 779
 780 /** Gets selected text.
 781  * @param sci Scintilla widget.
 782  *
 783  * @return The selected text. Should be freed when no longer needed.
 784  *
 785  * @since 0.17
 786  */
 787 GEANY_API_SYMBOL
 788 gchar *sci_get_selection_contents(ScintillaObject *sci)
 789 {
 790         return sci_get_string(sci, SCI_GETSELTEXT, 0);
 791 }
 792
 793
 794 /** Gets selected text length including the terminating NUL character.
 795  * @deprecated sci_get_selected_text_length is deprecated and should not be used in newly-written code.
 796  * Use sci_get_selected_text_length2() instead.
 797  * @param sci Scintilla widget.
 798  * @return Length. */
 799 GEANY_API_SYMBOL
 800 gint sci_get_selected_text_length(ScintillaObject *sci)
 801 {
 802         return (gint) SSM(sci, SCI_GETSELTEXT, 0, 0) + 1;
 803 }
 804
 805
 806 /** Gets selected text length without the terminating NUL character.
 807  * @param sci Scintilla widget.
 808  * @return Length. */
 809 GEANY_API_SYMBOL
 810 gint sci_get_selected_text_length2(ScintillaObject *sci)
 811 {
 812         return (gint) SSM(sci, SCI_GETSELTEXT, 0, 0);
 813 }
 814
 815
 816 gint sci_get_position_from_xy(ScintillaObject *sci, gint x, gint y, gboolean nearby)
 817 {
 818         /* for nearby return -1 if there is no character near to the x,y point. */
 819         return (gint) SSM(sci, (nearby) ? SCI_POSITIONFROMPOINTCLOSE : SCI_POSITIONFROMPOINT, (uptr_t) x, y);
 820 }
 821
 822
 823 /** Checks if a line is visible (folding may have hidden it).
 824  * @param sci Scintilla widget.
 825  * @param line Line number.
 826  * @return Whether @a line will be drawn on the screen. */
 827 GEANY_API_SYMBOL
 828 gboolean sci_get_line_is_visible(ScintillaObject *sci, gint line)
 829 {
 830         return SSM(sci, SCI_GETLINEVISIBLE, (uptr_t) line, 0) != FALSE;
 831 }
 832
 833
 834 /** Makes @a line visible (folding may have hidden it).
 835  * @param sci Scintilla widget.
 836  * @param line Line number. */
 837 GEANY_API_SYMBOL
 838 void sci_ensure_line_is_visible(ScintillaObject *sci, gint line)
 839 {
 840         SSM(sci, SCI_ENSUREVISIBLE, (uptr_t) line, 0);
 841 }
 842
 843
 844 gint sci_get_fold_level(ScintillaObject *sci, gint line)
 845 {
 846         return (gint) SSM(sci, SCI_GETFOLDLEVEL, (uptr_t) line, 0);
 847 }
 848
 849
 850 /* Get the line number of the fold point before start_line, or -1 if there isn't one */
 851 gint sci_get_fold_parent(ScintillaObject *sci, gint start_line)
 852 {
 853         return (gint) SSM(sci, SCI_GETFOLDPARENT, (uptr_t) start_line, 0);
 854 }
 855
 856
 857 void sci_toggle_fold(ScintillaObject *sci, gint line)
 858 {
 859         SSM(sci, SCI_TOGGLEFOLD, (uptr_t) line, 0);
 860 }
 861
 862
 863 gboolean sci_get_fold_expanded(ScintillaObject *sci, gint line)
 864 {
 865         return SSM(sci, SCI_GETFOLDEXPANDED, (uptr_t) line, 0) != FALSE;
 866 }
 867
 868
 869 void sci_colourise(ScintillaObject *sci, gint start, gint end)
 870 {
 871         SSM(sci, SCI_COLOURISE, (uptr_t) start, end);
 872 }
 873
 874
 875 void sci_clear_all(ScintillaObject *sci)
 876 {
 877         SSM(sci, SCI_CLEARALL, 0, 0);
 878 }
 879
 880
 881 gint sci_get_end_styled(ScintillaObject *sci)
 882 {
 883         return (gint) SSM(sci, SCI_GETENDSTYLED, 0, 0);
 884 }
 885
 886
 887 void sci_set_tab_width(ScintillaObject *sci, gint width)
 888 {
 889         SSM(sci, SCI_SETTABWIDTH, (uptr_t) width, 0);
 890 }
 891
 892
 893 /** Gets display tab width (this is not indent width, see GeanyIndentPrefs).
 894  * @param sci Scintilla widget.
 895  * @return Width.
 896  *
 897  * @since 0.15
 898  **/
 899 GEANY_API_SYMBOL
 900 gint sci_get_tab_width(ScintillaObject *sci)
 901 {
 902         return (gint) SSM(sci, SCI_GETTABWIDTH, 0, 0);
 903 }
 904
 905
 906 /** Gets a character.
 907  * @param sci Scintilla widget.
 908  * @param pos Position.
 909  * @return Char. */
 910 GEANY_API_SYMBOL
 911 gchar sci_get_char_at(ScintillaObject *sci, gint pos)
 912 {
 913         return (gchar) SSM(sci, SCI_GETCHARAT, (uptr_t) pos, 0);
 914 }
 915
 916
 917 void sci_set_savepoint(ScintillaObject *sci)
 918 {
 919         SSM(sci, SCI_SETSAVEPOINT, 0, 0);
 920 }
 921
 922
 923 void sci_set_indentation_guides(ScintillaObject *sci, gint mode)
 924 {
 925         SSM(sci, SCI_SETINDENTATIONGUIDES, (uptr_t) mode, 0);
 926 }
 927
 928
 929 void sci_use_popup(ScintillaObject *sci, gboolean enable)
 930 {
 931         SSM(sci, SCI_USEPOPUP, enable != FALSE, 0);
 932 }
 933
 934
 935 /** Checks if there's a selection.
 936  * @param sci Scintilla widget.
 937  * @return Whether a selection is present.
 938  *
 939  * @since 0.15
 940  **/
 941 GEANY_API_SYMBOL
 942 gboolean sci_has_selection(ScintillaObject *sci)
 943 {
 944         if (SSM(sci, SCI_GETSELECTIONEND, 0, 0) - SSM(sci, SCI_GETSELECTIONSTART, 0, 0))
 945                 return TRUE;
 946         else
 947                 return FALSE;
 948 }
 949
 950
 951 void sci_goto_pos(ScintillaObject *sci, gint pos, gboolean unfold)
 952 {
 953         if (unfold) SSM(sci, SCI_ENSUREVISIBLE, (uptr_t) SSM(sci, SCI_LINEFROMPOSITION, (uptr_t) pos, 0), 0);
 954         SSM(sci, SCI_GOTOPOS, (uptr_t) pos, 0);
 955 }
 956
 957
 958 void sci_set_search_anchor(ScintillaObject *sci)
 959 {
 960         SSM(sci, SCI_SEARCHANCHOR, 0, 0);
 961 }
 962
 963
 964 /* removes a selection if pos < 0 */
 965 void sci_set_anchor(ScintillaObject *sci, gint pos)
 966 {
 967         if (pos < 0)
 968                 pos = sci_get_current_position(sci);
 969
 970         SSM(sci, SCI_SETANCHOR, (uptr_t) pos, 0);
 971 }
 972
 973
 974 /** Scrolls the cursor in view.
 975  * @param sci Scintilla widget. */
 976 GEANY_API_SYMBOL
 977 void sci_scroll_caret(ScintillaObject *sci)
 978 {
 979         SSM(sci, SCI_SCROLLCARET, 0, 0);
 980 }
 981
 982
 983 void sci_scroll_columns(ScintillaObject *sci, gint columns)
 984 {
 985         SSM(sci, SCI_LINESCROLL, (uptr_t) columns, 0);
 986 }
 987
 988
 989 gint sci_search_next(ScintillaObject *sci, gint flags, const gchar *text)
 990 {
 991         /* FIXME: SCI_SEACHNEXT() actually returns long */
 992         return (gint) SSM(sci, SCI_SEARCHNEXT, (uptr_t) flags, (sptr_t) text);
 993 }
 994
 995
 996 gint sci_search_prev(ScintillaObject *sci, gint flags, const gchar *text)
 997 {
 998         /* FIXME: SCI_SEACHPREV() actually returns long */
 999         return (gint) SSM(sci, SCI_SEARCHPREV, (uptr_t) flags, (sptr_t) text);
1000 }
1001
1002
1003 /** Finds text in the document.
1004  * The @a ttf argument should be a pointer to a Sci_TextToFind structure which contains
1005  * the text to find and the range in which the text should be searched.
1006  *
1007  * Please refer to the Scintilla documentation for a more detailed description.
1008  *
1009  * @param sci Scintilla widget.
1010  * @param flags Bitmask of Scintilla search flags (@c SCFIND_*, see Scintilla documentation).
1011  * @param ttf Pointer to a TextToFind structure which contains the text to find and the range.
1012  * @return The position of the start of the found text if it succeeds, otherwise @c -1.
1013  *         The @c chrgText.cpMin and @c chrgText.cpMax members of @c TextToFind are filled in
1014  *         with the start and end positions of the found text.
1015  */
1016 GEANY_API_SYMBOL
1017 gint sci_find_text(ScintillaObject *sci, gint flags, struct Sci_TextToFind *ttf)
1018 {
1019         return (gint) SSM(sci, SCI_FINDTEXT, (uptr_t) flags, (sptr_t) ttf);
1020 }
1021
1022 /* * Sets the font for a particular style.
1023  * @param sci Scintilla widget.
1024  * @param style The style.
1025  * @param font The font name.
1026  * @param size The font (fractional) size. */
1027 void sci_set_font_fractional(ScintillaObject *sci, gint style, const gchar *font, gdouble size)
1028 {
1029         SSM(sci, SCI_STYLESETFONT, (uptr_t) style, (sptr_t) font);
1030
1031         /* Adding 0.5 is for rounding. */
1032         SSM(sci, SCI_STYLESETSIZEFRACTIONAL, (uptr_t) style, (sptr_t) (SC_FONT_SIZE_MULTIPLIER * size + 0.5));
1033 }
1034
1035 /** Sets the font for a particular style.
1036  * @param sci Scintilla widget.
1037  * @param style The style.
1038  * @param font The font name.
1039  * @param size The font size. */
1040 GEANY_API_SYMBOL
1041 void sci_set_font(ScintillaObject *sci, gint style, const gchar *font, gint size)
1042 {
1043         sci_set_font_fractional(sci, style, font, size);
1044 }
1045
1046
1047 /** Jumps to the specified line in the document.
1048  * If @a unfold is set and @a line is hidden by a fold, it is unfolded
1049  * first to ensure it is visible.
1050  * @param sci Scintilla widget.
1051  * @param line Line.
1052  * @param unfold Whether to unfold first.
1053  */
1054 GEANY_API_SYMBOL
1055 void sci_goto_line(ScintillaObject *sci, gint line, gboolean unfold)
1056 {
1057         if (unfold) SSM(sci, SCI_ENSUREVISIBLE, (uptr_t) line, 0);
1058         SSM(sci, SCI_GOTOLINE, (uptr_t) line, 0);
1059 }
1060
1061
1062 void sci_marker_delete_all(ScintillaObject *sci, gint marker)
1063 {
1064         SSM(sci, SCI_MARKERDELETEALL, (uptr_t) marker, 0);
1065 }
1066
1067
1068 /** Gets style ID at @a position.
1069  * @param sci Scintilla widget.
1070  * @param position Position.
1071  * @return Style ID. */
1072 GEANY_API_SYMBOL
1073 gint sci_get_style_at(ScintillaObject *sci, gint position)
1074 {
1075         return (gint) SSM(sci, SCI_GETSTYLEAT, (uptr_t) position, 0);
1076 }
1077
1078
1079 void sci_set_codepage(ScintillaObject *sci, gint cp)
1080 {
1081         g_return_if_fail(cp == 0 || cp == SC_CP_UTF8);
1082         SSM(sci, SCI_SETCODEPAGE, (uptr_t) cp, 0);
1083 }
1084
1085
1086 void sci_assign_cmdkey(ScintillaObject *sci, gint key, gint command)
1087 {
1088         SSM(sci, SCI_ASSIGNCMDKEY, (uptr_t) key, command);
1089 }
1090
1091
1092 void sci_clear_cmdkey(ScintillaObject *sci, gint key)
1093 {
1094         SSM(sci, SCI_CLEARCMDKEY, (uptr_t) key, 0);
1095 }
1096
1097
1098 /** Gets text between @a start and @a end.
1099  * @deprecated sci_get_text_range is deprecated and should not be used in newly-written code.
1100  * Use sci_get_contents_range() instead.
1101  *
1102  * @param sci Scintilla widget.
1103  * @param start Start.
1104  * @param end End.
1105  * @param text Text will be zero terminated and must be allocated (end - start + 1) bytes. */
1106 GEANY_API_SYMBOL
1107 void sci_get_text_range(ScintillaObject *sci, gint start, gint end, gchar *text)
1108 {
1109         struct Sci_TextRange tr;
1110         tr.chrg.cpMin = start;
1111         tr.chrg.cpMax = end;
1112         tr.lpstrText = text;
1113         SSM(sci, SCI_GETTEXTRANGE, 0, (sptr_t) &tr);
1114 }
1115
1116
1117 /** Gets text between @a start and @a end.
1118  * @param sci Scintilla widget.
1119  * @param start Start position.
1120  * @param end End position.
1121  * @return The text inside the given range. Should be freed when no longer needed.
1122  *
1123  * @since 0.17
1124  */
1125 GEANY_API_SYMBOL
1126 gchar *sci_get_contents_range(ScintillaObject *sci, gint start, gint end)
1127 {
1128         gchar *text;
1129
1130         g_return_val_if_fail(start < end, NULL);
1131
1132         text = g_malloc((gsize) (end - start) + 1);
1133         sci_get_text_range(sci, start, end, text);
1134         return text;
1135 }
1136
1137
1138 void sci_line_duplicate(ScintillaObject *sci)
1139 {
1140         SSM(sci, SCI_LINEDUPLICATE, 0, 0);
1141 }
1142
1143
1144 void sci_selection_duplicate(ScintillaObject *sci)
1145 {
1146         SSM(sci, SCI_SELECTIONDUPLICATE, 0, 0);
1147 }
1148
1149
1150 /** Inserts text.
1151  * @param sci Scintilla widget.
1152  * @param pos Position, or -1 for current.
1153  * @param text Text. */
1154 GEANY_API_SYMBOL
1155 void sci_insert_text(ScintillaObject *sci, gint pos, const gchar *text)
1156 {
1157         SSM(sci, SCI_INSERTTEXT, (uptr_t) pos, (sptr_t) text);
1158 }
1159
1160
1161 GEANY_API_SYMBOL
1162 void sci_set_target_start(ScintillaObject *sci, gint start)
1163 {
1164         SSM(sci, SCI_SETTARGETSTART, (uptr_t) start, 0);
1165 }
1166
1167
1168 GEANY_API_SYMBOL
1169 void sci_set_target_end(ScintillaObject *sci, gint end)
1170 {
1171         SSM(sci, SCI_SETTARGETEND, (uptr_t) end, 0);
1172 }
1173
1174
1175 GEANY_API_SYMBOL
1176 gint sci_replace_target(ScintillaObject *sci, const gchar *text, gboolean regex)
1177 {
1178         return (gint) SSM(sci, (regex) ? SCI_REPLACETARGETRE : SCI_REPLACETARGET, (uptr_t) -1, (sptr_t) text);
1179 }
1180
1181
1182 void sci_set_keywords(ScintillaObject *sci, guint k, const gchar *text)
1183 {
1184         SSM(sci, SCI_SETKEYWORDS, k, (sptr_t) text);
1185 }
1186
1187
1188 void sci_set_readonly(ScintillaObject *sci, gboolean readonly)
1189 {
1190         SSM(sci, SCI_SETREADONLY, readonly != FALSE, 0);
1191 }
1192
1193
1194 /** Sends Scintilla commands without any parameters.
1195  * @param sci The Scintilla @c GtkWidget.
1196  * @param cmd @c SCI_COMMAND.
1197  * @see http://scintilla.org for the documentation.
1198  *
1199  *  @since 0.16
1200  */
1201 GEANY_API_SYMBOL
1202 void sci_send_command(ScintillaObject *sci, gint cmd)
1203 {
1204         SSM(sci, cmd, 0, 0);
1205 }
1206
1207
1208 /** Gets current line number.
1209  * @param sci Scintilla widget.
1210  * @return Line number. */
1211 GEANY_API_SYMBOL
1212 gint sci_get_current_line(ScintillaObject *sci)
1213 {
1214         return (gint) SSM(sci, SCI_LINEFROMPOSITION, (uptr_t) SSM(sci, SCI_GETCURRENTPOS, 0, 0), 0);
1215 }
1216
1217
1218 /* Get number of lines partially or fully selected.
1219  * Returns 1 if there is a partial selection on the same line.
1220  * Returns 2 if a whole line is selected including the line break char(s). */
1221 gint sci_get_lines_selected(ScintillaObject *sci)
1222 {
1223         gint start = (gint) SSM(sci, SCI_GETSELECTIONSTART, 0, 0);
1224         gint end = (gint) SSM(sci, SCI_GETSELECTIONEND, 0, 0);
1225         gint line_start;
1226         gint line_end;
1227
1228         if (start == end)
1229                 return 0; /* no selection */
1230
1231         line_start = (gint) SSM(sci, SCI_LINEFROMPOSITION, (uptr_t) start, 0);
1232         line_end = (gint) SSM(sci, SCI_LINEFROMPOSITION, (uptr_t) end, 0);
1233
1234         return line_end - line_start + 1;
1235 }
1236
1237
1238 gint sci_get_first_visible_line(ScintillaObject *sci)
1239 {
1240         return (gint) SSM(sci, SCI_GETFIRSTVISIBLELINE, 0, 0);
1241 }
1242
1243
1244 /**
1245  *  Sets the current indicator. This is necessary to define an indicator for a range of text or
1246  *  clearing indicators for a range of text.
1247  *
1248  *  @param sci Scintilla widget.
1249  *  @param indic The indicator number to set.
1250  *
1251  *  @see sci_indicator_clear
1252  *
1253  *  @since 0.16
1254  */
1255 GEANY_API_SYMBOL
1256 void sci_indicator_set(ScintillaObject *sci, gint indic)
1257 {
1258         SSM(sci, SCI_SETINDICATORCURRENT, (uptr_t) indic, 0);
1259 }
1260
1261
1262 void sci_indicator_fill(ScintillaObject *sci, gint pos, gint len)
1263 {
1264         SSM(sci, SCI_INDICATORFILLRANGE, (uptr_t) pos, len);
1265 }
1266
1267
1268 /**
1269  *  Clears the currently set indicator from a range of text.
1270  *  Starting at @a pos, @a len characters long.
1271  *  In order to make this function properly, you need to set the current indicator before with
1272  *  @ref sci_indicator_set().
1273  *
1274  *  @param sci Scintilla widget.
1275  *  @param pos Starting position.
1276  *  @param len Length.
1277  *
1278  *  @since 0.16
1279  */
1280 GEANY_API_SYMBOL
1281 void sci_indicator_clear(ScintillaObject *sci, gint pos, gint len)
1282 {
1283         SSM(sci, SCI_INDICATORCLEARRANGE, (uptr_t) pos, len);
1284 }
1285
1286
1287 void sci_select_all(ScintillaObject *sci)
1288 {
1289         SSM(sci, SCI_SELECTALL, 0, 0);
1290 }
1291
1292
1293 gint sci_get_line_indent_position(ScintillaObject *sci, gint line)
1294 {
1295         return (gint) SSM(sci, SCI_GETLINEINDENTPOSITION, (uptr_t) line, 0);
1296 }
1297
1298
1299 void sci_set_autoc_max_height(ScintillaObject *sci, gint val)
1300 {
1301         SSM(sci, SCI_AUTOCSETMAXHEIGHT, (uptr_t) val, 0);
1302 }
1303
1304
1305 /** Finds a matching brace at @a pos.
1306  * @param sci Scintilla widget.
1307  * @param pos Position.
1308  * @return Matching brace position.
1309  *
1310  * @since 0.15
1311  **/
1312 GEANY_API_SYMBOL
1313 gint sci_find_matching_brace(ScintillaObject *sci, gint pos)
1314 {
1315         return (gint) SSM(sci, SCI_BRACEMATCH, (uptr_t) pos, 0);
1316 }
1317
1318
1319 gint sci_get_overtype(ScintillaObject *sci)
1320 {
1321         return (gint) SSM(sci, SCI_GETOVERTYPE, 0, 0);
1322 }
1323
1324
1325 void sci_set_tab_indents(ScintillaObject *sci, gboolean set)
1326 {
1327         SSM(sci, SCI_SETTABINDENTS, set != FALSE, 0);
1328 }
1329
1330
1331 void sci_set_use_tabs(ScintillaObject *sci, gboolean set)
1332 {
1333         SSM(sci, SCI_SETUSETABS, set != FALSE, 0);
1334 }
1335
1336
1337 gint sci_get_pos_at_line_sel_start(ScintillaObject *sci, gint line)
1338 {
1339         return (gint) SSM(sci, SCI_GETLINESELSTARTPOSITION, (uptr_t) line, 0);
1340 }
1341
1342
1343 gint sci_get_pos_at_line_sel_end(ScintillaObject *sci, gint line)
1344 {
1345         return (gint) SSM(sci, SCI_GETLINESELENDPOSITION, (uptr_t) line, 0);
1346 }
1347
1348
1349 /** Gets selection mode.
1350  * @param sci Scintilla widget.
1351  * @return Selection mode. */
1352 GEANY_API_SYMBOL
1353 gint sci_get_selection_mode(ScintillaObject *sci)
1354 {
1355         return (gint) SSM(sci, SCI_GETSELECTIONMODE, 0, 0);
1356 }
1357
1358
1359 /** Sets selection mode.
1360  * @param sci Scintilla widget.
1361  * @param mode Mode. */
1362 GEANY_API_SYMBOL
1363 void sci_set_selection_mode(ScintillaObject *sci, gint mode)
1364 {
1365         SSM(sci, SCI_SETSELECTIONMODE, (uptr_t) mode, 0);
1366 }
1367
1368
1369 void sci_set_scrollbar_mode(ScintillaObject *sci, gboolean visible)
1370 {
1371         SSM(sci, SCI_SETHSCROLLBAR, visible != FALSE, 0);
1372         SSM(sci, SCI_SETVSCROLLBAR, visible != FALSE, 0);
1373 }
1374
1375
1376 /** Sets the indentation of a line.
1377  * @param sci Scintilla widget.
1378  * @param line Line to indent.
1379  * @param indent Indentation width.
1380  *
1381  * @since 0.19
1382  */
1383 GEANY_API_SYMBOL
1384 void sci_set_line_indentation(ScintillaObject *sci, gint line, gint indent)
1385 {
1386         SSM(sci, SCI_SETLINEINDENTATION, (uptr_t) line, indent);
1387 }
1388
1389
1390 /** Gets the indentation width of a line.
1391  * @param sci Scintilla widget.
1392  * @param line Line to get the indentation from.
1393  * @return Indentation width.
1394  *
1395  * @since 0.19
1396  */
1397 GEANY_API_SYMBOL
1398 gint sci_get_line_indentation(ScintillaObject *sci, gint line)
1399 {
1400         return (gint) SSM(sci, SCI_GETLINEINDENTATION, (uptr_t) line, 0);
1401 }
1402
1403
1404 void sci_set_caret_policy_x(ScintillaObject *sci, gint policy, gint slop)
1405 {
1406         SSM(sci, SCI_SETXCARETPOLICY, (uptr_t) policy, slop);
1407 }
1408
1409
1410 void sci_set_caret_policy_y(ScintillaObject *sci, gint policy, gint slop)
1411 {
1412         SSM(sci, SCI_SETYCARETPOLICY, (uptr_t) policy, slop);
1413 }
1414
1415
1416 void sci_set_scroll_stop_at_last_line(ScintillaObject *sci, gboolean set)
1417 {
1418         SSM(sci, SCI_SETENDATLASTLINE, set != FALSE, 0);
1419 }
1420
1421
1422 void sci_cancel(ScintillaObject *sci)
1423 {
1424         SSM(sci, SCI_CANCEL, 0, 0);
1425 }
1426
1427
1428 gint sci_get_position_after(ScintillaObject *sci, gint start)
1429 {
1430         return (gint) SSM(sci, SCI_POSITIONAFTER, (uptr_t) start, 0);
1431 }
1432
1433
1434 void sci_lines_join(ScintillaObject *sci)
1435 {
1436         SSM(sci, SCI_LINESJOIN, 0, 0);
1437 }
1438
1439
1440 gint sci_text_width(ScintillaObject *sci, gint styleNumber, const gchar *text)
1441 {
1442         return (gint) SSM(sci, SCI_TEXTWIDTH, (uptr_t) styleNumber, (sptr_t) text);
1443 }
1444
1445
1446 void sci_move_selected_lines_down(ScintillaObject *sci)
1447 {
1448         SSM(sci, SCI_MOVESELECTEDLINESDOWN, 0, 0);
1449 }
1450
1451
1452 void sci_move_selected_lines_up(ScintillaObject *sci)
1453 {
1454         SSM(sci, SCI_MOVESELECTEDLINESUP, 0, 0);
1455 }
1456
1457
1458 gint sci_word_start_position(ScintillaObject *sci, gint position, gboolean onlyWordCharacters)
1459 {
1460         return SSM(sci, SCI_WORDSTARTPOSITION, position, onlyWordCharacters);
1461 }
1462
1463
1464 gint sci_word_end_position(ScintillaObject *sci, gint position, gboolean onlyWordCharacters)
1465 {
1466         return SSM(sci, SCI_WORDENDPOSITION, position, onlyWordCharacters);
1467 }