sign - Vim Documentation

sign.txt      For Vim version 9.1.  Last change: 2024 Jul 07


                  VIM REFERENCE MANUAL    by Gordon Prieur
                                          and Bram Moolenaar


Sign Support Features                           sign-support

1. Introduction                         sign-intro
2. Commands                             sign-commands
3. Functions                            sign-functions-details

{only available when compiled with the +signs feature}

==============================================================================
1. Introduction                                 sign-intro signs

When a debugger or other IDE tool is driving an editor it needs to be able
to give specific highlights which quickly tell the user useful information
about the file.  One example of this would be a debugger which had an icon
in the left-hand column denoting a breakpoint.  Another example might be an
arrow representing the Program Counter (PC).  The sign features allow both
placement of a sign, or icon, in the left-hand side of the window and
definition of a highlight which will be applied to that line.  Displaying the
sign as an image is most likely only feasible in gvim (although Sun
Microsystem's dtterm does support this it's the only terminal emulator I know
of which does).  A text sign and the highlight should be feasible in any color
terminal emulator.

Signs and highlights are not useful just for debuggers.  Sun's Visual
WorkShop uses signs and highlights to mark build errors and SourceBrowser
hits.  Additionally, the debugger supports 8 to 10 different signs and
highlight colors, see NetBeans.

There are two steps in using signs:

1. Define the sign.  This specifies the image, text and highlighting.  For
   example, you can define a "break" sign with an image of a stop roadsign and
   text "!!".

2. Place the sign.  This specifies the file and line number where the sign is
   displayed.  A defined sign can be placed several times in different lines
   and files.

                                                        sign-column
When signs are defined for a file, Vim will automatically add a column of two
characters to display them in.  When the last sign is unplaced the column
disappears again.  This behavior can be changed with the 'signcolumn' option.

The color of the column is set with the SignColumn highlight group
hl-SignColumn.  Example to set the color:


If 'cursorline' is enabled, then the CursorLineSign highlight group is used
hl-CursorLineSign.
                                                        sign-identifier
Each placed sign is identified by a number called the sign identifier. This
identifier is used to jump to the sign or to remove the sign. The identifier
is assigned when placing the sign using the :sign-place command or the
sign_place() function. Each sign identifier should be a unique number. If
multiple placed signs use the same identifier, then jumping to or removing a
sign becomes unpredictable. To avoid overlapping identifiers, sign groups can
be used. The sign_place() function can be called with a zero sign identifier
to allocate the next available identifier.

                                                        sign-group
Each placed sign can be assigned to either the global group or a named group.
When placing a sign, if a group name is not supplied, or an empty string is
used, then the sign is placed in the global group. Otherwise the sign is
placed in the named group. The sign identifier is unique within a group. The
sign group allows Vim plugins to use unique signs without interfering with
other plugins using signs.

To place a sign in a popup window the group name must start with "PopUp".
Other signs will not show in a popup window.  The group name "PopUpMenu" is
used by popup windows where 'cursorline' is set.

                                                        sign-priority
Each placed sign is assigned a priority value. When multiple signs are placed
on the same line, the attributes of the sign with the highest priority is used
independently of the sign group. The default priority for a sign is 10, this
value can be changed for different signs by specifying a different value at
definition time.  The priority is assigned at the time of placing a sign.

When two signs with the same priority are present, and one has an icon or text
in the signcolumn while the other has line highlighting, then both are
displayed.

When the line on which the sign is placed is deleted, the sign is moved to the
next line (or the last line of the buffer, if there is no next line).  When
the delete is undone the sign does not move back.

When a sign with line highlighting and 'cursorline' highlighting are both
present, if the priority is 100 or more then the sign highlighting takes
precedence, otherwise the 'cursorline' highlighting.

==============================================================================
2. Commands                                     sign-commands :sig :sign

Here is an example that places a sign "piet", displayed with the text ">>", in
line 23 of the current file:

And here is the command to delete it again:

Note that the ":sign" command cannot be followed by another command or a
comment.  If you do need that, use the :execute command.


DEFINING A SIGN.                        :sign-define E255 E160 E612

See sign_define() for the equivalent Vim script function.

:sign define {name} {argument}...
                Define a new sign or set attributes for an existing sign.
                The {name} can either be a number (all digits) or a name
                starting with a non-digit.  Leading zeros are ignored, thus
                "0012", "012" and "12" are considered the same name.
                About 120 different signs can be defined.

                Accepted arguments:

        icon={bitmap}
                Define the file name where the bitmap can be found.  Should be
                a full path.  The bitmap should fit in the place of two
                characters.  This is not checked.  If the bitmap is too big it
                will cause redraw problems.  Only GTK 2 can scale the bitmap
                to fit the space available.
                        toolkit         supports
                        GTK 1           pixmap (.xpm)
                        GTK 2           many
                        Motif           pixmap (.xpm)
                        Win32           .bmp, .ico, .cur
                                        pixmap (.xpm) +xpm_w32
        priority={prio}
                Default priority for the sign, see sign-priority.

        linehl={group}
                Highlighting group used for the whole line the sign is placed
                in.  Most useful is defining a background color.

        numhl={group}
                Highlighting group used for the line number on the line where
                the sign is placed.  Overrides hl-LineNr, hl-LineNrAbove,
                hl-LineNrBelow, and hl-CursorLineNr.

        text={text}                                             E239
                Define the text that is displayed when there is no icon or the
                GUI is not being used.  Only printable characters are allowed
                and they must occupy one or two display cells.

        texthl={group}
                Highlighting group used for the text item.

        culhl={group}
                Highlighting group used for the text item when the cursor is
                on the same line as the sign and 'cursorline' is enabled.

        Example:


DELETING A SIGN                                         :sign-undefine E155

See sign_undefine() for the equivalent Vim script function.

:sign undefine {name}
                Deletes a previously defined sign.  If signs with this {name}
                are still placed this will cause trouble.

                Example:


LISTING SIGNS                                           :sign-list E156

See sign_getdefined() for the equivalent Vim script function.

:sign list      Lists all defined signs and their attributes.

:sign list {name}
                Lists one defined sign and its attributes.


PLACING SIGNS                                           :sign-place E158

See sign_place() for the equivalent Vim script function.

:sign place {id} line={lnum} name={name} file={fname}
                Place sign defined as {name} at line {lnum} in file {fname}.
                                                        :sign-fname
                The file {fname} must already be loaded in a buffer.  The
                exact file name must be used, wildcards, $ENV and ~ are not
                expanded, white space must not be escaped.  Trailing white
                space is ignored.

                The sign is remembered under {id}, this can be used for
                further manipulation.  {id} must be a number.
                It's up to the user to make sure the {id} is used only once in
                each file (if it's used several times unplacing will also have
                to be done several times and making changes may not work as
                expected).

                The following optional sign attributes can be specified before
                "file=":
                        group={group}   Place sign in sign group {group}
                        priority={prio} Assign priority {prio} to sign

                By default, the sign is placed in the global sign group.

                By default, the sign is assigned a default priority of 10,
                unless specified otherwise by the sign definition.  To assign a
                different priority value, use "priority={prio}" to specify a
                value.  The priority is used to determine the sign that is
                displayed when multiple signs are placed on the same line.

                Examples:

:sign place {id} line={lnum} name={name} [buffer={nr}]
                Same, but use buffer {nr}.  If the buffer argument is not
                given, place the sign in the current buffer.

                Example:

                                                        E885
:sign place {id} name={name} file={fname}
                Change the placed sign {id} in file {fname} to use the defined
                sign {name}.  See remark above about {fname} :sign-fname.
                This can be used to change the displayed sign without moving
                it (e.g., when the debugger has stopped at a breakpoint).

                The optional "group={group}" attribute can be used before
                "file=" to select a sign in a particular group.  The optional
                "priority={prio}" attribute can be used to change the priority
                of an existing sign.

                Example:

:sign place {id} name={name} [buffer={nr}]
                Same, but use buffer {nr}.  If the buffer argument is not
                given, use the current buffer.

                Example:


REMOVING SIGNS                                          :sign-unplace E159

See sign_unplace() for the equivalent Vim script function.

:sign unplace {id} file={fname}
                Remove the previously placed sign {id} from file {fname}.
                See remark above about {fname} :sign-fname.

:sign unplace {id} group={group} file={fname}
                Same but remove the sign {id} in sign group {group}.

:sign unplace {id} group=* file={fname}
                Same but remove the sign {id} from all the sign groups.

:sign unplace * file={fname}
                Remove all placed signs in file {fname}.

:sign unplace * group={group} file={fname}
                Remove all placed signs in group {group} from file {fname}.

:sign unplace * group=* file={fname}
                Remove all placed signs in all the groups from file {fname}.

:sign unplace {id} buffer={nr}
                Remove the previously placed sign {id} from buffer {nr}.

:sign unplace {id} group={group} buffer={nr}
                Remove the previously placed sign {id} in group {group} from
                buffer {nr}.

:sign unplace {id} group=* buffer={nr}
                Remove the previously placed sign {id} in all the groups from
                buffer {nr}.

:sign unplace * buffer={nr}
                Remove all placed signs in buffer {nr}.

:sign unplace * group={group} buffer={nr}
                Remove all placed signs in group {group} from buffer {nr}.

:sign unplace * group=* buffer={nr}
                Remove all placed signs in all the groups from buffer {nr}.

:sign unplace {id}
                Remove the previously placed sign {id} from all files it
                appears in.

:sign unplace {id} group={group}
                Remove the previously placed sign {id} in group {group} from
                all files it appears in.

:sign unplace {id} group=*
                Remove the previously placed sign {id} in all the groups from
                all the files it appears in.

:sign unplace *
                Remove all placed signs in the global group from all the files.

:sign unplace * group={group}
                Remove all placed signs in group {group} from all the files.

:sign unplace * group=*
                Remove all placed signs in all the groups from all the files.

:sign unplace
                Remove a placed sign at the cursor position. If multiple signs
                are placed in the line, then only one is removed.

:sign unplace group={group}
                Remove a placed sign in group {group} at the cursor
                position.

:sign unplace group=*
                Remove a placed sign in any group at the cursor position.


LISTING PLACED SIGNS                                    :sign-place-list

See sign_getplaced() for the equivalent Vim script function.

:sign place file={fname}
                List signs placed in file {fname}.
                See remark above about {fname} :sign-fname.

:sign place group={group} file={fname}
                List signs in group {group} placed in file {fname}.

:sign place group=* file={fname}
                List signs in all the groups placed in file {fname}.

:sign place buffer={nr}
                List signs placed in buffer {nr}.

:sign place group={group} buffer={nr}
                List signs in group {group} placed in buffer {nr}.

:sign place group=* buffer={nr}
                List signs in all the groups placed in buffer {nr}.

:sign place     List placed signs in the global group in all files.

:sign place group={group}
                List placed signs with sign group {group} in all files.

:sign place group=*
                List placed signs in all sign groups in all files.


JUMPING TO A SIGN                                       :sign-jump E157

See sign_jump() for the equivalent Vim script function.

:sign jump {id} file={fname}
                Open the file {fname} or jump to the window that contains
                {fname} and position the cursor at sign {id}.
                See remark above about {fname} :sign-fname.
                If the file isn't displayed in window and the current file can
                not be abandoned this fails.

:sign jump {id} group={group} file={fname}
                Same but jump to the sign in group {group}

:sign jump {id} [buffer={nr}]                                   E934
                Same, but use buffer {nr}.  This fails if buffer {nr} does not
                have a name. If the buffer argument is not given, use the
                current buffer.

:sign jump {id} group={group} [buffer={nr}]
                Same but jump to the sign in group {group}


==============================================================================
3. Functions                                    sign-functions-details

sign_define({name} [, {dict}])                          sign_define()
sign_define({list})
                Define a new sign named {name} or modify the attributes of an
                existing sign.  This is similar to the :sign-define command.

                Prefix {name} with a unique text to avoid name collisions.
                There is no {group} like with placing signs.

                The {name} can be a String or a Number.  The optional {dict}
                argument specifies the sign attributes.  The following values
                are supported:
                   icon         full path to the bitmap file for the sign.
                   linehl       highlight group used for the whole line the
                                sign is placed in.
                   priority     default priority value of the sign
                   numhl        highlight group used for the line number where
                                the sign is placed.
                   text         text that is displayed when there is no icon
                                or the GUI is not being used.
                   texthl       highlight group used for the text item
                   culhl        highlight group used for the text item when
                                the cursor is on the same line as the sign and
                                'cursorline' is enabled.

                If the sign named {name} already exists, then the attributes
                of the sign are updated.

                The one argument {list} can be used to define a list of signs.
                Each list item is a dictionary with the above items in {dict}
                and a "name" item for the sign name.

                Returns 0 on success and -1 on failure.  When the one argument
                {list} is used, then returns a List of values one for each
                defined sign.

                Examples:

                Can also be used as a method:

                Return type: Number


sign_getdefined([{name}])                               sign_getdefined()
                Get a list of defined signs and their attributes.
                This is similar to the :sign-list command.

                If the {name} is not supplied, then a list of all the defined
                signs is returned. Otherwise the attribute of the specified
                sign is returned.

                Each list item in the returned value is a dictionary with the
                following entries:
                   icon         full path to the bitmap file of the sign
                   linehl       highlight group used for the whole line the
                                sign is placed in; not present if not set
                   name         name of the sign
                   priority     default priority value of the sign
                   numhl        highlight group used for the line number where
                                the sign is placed; not present if not set
                   text         text that is displayed when there is no icon
                                or the GUI is not being used.
                   texthl       highlight group used for the text item; not
                                present if not set
                   culhl        highlight group used for the text item when
                                the cursor is on the same line as the sign and
                                'cursorline' is enabled; not present if not
                                set

                Returns an empty List if there are no signs and when {name} is
                not found.

                Examples:


                Can also be used as a method:

                Return type: list<dict<string>> or list<any>


sign_getplaced([{buf} [, {dict}]])                      sign_getplaced()
                Return a list of signs placed in a buffer or all the buffers.
                This is similar to the :sign-place-list command.

                If the optional buffer name {buf} is specified, then only the
                list of signs placed in that buffer is returned.  For the use
                of {buf}, see bufname(). The optional {dict} can contain
                the following entries:
                   group        select only signs in this group
                   id           select sign with this identifier
                   lnum         select signs placed in this line. For the use
                                of {lnum}, see line().
                If {group} is '*', then signs in all the groups including the
                global group are returned. If {group} is not supplied or is an
                empty string, then only signs in the global group are
                returned.  If no arguments are supplied, then signs in the
                global group placed in all the buffers are returned.
                See sign-group.

                Each list item in the returned value is a dictionary with the
                following entries:
                        bufnr   number of the buffer with the sign
                        signs   list of signs placed in {bufnr}. Each list
                                item is a dictionary with the below listed
                                entries

                The dictionary for each sign contains the following entries:
                        group    sign group. Set to '' for the global group.
                        id       identifier of the sign
                        lnum     line number where the sign is placed
                        name     name of the defined sign
                        priority sign priority

                The returned signs in a buffer are ordered by their line
                number and priority.

                Returns an empty list on failure or if there are no placed
                signs.

                Examples:






                Can also be used as a method:

                Return type: list<dict<any>>


sign_jump({id}, {group}, {buf})                         sign_jump()
                Open the buffer {buf} or jump to the window that contains
                {buf} and position the cursor at sign {id} in group {group}.
                This is similar to the :sign-jump command.

                If {group} is an empty string, then the global group is used.
                For the use of {buf}, see bufname().

                Returns the line number of the sign. Returns -1 if the
                arguments are invalid.

                Example:

                Can also be used as a method:

                Return type: Number


                                                        sign_place()
sign_place({id}, {group}, {name}, {buf} [, {dict}])
                Place the sign defined as {name} at line {lnum} in file or
                buffer {buf} and assign {id} and {group} to sign.  This is
                similar to the :sign-place command.

                If the sign identifier {id} is zero, then a new identifier is
                allocated.  Otherwise the specified number is used. {group} is
                the sign group name. To use the global sign group, use an
                empty string.  {group} functions as a namespace for {id}, thus
                two groups can use the same IDs. Refer to sign-identifier
                and sign-group for more information.

                {name} refers to a defined sign.
                {buf} refers to a buffer name or number. For the accepted
                values, see bufname().

                The optional {dict} argument supports the following entries:
                        lnum            line number in the file or buffer
                                        {buf} where the sign is to be placed.
                                        For the accepted values, see line().
                        priority        priority of the sign. See
                                        sign-priority for more information.

                If the optional {dict} is not specified, then it modifies the
                placed sign {id} in group {group} to use the defined sign
                {name}.

                Returns the sign identifier on success and -1 on failure.

                Examples:




                Can also be used as a method:

                Return type: Number


sign_placelist({list})                          sign_placelist()
                Place one or more signs.  This is similar to the
                sign_place() function.  The {list} argument specifies the
                List of signs to place. Each list item is a dict with the
                following sign attributes:
                    buffer      Buffer name or number. For the accepted
                                values, see bufname().
                    group       Sign group. {group} functions as a namespace
                                for {id}, thus two groups can use the same
                                IDs. If not specified or set to an empty
                                string, then the global group is used.   See
                                sign-group for more information.
                    id          Sign identifier. If not specified or zero,
                                then a new unique identifier is allocated.
                                Otherwise the specified number is used. See
                                sign-identifier for more information.
                    lnum        Line number in the buffer where the sign is to
                                be placed. For the accepted values, see
                                line().
                    name        Name of the sign to place. See sign_define()
                                for more information.
                    priority    Priority of the sign. When multiple signs are
                                placed on a line, the sign with the highest
                                priority is used. If not specified, the
                                default value of 10 is used, unless specified
                                otherwise by the sign definition. See
                                sign-priority for more information.

                If {id} refers to an existing sign, then the existing sign is
                modified to use the specified {name} and/or {priority}.

                Returns a List of sign identifiers. If failed to place a
                sign, the corresponding list item is set to -1.

                Examples:


                Can also be used as a method:

                Return type: Number


sign_undefine([{name}])                                 sign_undefine()
sign_undefine({list})
                Deletes a previously defined sign {name}. This is similar to
                the :sign-undefine command. If {name} is not supplied, then
                deletes all the defined signs.

                The one argument {list} can be used to undefine a list of
                signs. Each list item is the name of a sign.

                Returns 0 on success and -1 on failure.  For the one argument
                {list} call, returns a list of values one for each undefined
                sign.

                Examples:



                Can also be used as a method:

                Return type: Number


sign_unplace({group} [, {dict}])                        sign_unplace()
                Remove a previously placed sign in one or more buffers.  This
                is similar to the :sign-unplace command.

                {group} is the sign group name. To use the global sign group,
                use an empty string.  If {group} is set to '*', then all the
                groups including the global group are used.
                The signs in {group} are selected based on the entries in
                {dict}.  The following optional entries in {dict} are
                supported:
                        buffer  buffer name or number. See bufname().
                        id      sign identifier
                If {dict} is not supplied, then all the signs in {group} are
                removed.

                Returns 0 on success and -1 on failure.

                Examples:








                Can also be used as a method:

                Return type: Number


sign_unplacelist({list})                                sign_unplacelist()
                Remove previously placed signs from one or more buffers.  This
                is similar to the sign_unplace() function.

                The {list} argument specifies the List of signs to remove.
                Each list item is a dict with the following sign attributes:
                    buffer      buffer name or number. For the accepted
                                values, see bufname(). If not specified,
                                then the specified sign is removed from all
                                the buffers.
                    group       sign group name. If not specified or set to an
                                empty string, then the global sign group is
                                used. If set to '*', then all the groups
                                including the global group are used.
                    id          sign identifier. If not specified, then all
                                the signs in the specified group are removed.

                Returns a List where an entry is set to 0 if the corresponding
                sign was successfully removed or -1 on failure.

                Example:

                Can also be used as a method:

                Return type: list<number> or list<any>

 vim:tw=78:ts=8:noet:ft=help:norl: