src/sciwrappers.c

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