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