TerminalView | Curious view that simulates a terminal | Command Line Interface library

Something to keep in mind is that plugin development in Sublime is easier when you don't do it in a vacuum. That is to say, even if you're not interested in using someone else's solution to a problem (I often develop my own plugins rather than using an existing one, for example), looking at how someone else accomplished something similar to what you're trying to do is an invaluable learning tool.

As such, I would recommend looking not only at the TerminalView package that you mentioned, but also Terminus (which is similar but works on all platforms). Even if you're not going to use them, you can examine their code to see how they work.

That said, generally speaking, the color that text is rendered as is controlled by the color scheme that's in use in combination with the syntax definition that's applied to that particular file. The syntax uses rules to apply one or more scopes to every character in the file, and the color scheme uses rules that match those scopes to know what color to render them as.

For example, the Python.sublime-syntax file contains a rule that recognizes the word def as defining a function and applies a scope of storage.type.function.python to it. The Monokai.sublime-color-scheme file includes a rule that says that things that match storage.type.function should be displayed as italicized blue text. Thus, if you use that color scheme and edit a Python file, the word def appears blue and italicized.

Such functionality is not entirely useful for the purposes of a terminal plugin since the rules have to be able to explicitly match known text but a terminal can theoretically display anything you want. So this is not the way to go, or at least not entirely the way to go; the TerminalView package you mentioned in your original question allows you to apply a syntax if you want to, but still uses the following method overall.

Programatically, you can use the view.add_regions() API endpoint to do something similar to this, with some caveats as we'll see in just a moment.

You may have seen the effects of this API function even if you didn't know it. It can apply icons in the gutter associated with each line as well as applying graphical markup in the form of outlines, underlines, etc to text in the buffer.

For example, a linter might include a yellow circle icon in the gutter to show you lines with issues and use a colored outline around text to show you where the problem is.

One of the things it can be used for is to apply a colored region to text. In fact this is what both TerminalView and Terminus do to achieve this particular feature in their terminals. The region colors that it can apply are still controlled by the color scheme in use, however. So unless you want to be limited to only colors that exist in your current color scheme, you need to provide a custom color scheme to be used by your plugin as well.

By way of example, create a file named Test.sublime-color-scheme in your User package with the following contents:

To achieve this, we need to find what the correct command is to focus the first group. In ST, from the View menu, select Show Console, and then enter sublime.log_commands(True) Enter, followed by focusing group 1 from the menu: View -> Focus Group -> Group 1. We will see the following in the console:

command: focus_group { "group": 0 }

Now, to run this command from the command line:

The problem here is that you inherit QObject twice: first in ViewInterface hierarchy, second in QDialog hierarchy (diamond problem). Try using virtual inheritance for your FancyView and TextView classes (DOES NOT WORK, SINCE VIRTUAL INHERITANCE SHOULD BE USED IN ENTIRE HIERARCHY)

But there is another problem with your design: both QDialog and QPlainTextEdit inherit QWidget. To resolve this issue you may do the following:

1. Make ViewInterface abstract without inheriting from QObject. This abstract class will define the interface of your FancyView and TextView and may or may not implement some common logic.

2. Implement FancyView and TextView with multiple inheritance from QDialog and ViewInterface and from QPlainTextEdit and ViewInterface respectively.

This way you may not encounter any problems with ambiguous base class.

UPDATE:

Did not see your edit yet: indeed this would solve the issue, but another problem rises: if I do this, I can't use a ViewInterface pointer to set my QWidget. It is possible indeed, but in my opinion this is not really clean

Well, that is a real problem. An obvious solution is not to use ViewInterface* instead of QWidget*. But this means that you need to change quite a lot of code and it may actually be not that great in your case.

With respect to the given comment, I propose another solution:

1. Inherit ViewInterface from QWidget (with all desired interface functions):

just try with your hosted server link instead of window.location.origin