├── .python-version
├── GhostText (OSX).sublime-settings
├── messages
    ├── 1.0.6.txt
    ├── 1.0.7.txt
    ├── 1.0.0.txt
    ├── 1.0.13.txt
    ├── 1.0.8.txt
    ├── 1.0.9.txt
    ├── 1.0.11.txt
    ├── 1.0.12.txt
    ├── 1.0.5.txt
    ├── install.txt
    ├── 1.0.10.txt
    ├── 1.0.4.txt
    ├── 1.0.3.txt
    ├── 1.0.2.txt
    └── 1.0.1.txt
├── GhostTextTools
    ├── __init__.py
    ├── WindowHelper.py
    ├── OnSelectionModifiedListener.py
    └── Utils.py
├── WebSocket
    ├── AbstractOnClose.py
    ├── AbstractOnMessage.py
    ├── AbstractHandler.py
    ├── Handshake.py
    ├── Frame.py
    └── WebSocketServer.py
├── GhostText.sublime-settings
├── .gitignore
├── messages.json
├── LICENSE
├── Main.sublime-menu
├── contributing.md
├── FocusSublimeWindow.py
├── README.md
└── GhostText.py


/.python-version:
--------------------------------------------------------------------------------
1 | 3.8
2 | 


--------------------------------------------------------------------------------
/GhostText (OSX).sublime-settings:
--------------------------------------------------------------------------------
1 | {
2 |     "view_title_prefix": {
3 |         "connected": "👻🌕",
4 |         "disconnected": "👻🌘"
5 |     }
6 | }


--------------------------------------------------------------------------------
/messages/1.0.6.txt:
--------------------------------------------------------------------------------
1 | GhostText for Sublime Text v 1.0.6
2 | =====================================================
3 | 
4 | - New views are now in scratch mode.


--------------------------------------------------------------------------------
/messages/1.0.7.txt:
--------------------------------------------------------------------------------
1 | GhostText for Sublime Text v 1.0.7
2 | =====================================================
3 | 
4 | - Fixed disconnection bug on Windows machines.


--------------------------------------------------------------------------------
/messages/1.0.0.txt:
--------------------------------------------------------------------------------
1 | GhostText for Sublime Text has been released.
2 | 
3 | If you where using ChromeTextArea, the previous name of this plugin, update your Chrome extension, too.


--------------------------------------------------------------------------------
/messages/1.0.13.txt:
--------------------------------------------------------------------------------
1 | GhostText for Sublime Text v 1.0.13
2 | =====================================================
3 | 
4 | - Fixed bug occurred when WebSocket has been closed at Server side.


--------------------------------------------------------------------------------
/messages/1.0.8.txt:
--------------------------------------------------------------------------------
1 | GhostText for Sublime Text v 1.0.8
2 | =====================================================
3 | 
4 | - Bugfix, the view does not get marked as disconnected when the client closes the connection.


--------------------------------------------------------------------------------
/messages/1.0.9.txt:
--------------------------------------------------------------------------------
1 | GhostText for Sublime Text v 1.0.9
2 | =====================================================
3 | 
4 | - Bugfix, the view does not get marked as disconnected when the client closes the connection.


--------------------------------------------------------------------------------
/messages/1.0.11.txt:
--------------------------------------------------------------------------------
1 | GhostText for Sublime Text v 1.0.11
2 | =====================================================
3 | 
4 | - Bugfix in the WebSocket server, WebSocket packets with a size of exactly 127 byte let the server crash.


--------------------------------------------------------------------------------
/messages/1.0.12.txt:
--------------------------------------------------------------------------------
1 | GhostText for Sublime Text v 1.0.12
2 | =====================================================
3 | 
4 | - Bugfix in the WebSocket component, the server can now handle connection requests which are longer than 1024 bytes.


--------------------------------------------------------------------------------
/messages/1.0.5.txt:
--------------------------------------------------------------------------------
1 | GhostText for Sublime Text v 1.0.5
2 | =====================================================
3 | 
4 | - Linux users should install xdotool which provides a better window focusing behavior as wmctrl, wmctrl is not longer supported.


--------------------------------------------------------------------------------
/messages/install.txt:
--------------------------------------------------------------------------------
1 | GhostText for Sublime Text
2 | ==========================
3 | 
4 | Visit https://ghosttext.fregante.com to install the extension for your browser (Chrome, Safari, Firefox). You can find more information on the welcome page after the browser extension is installed.
5 | 


--------------------------------------------------------------------------------
/GhostTextTools/__init__.py:
--------------------------------------------------------------------------------
1 | __author__ = 'Guido Krömer'
2 | __license__ = 'MIT'
3 | __version__ = '0.1'
4 | __email__ = 'mail 64 cacodaemon 46 de'
5 | 
6 | from .OnSelectionModifiedListener import OnSelectionModifiedListener
7 | from .WindowHelper import WindowHelper
8 | from .Utils import Utils
9 | 


--------------------------------------------------------------------------------
/WebSocket/AbstractOnClose.py:
--------------------------------------------------------------------------------
 1 | from .AbstractHandler import AbstractHandler
 2 | 
 3 | 
 4 | class AbstractOnClose(AbstractHandler):
 5 |     """
 6 |     Abstract on connection close handler.
 7 |     """
 8 | 
 9 |     def on_close(self):
10 |         raise NotImplementedError("error message")
11 | 


--------------------------------------------------------------------------------
/WebSocket/AbstractOnMessage.py:
--------------------------------------------------------------------------------
 1 | from .AbstractHandler import AbstractHandler
 2 | 
 3 | 
 4 | class AbstractOnMessage(AbstractHandler):
 5 |     """
 6 |     Abstract on message handler.
 7 |     """
 8 | 
 9 |     def on_message(self, text):
10 |         raise NotImplementedError("error message")
11 | 


--------------------------------------------------------------------------------
/messages/1.0.10.txt:
--------------------------------------------------------------------------------
1 | GhostText for Sublime Text v 1.0.10
2 | =====================================================
3 | 
4 | - The new "close_view_on_disconnect" option enables auto closing of views, when the client disconnects.
5 |   It is disabled by default and can be enabled by setting the flag to true.


--------------------------------------------------------------------------------
/WebSocket/AbstractHandler.py:
--------------------------------------------------------------------------------
 1 | class AbstractHandler:
 2 |     """
 3 |     Abstract on whatever handler.
 4 |     """
 5 | 
 6 |     def __init__(self):
 7 |         self._web_socket_server = None
 8 | 
 9 |     def set_web_socket_server(self, web_socket_server):
10 |         self._web_socket_server = web_socket_server
11 | 


--------------------------------------------------------------------------------
/messages/1.0.4.txt:
--------------------------------------------------------------------------------
1 | GhostText for Sublime Text v 1.0.4
2 | =====================================================
3 | 
4 | - Connection status indicator added, the indicator prefix can be modified in the config.
5 | 
6 | - Closed views gets reused when starting a new connection, a view with a matching title has precede before any other closed view.


--------------------------------------------------------------------------------
/GhostText.sublime-settings:
--------------------------------------------------------------------------------
 1 | {
 2 |     "server_port": "4001",
 3 |     "new_window_on_connect": false,
 4 |     "close_view_on_disconnect": false,
 5 |     "default_syntax": "md",
 6 |     "host_to_syntax": {
 7 |         "sandbox.onlinephpfunctions.com": "php",
 8 |         "textarea.org": "html"
 9 |     },
10 |     "view_title_prefix": {
11 |         "connected": "☗ ●",
12 |         "disconnected": "☗ ☾"
13 |     }
14 | }


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | *.py[cod]
 2 | 
 3 | # C extensions
 4 | *.so
 5 | 
 6 | # Packages
 7 | *.egg
 8 | *.egg-info
 9 | dist
10 | build
11 | eggs
12 | parts
13 | bin
14 | var
15 | sdist
16 | develop-eggs
17 | .installed.cfg
18 | lib
19 | lib64
20 | __pycache__
21 | 
22 | # Installer logs
23 | pip-log.txt
24 | 
25 | # Unit test / coverage reports
26 | .coverage
27 | .tox
28 | nosetests.xml
29 | 
30 | # Translations
31 | *.mo
32 | 
33 | # Mr Developer
34 | .mr.developer.cfg
35 | .project
36 | .pydevproject
37 | 
38 | .idea
39 | SublimeText3Plugin/.idea
40 | 
41 | ChromeExtension.pem


--------------------------------------------------------------------------------
/messages.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"1.0.0":   "messages/1.0.0.txt",
 3 | 	"1.0.1":   "messages/1.0.1.txt",
 4 | 	"1.0.2":   "messages/1.0.2.txt",
 5 | 	"1.0.3":   "messages/1.0.3.txt",
 6 | 	"1.0.4":   "messages/1.0.4.txt",
 7 | 	"1.0.5":   "messages/1.0.5.txt",
 8 | 	"1.0.6":   "messages/1.0.6.txt",
 9 | 	"1.0.7":   "messages/1.0.7.txt",
10 | 	"1.0.8":   "messages/1.0.8.txt",
11 | 	"1.0.9":   "messages/1.0.9.txt",
12 | 	"1.0.10":  "messages/1.0.10.txt",
13 | 	"1.0.11":  "messages/1.0.11.txt",
14 | 	"1.0.12":  "messages/1.0.12.txt",
15 | 	"1.0.13":  "messages/1.0.13.txt",
16 | 	"install": "messages/install.txt"
17 | }
18 | 


--------------------------------------------------------------------------------
/messages/1.0.3.txt:
--------------------------------------------------------------------------------
 1 | GhostText for Sublime Text v 1.0.3
 2 | =====================================================
 3 | 
 4 | - Fixed syntax detection, instead of the full resource path only the file name is need now, please use 'Markdown.tmLanguage' and not 'Packages/MarkdownEditing/Markdown.tmLanguage' anymore.
 5 | 
 6 | - Fixed bug which lets the WebSocket sever crash when editing large text (An css file with 3k lines for example) with Ghost Text.
 7 | 
 8 | - Fixed bug on Windows which let the status HTTP sever crash.
 9 | 
10 | - Plugin reload behavior has been improved, an exception where thrown on a HTTP server stop.


--------------------------------------------------------------------------------
/messages/1.0.2.txt:
--------------------------------------------------------------------------------
 1 | SublimeTextArea has become GhostText for Sublime Text
 2 | =====================================================
 3 | 
 4 | Syntax detection by host name has been changed, now only the base name like "PHP.tmLanguage" is needed.
 5 | If a not installed syntax like "Foo.tmLanguage" gets specified you will get informed about it!
 6 | 
 7 | Usage
 8 | -----
 9 | 
10 | In Chrome, when you're in a page with a plain-text field (<textarea>), click the GhostText button in the upper-right corner to open up Sublime Text. Everything you type in the editor will be instantly updated in the browser (and vice versa).
11 | 
12 | To close the link, either close the tab in Sublime Text or click on the GhostText button again.
13 | 
14 | For more specific instructions, read this: https://github.com/Cacodaimon/GhostText-for-SublimeText/blob/master/README.md


--------------------------------------------------------------------------------
/messages/1.0.1.txt:
--------------------------------------------------------------------------------
 1 | SublimeTextArea has become GhostText for Sublime Text
 2 | =====================================================
 3 | 
 4 | We put a lot of effort to bring you GhostText, a much more polished and solid experience to write in the browser with Sublime Text.
 5 | 
 6 | Don't forget to install the updated Chrome extension:
 7 | https://chrome.google.com/webstore/detail/ghosttext/godiecgffnchndlihlpaajjcplehddca
 8 | 
 9 | Usage
10 | -----
11 | 
12 | In Chrome, when you're in a page with a plain-text field (<textarea>), click the GhostText button in the upper-right corner to open up Sublime Text. Everything you type in the editor will be instantly updated in the browser (and vice versa).
13 | 
14 | To close the link, either close the tab in Sublime Text or click on the GhostText button again.
15 | 
16 | For more specific instructions, read this: https://github.com/Cacodaimon/GhostText-for-SublimeText/blob/master/README.md


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2014 Guido Krömer
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.


--------------------------------------------------------------------------------
/Main.sublime-menu:
--------------------------------------------------------------------------------
 1 | [
 2 |     {
 3 |         "caption": "Preferences",
 4 |         "mnemonic": "n",
 5 |         "id": "preferences",
 6 |         "children":
 7 |         [
 8 |             {
 9 |                 "caption": "Package Settings",
10 |                 "mnemonic": "P",
11 |                 "id": "package-settings",
12 |                 "children":
13 |                 [
14 |                     {
15 |                         "caption": "GhostText",
16 |                         "id": "ghost-text",
17 |                         "children":
18 |                         [
19 |                             {
20 |                                 "command": "open_file",
21 |                                 "args": {"file": "${packages}/GhostText/GhostText.sublime-settings"},
22 |                                 "caption": "Settings – Default"
23 |                             },
24 |                             {
25 |                                 "command": "open_file",
26 |                                 "args": {"file": "${packages}/User/GhostText.sublime-settings"},
27 |                                 "caption": "Settings – User"
28 |                             },
29 |                         ]
30 |                     }
31 |                 ]
32 |             }
33 |         ]
34 |     }
35 | ]
36 | 


--------------------------------------------------------------------------------
/contributing.md:
--------------------------------------------------------------------------------
 1 | # Contributing
 2 | 
 3 | 
 4 | ## Download
 5 | 
 6 | Download it zipped:
 7 | 
 8 | https://github.com/GhostText/GhostText-for-SublimeText/archive/refs/heads/main.zip
 9 | 
10 | or via git:
11 | 
12 | ```sh
13 | git clone https://github.com/GhostText/GhostText-for-SublimeText.git
14 | ```
15 | 
16 | ## Install
17 | 
18 | Place the folder in your Sublime Text "Packages" directory, or create a link to it, for example:
19 | 
20 | ```sh
21 | ln -s \
22 |     ~/repos/GhostText-for-SublimeText \
23 |     ~/Library/Application Support/Sublime Text 3/Packages/ghosttext-local
24 | ```
25 | 
26 | ### Package directory
27 | 
28 | The "Packages" directory is located at:
29 | 
30 | * OS X:
31 | 
32 |         ~/Library/Application Support/Sublime Text 3/Packages/
33 | 
34 | * Linux:
35 | 
36 |         ~/.config/sublime-text-3/Packages/
37 | 
38 | * Windows:
39 | 
40 |         %APPDATA%/Sublime Text 3/Packages/
41 | 
42 | ## Running a local version
43 | 
44 | Sublime Text will automatically load the plugin, you can see it in its console. However it seems that it doesn't properly reload it when the extension changes, you will have to restart Sublime Text.
45 | 
46 | ## Publishing
47 | 
48 | Package Control automatically picks up new tags, so they can be [created on GitHub](https://github.com/GhostText/GhostText-for-SublimeText/releases/new).
49 | 


--------------------------------------------------------------------------------
/FocusSublimeWindow.py:
--------------------------------------------------------------------------------
 1 | import os
 2 | import sublime
 3 | import subprocess
 4 | from sublime_plugin import WindowCommand
 5 | 
 6 | 
 7 | NATIVE_FOCUS_WINDOW = int(sublime.version()) >= 4067
 8 | 
 9 | 
10 | class FocusSublimeWindowCommand(WindowCommand):
11 |     """
12 |     Focuses the SublimeText window.
13 |     """
14 | 
15 |     def run(self, **args):
16 |         if NATIVE_FOCUS_WINDOW:
17 |             self.window.bring_to_front()
18 | 
19 |         platform = sublime.platform()
20 |         if platform == 'linux':
21 |             os.system(
22 |                 'sh -c "xdotool windowactivate $(xdotool search --class sublime | tail -1)"'
23 |             )
24 |         elif platform == 'osx':
25 |             script = """
26 |             tell application "Sublime Text"
27 |                 activate
28 |             end tell
29 |             """  # Brings ALL the windows forward
30 |             subprocess.Popen(["osascript", "-e", script])
31 |         elif platform == 'windows':
32 |             startupinfo = subprocess.STARTUPINFO()
33 |             startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
34 |             subprocess.Popen(
35 |                 'powershell -Command (New-Object -ComObject WScript.Shell).AppActivate({})'.format(
36 |                     os.getppid()
37 |                 ),
38 |                 startupinfo=startupinfo,
39 |             )
40 | 


--------------------------------------------------------------------------------
/WebSocket/Handshake.py:
--------------------------------------------------------------------------------
 1 | import hashlib
 2 | import base64
 3 | 
 4 | 
 5 | class Handshake:
 6 |     """
 7 |     Handles the WebSocket handshake.
 8 |     """
 9 | 
10 |     def perform(self, data):
11 |         """
12 |         Parses the given request data and returns a matching response header.
13 |         """
14 |         key = self._build_web_socket_accept_from_request_header(data.decode("utf-8"))
15 | 
16 |         return self._build_response_header(key)
17 | 
18 |     def _build_web_socket_accept_from_request_header(self, header):
19 |         """
20 |         Parses the response header and builds a sec web socket accept.
21 |         """
22 |         search_term = "Sec-WebSocket-Key: "
23 |         start = header.find(search_term) + len(search_term)
24 |         end = header.find("\r\n", start)
25 |         key = header[start:end]
26 | 
27 |         guid = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
28 |         key = (key + guid).encode('utf-8')
29 |         sha1 = hashlib.sha1(key).digest()
30 | 
31 |         return base64.b64encode(sha1)
32 | 
33 |     def _build_response_header(self, key):
34 |         """
35 |         Builds the response header containing the given key.
36 |         """
37 |         return str(
38 |             "HTTP/1.1 101 Switching Protocols\r\n"
39 |             + "Upgrade: websocket\r\n"
40 |             + "Connection: Upgrade\r\n"
41 |             + "Sec-WebSocket-Accept: "
42 |             + key.decode('utf-8')
43 |             + "\r\n\r\n"
44 |         )
45 | 


--------------------------------------------------------------------------------
/GhostTextTools/WindowHelper.py:
--------------------------------------------------------------------------------
 1 | import sublime
 2 | import os
 3 | from .Utils import Utils
 4 | 
 5 | 
 6 | class WindowHelper(sublime.Window):
 7 |     """
 8 |     Helper class for opening new files in the active sublime text window.
 9 |     """
10 | 
11 |     def __init__(self):
12 |         self.window_id = sublime.active_window().id()
13 |         self._view_disconnected_prefix = Utils.get_view_prefix('disconnected')
14 |         self._view_connected_prefix = Utils.get_view_prefix('connected')
15 | 
16 |     def add_file(self, title, text, selections):
17 |         """
18 |         Creates a new file and adds the given text content to it.
19 |         """
20 |         view = self._find_disconnected_view(title)
21 |         view.set_name(
22 |             '{} {}'.format(self._view_connected_prefix, os.path.splitext(title)[0])
23 |         )
24 |         view.set_status('title', title)
25 |         view.run_command('replace_content', {'text': text, 'selections': selections})
26 |         view.set_scratch(True)
27 | 
28 |         return view
29 | 
30 |     def _find_disconnected_view(self, title=None):
31 |         disconnected_views = []
32 | 
33 |         if (
34 |             title is not None
35 |         ):  # if title is set try to find the best match by exact title first
36 |             needle = '{} {}'.format(self._view_disconnected_prefix, title)
37 |             disconnected_views.extend(Utils.search_views_by_title(needle))
38 | 
39 |         disconnected_views.extend(
40 |             Utils.search_views_by_title(self._view_disconnected_prefix)
41 |         )
42 |         if len(disconnected_views) > 0:
43 |             return disconnected_views[0]
44 | 
45 |         return self.open_file(title)
46 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # ![GhostText for Sublime Text](https://github.com/fregante/GhostText/raw/main/promo/gt_banner-for-sublimetext.png)
 2 | 
 3 | Use Sublime Text to write in your browser. Everything you type in the editor will be instantly updated in the browser (and vice versa).
 4 | 
 5 | ## Download
 6 | 
 7 | [<img src="https://user-images.githubusercontent.com/1402241/226263051-8452482b-5922-4959-9ab4-615a2cf2ae2e.png" width="32" valign="middle"> Download GhostText for Sublime Text](https://sublime.wbond.net/packages/GhostText)
 8 | 
 9 | ## Documentation
10 | 
11 | [<img src="https://raw.githubusercontent.com/fregante/GhostText/c33d6bf04089655043c14d3d0fd85c1df96ed49c/source/icons/icon48.png" width="24" valign="middle"> GhostText website](https://ghosttext.fregante.com)
12 | 
13 | [<img src="https://raw.githubusercontent.com/iamcal/emoji-data/afaa1a027c7f9b6f8d4b15cf22cd1e70a4a7d577/img-apple-64/1f41b.png" width="24" valign="middle"> Bug tracker](https://github.com/fregante/GhostText/issues)
14 | 
15 | ## Repositories
16 | 
17 | <a href="https://github.com/fregante/GhostText"><picture><source media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/3369400/139447912-e0f43f33-6d9f-45f8-be46-2df5bbc91289.png"><img width="24" valign="middle" src="https://user-images.githubusercontent.com/3369400/139448065-39a229ba-4b06-434b-bc67-616e2ed80c8f.png"></picture> GhostText for the browser</a>
18 | 
19 | <a href="https://github.com/GhostText/GhostText-for-SublimeText"><picture><source media="(prefers-color-scheme: dark)" srcset="https://user-images.githubusercontent.com/3369400/139447912-e0f43f33-6d9f-45f8-be46-2df5bbc91289.png"><img width="24" valign="middle" src="https://user-images.githubusercontent.com/3369400/139448065-39a229ba-4b06-434b-bc67-616e2ed80c8f.png"></picture> GhostText for Sublime Text</a>
20 | 
21 | ## Demo
22 | 
23 | <img src="https://raw.githubusercontent.com/fregante/GhostText/d5273b134f88a96dd3a20bfeb09049bdbc5f8b70/promo/demo.gif" alt="Demo screencast">
24 | 
25 | ## Installation suggestions
26 | 
27 | - On Linux, [xdotool](http://www.semicomplete.com/projects/xdotool/) lets GhostText focus your Sublime Text window on a new connection.
28 | 


--------------------------------------------------------------------------------
/GhostTextTools/OnSelectionModifiedListener.py:
--------------------------------------------------------------------------------
  1 | from contextlib import contextmanager
  2 | 
  3 | import sublime
  4 | from sublime_plugin import EventListener
  5 | import json
  6 | 
  7 | 
  8 | class OnSelectionModifiedListener(EventListener):
  9 |     """
 10 |     Handles content changes, each changes gets send with the given web socket server to the client.
 11 |     """
 12 | 
 13 |     _bind_views = {}
 14 |     _disabled = set()
 15 | 
 16 |     def on_selection_modified(self, view):
 17 |         vid = view.id()
 18 |         if vid not in OnSelectionModifiedListener._bind_views or vid in self._disabled:
 19 |             return
 20 | 
 21 |         changed_text = view.substr(sublime.Region(0, view.size()))
 22 |         selections = OnSelectionModifiedListener._get_selections(view)
 23 |         response = json.dumps(
 24 |             {
 25 |                 'title': view.name(),
 26 |                 'text': changed_text,
 27 |                 'syntax': view.scope_name(0),
 28 |                 'selections': selections,
 29 |             }
 30 |         )
 31 | 
 32 |         OnSelectionModifiedListener._bind_views[view.id()].send_message(response)
 33 | 
 34 |     @classmethod
 35 |     @contextmanager
 36 |     def disabled(cls, view):
 37 |         vid = view.id()
 38 |         cls._disabled.add(vid)
 39 |         try:
 40 |             yield
 41 |         finally:
 42 |             cls._disabled.remove(vid)
 43 | 
 44 |     def on_close(self, view):
 45 |         if view.id() not in OnSelectionModifiedListener._bind_views:
 46 |             return
 47 | 
 48 |         print("View with id: {} closed".format(view.id()))
 49 |         OnSelectionModifiedListener._bind_views[view.id()].initiate_close()
 50 |         OnSelectionModifiedListener.unbind_view(view)
 51 | 
 52 |     @staticmethod
 53 |     def bind_view(view, web_socket_server):
 54 |         """
 55 |         Binds a view to a WebSocket.
 56 |         """
 57 |         print("Bind view with id: {}".format(view.id()))
 58 |         OnSelectionModifiedListener._bind_views[view.id()] = web_socket_server
 59 | 
 60 |     @classmethod
 61 |     def unbind_all_views(cls):
 62 |         """
 63 |         Close all websocket servers.
 64 |         """
 65 |         for vid, server in cls._bind_views.items():
 66 |             server.initiate_close()
 67 |         cls._bind_views.clear()
 68 | 
 69 |     @staticmethod
 70 |     def unbind_view(view):
 71 |         """
 72 |         Unbinds a view connected to a WebSocket.
 73 |         """
 74 |         OnSelectionModifiedListener.unbind_view_by_id(view.id())
 75 | 
 76 |     @staticmethod
 77 |     def unbind_view_by_id(view_id):
 78 |         """
 79 |         Unbinds a view specified by it's id connected to a WebSocket.
 80 |         """
 81 |         print("Unbind view with id: {}".format(view_id))
 82 |         if view_id in OnSelectionModifiedListener._bind_views:
 83 |             del OnSelectionModifiedListener._bind_views[view_id]
 84 | 
 85 |     @staticmethod
 86 |     def unbind_view_by_web_socket_server_id(web_socket_server):
 87 |         """
 88 |         Unbinds a view specified by it's WebSocket server.
 89 |         """
 90 |         view_id_to_unbind = (
 91 |             OnSelectionModifiedListener.find_view_id_by_web_socket_server_id(
 92 |                 web_socket_server
 93 |             )
 94 |         )
 95 | 
 96 |         if view_id_to_unbind is not None:
 97 |             OnSelectionModifiedListener.unbind_view_by_id(view_id_to_unbind)
 98 | 
 99 |     @staticmethod
100 |     def find_view_id_by_web_socket_server_id(web_socket_server):
101 |         """
102 |         Searches a view by the given WebSocket server or returns None.
103 |         """
104 |         for view_id in OnSelectionModifiedListener._bind_views:
105 |             if (
106 |                 OnSelectionModifiedListener._bind_views[view_id].get_id()
107 |                 == web_socket_server.get_id()
108 |             ):
109 |                 return view_id
110 | 
111 |         return None
112 | 
113 |     @staticmethod
114 |     def _get_selections(view):
115 |         """
116 |         Returns the selections from the given view.
117 |         """
118 |         selections = []
119 | 
120 |         for pos in view.sel():
121 |             selections.append({'start': pos.begin(), 'end': pos.end()})
122 | 
123 |         return selections
124 | 


--------------------------------------------------------------------------------
/WebSocket/Frame.py:
--------------------------------------------------------------------------------
  1 | class Frame:
  2 |     """
  3 |     Parses and creates a WebSocket frame.
  4 |     """
  5 | 
  6 |     def __init__(self):
  7 |         self._payload_len = 0
  8 |         self._payload_start = 2
  9 |         self._mask_start = 2
 10 |         self._mask_data = []
 11 | 
 12 |         self.fin = False
 13 |         self.continues = False
 14 |         self.utf8 = False
 15 |         self.binary = False
 16 |         self.terminate = False
 17 |         self.ping = False
 18 |         self.pong = False
 19 |         self.mask = False
 20 | 
 21 |     def create(self, text):
 22 |         """
 23 |         Creates a from the given text.
 24 |         """
 25 |         length = len(text)
 26 | 
 27 |         if length <= 125:
 28 |             ret = bytearray([129, length])
 29 |         elif length > 65536:  # 64 bit length
 30 |             ret = bytearray(
 31 |                 [
 32 |                     129,
 33 |                     127,
 34 |                     (length >> 56) & 0xFF,
 35 |                     (length >> 48) & 0xFF,
 36 |                     (length >> 40) & 0xFF,
 37 |                     (length >> 32) & 0xFF,
 38 |                     (length >> 24) & 0xFF,
 39 |                     (length >> 16) & 0xFF,
 40 |                     (length >> 8) & 0xFF,
 41 |                     length & 0xFF,
 42 |                 ]
 43 |             )
 44 |         else:  # 16bit length
 45 |             ret = bytearray([129, 126, (length >> 8) & 0xFF, length & 0xFF])
 46 | 
 47 |         for byte in text.encode("utf-8"):
 48 |             ret.append(byte)
 49 | 
 50 |         return ret
 51 | 
 52 |     def parse(self, data):
 53 |         """
 54 |         Parses a frame.
 55 |         """
 56 |         self._parse_first_byte(data[0])
 57 |         self._parse_second_byte(data[1])
 58 | 
 59 |         if self._payload_len == 126:  # 16 bit int length
 60 |             self._payload_len = (data[2] << 8) + data[3]
 61 |             self._mask_start += 2
 62 |             self._payload_start += 2
 63 |         elif self._payload_len == 127:  # 64 bit int length
 64 |             self._payload_len = (
 65 |                 (data[2] << 56)
 66 |                 + (data[3] << 48)
 67 |                 + (data[4] << 40)
 68 |                 + (data[5] << 32)
 69 |                 + (data[6] << 24)
 70 |                 + (data[7] << 16)
 71 |                 + (data[8] << 8)
 72 |                 + data[9]
 73 |             )
 74 |             self._mask_start += 8
 75 |             self._payload_start += 8
 76 | 
 77 |         if self.mask:
 78 |             self._mask_data = [
 79 |                 data[self._mask_start],
 80 |                 data[self._mask_start + 1],
 81 |                 data[self._mask_start + 2],
 82 |                 data[self._mask_start + 3],
 83 |             ]
 84 | 
 85 |     def close(self):
 86 |         """
 87 |         Creates a closing frame.
 88 | 
 89 |         """
 90 |         return bytearray([136, 0])
 91 | 
 92 |     def get_payload(self, data):
 93 |         """
 94 |         Gets the payload from the given raw data, parse has to be called first!
 95 |         """
 96 |         if self.mask:
 97 |             res = bytearray(self._payload_len)
 98 |             i = 0
 99 |             for char in data[self._payload_start :]:
100 |                 res.append(char ^ self._mask_data[i % 4])
101 |                 i += 1
102 | 
103 |             return res
104 | 
105 |         return data[self._payload_start :]
106 | 
107 |     def get_payload_offset(self):
108 |         """
109 |         Returns the payload offset length.
110 | 
111 |         """
112 |         return self._payload_len - self._payload_start
113 | 
114 |     def _parse_first_byte(self, byte):
115 |         """
116 |         Parses the first byte.
117 |         """
118 |         self.fin = byte >= 128
119 |         opcode = byte
120 |         if self.fin:
121 |             opcode -= 128
122 | 
123 |         self.continues = opcode == 0
124 |         self.utf8 = opcode == 1
125 |         self.binary = opcode == 2
126 |         self.terminate = opcode == 8
127 |         self.ping = opcode == 9
128 |         self.pong = opcode == 10
129 | 
130 |     def _parse_second_byte(self, byte):
131 |         """
132 |         Parses the second byte.
133 |         """
134 |         self.mask = byte >= 128
135 |         self._payload_len = byte
136 | 
137 |         if self.mask:
138 |             self._payload_start += 4
139 |             self._payload_len -= 128
140 | 
141 |     def __str__(self):
142 |         lengths_frm = " maskStart: {}\n payloadStart: {}\n payloadLen: {}\n"
143 |         lengths = lengths_frm.format(
144 |             self._mask_start, self._payload_start, self._payload_len
145 |         )
146 | 
147 |         flags_frm = " fin: {}\n continues: {}\n utf8: {}\n binary: {}\n terminate: {}\n ping: {}\n pong: {}\n mask: {}\n"
148 |         flags = flags_frm.format(
149 |             self.fin,
150 |             self.continues,
151 |             self.utf8,
152 |             self.binary,
153 |             self.terminate,
154 |             self.ping,
155 |             self.pong,
156 |             self.mask,
157 |         )
158 | 
159 |         return "Frame:\n" + lengths + flags
160 | 


--------------------------------------------------------------------------------
/GhostTextTools/Utils.py:
--------------------------------------------------------------------------------
  1 | import sublime
  2 | import traceback
  3 | 
  4 | 
  5 | class Utils:
  6 |     """
  7 |     Loose collection of GhostText related utils for working with the Sublime Text API.
  8 |     """
  9 | 
 10 |     @staticmethod
 11 |     def show_status(status=''):
 12 |         """
 13 |         Shows a status message.
 14 |         """
 15 |         sublime.status_message('GhostText - {}'.format(status))
 16 | 
 17 |     @staticmethod
 18 |     def show_error(e=None, hint='', message=''):
 19 |         """
 20 |         Shows a sublime error dialog.
 21 |         """
 22 |         if hint:
 23 |             hint = ' - ' + hint
 24 | 
 25 |         if e:
 26 |             sublime.status_message(
 27 |                 'GhostText{}: {}, {}, {}'.format(
 28 |                     hint, message, str(e), traceback.format_exc()
 29 |                 )
 30 |             )
 31 |         else:
 32 |             sublime.status_message('GhostText{}: {}'.format(hint, message))
 33 | 
 34 |     @staticmethod
 35 |     def search_views_by_title(needle):
 36 |         """
 37 |         Search for views in all open windows containing the given needle.
 38 |         """
 39 |         result = []
 40 |         for window in sublime.windows():
 41 |             for view in window.views():
 42 |                 name = Utils.get_name_or_file_name_from_view(view)
 43 |                 if needle in name:
 44 |                     result.append(view)
 45 |                 if needle == name:
 46 |                     result.append(view)
 47 | 
 48 |         return result
 49 | 
 50 |     @staticmethod
 51 |     def find_view_by_id(view_id):
 52 |         """
 53 |         Finds a view in all open windows containing the given id.
 54 |         """
 55 |         for window in sublime.windows():
 56 |             for view in window.views():
 57 |                 if view.id() == view_id:
 58 |                     return view
 59 | 
 60 |         return None
 61 | 
 62 |     @staticmethod
 63 |     def close_view(view):
 64 |         """
 65 |         Closes the given view by running the close_by_index command.
 66 |         If there are more than one open windows and the window has no more views it gets closed, too.
 67 |         """
 68 |         window = view.window()
 69 |         group_index, view_index = window.get_view_index(view)
 70 |         window.run_command(
 71 |             'close_by_index', {'group': group_index, 'index': view_index}
 72 |         )
 73 |         if len(sublime.windows()) > 1 and len(window.views()) == 0:
 74 |             window.run_command('close')
 75 | 
 76 |     @staticmethod
 77 |     def close_view_by_id(view_id):
 78 |         """
 79 |         Closes the given view, specified by it's id, by running the close_by_index command.
 80 |         """
 81 |         view = Utils.find_view_by_id(view_id)
 82 | 
 83 |         if view is None:
 84 |             return
 85 | 
 86 |         Utils.close_view(view)
 87 | 
 88 |     @staticmethod
 89 |     def mark_view_as(view, state):
 90 |         """
 91 |         Marks a view, sets a prefix, as connected or disconnected.
 92 |         """
 93 |         name = Utils.get_name_or_file_name_from_view(view)
 94 |         name = name.replace(Utils.get_view_prefix('connected'), '')
 95 |         name = name.replace(Utils.get_view_prefix('disconnected'), '')
 96 |         name = name.lstrip()
 97 |         view.set_name('{} {}'.format(Utils.get_view_prefix(state), name))
 98 | 
 99 |     @staticmethod
100 |     def replace_connected_with_disconnected_prefix():
101 |         """
102 |         Replaces the connected prefix with the disconnected one.
103 |         """
104 |         view_prefix_connected = Utils.get_view_prefix('connected')
105 | 
106 |         for view in Utils.search_views_by_title(view_prefix_connected):
107 |             name = Utils.get_name_or_file_name_from_view(view)
108 |             if view_prefix_connected in name:
109 |                 Utils.mark_view_as(view, 'disconnected')
110 | 
111 |     @staticmethod
112 |     def get_view_prefix(state):
113 |         """
114 |         Gets the view prefix by the given state from the config.
115 |         """
116 |         settings = sublime.load_settings('GhostText.sublime-settings')
117 |         return settings.get('view_title_prefix')[state]
118 | 
119 |     @staticmethod
120 |     def get_name_or_file_name_from_view(view):
121 |         """
122 |         Returns the name from the given view,
123 |         if no name is set the file name gets returned,
124 |         when no file name was found an empty string is teh result.
125 |         """
126 |         name = view.name()
127 |         if name is not None:
128 |             return name
129 | 
130 |         name = view.file_name()
131 |         if name is not None:
132 |             return name
133 | 
134 |         return ''
135 | 
136 |     @staticmethod
137 |     def get_syntax_by_host(host):
138 |         """
139 |         Looks for a user-suggested syntax in the "host_to_syntax" setting,
140 |         defaults to "default_syntax"
141 |         """
142 |         settings = sublime.load_settings('GhostText.sublime-settings')
143 |         host_to_syntax = settings.get('host_to_syntax')
144 | 
145 |         syntax = None
146 |         syntax_part = None
147 |         for host_fragment in host_to_syntax:
148 |             if host_fragment not in host:
149 |                 continue
150 | 
151 |             return host_to_syntax[host_fragment]
152 | 
153 |         return settings.get('default_syntax')
154 | 


--------------------------------------------------------------------------------
/WebSocket/WebSocketServer.py:
--------------------------------------------------------------------------------
  1 | import socket
  2 | import traceback
  3 | from math import ceil
  4 | from .Frame import Frame
  5 | from .Handshake import Handshake
  6 | 
  7 | 
  8 | class WebSocketServer:
  9 |     """
 10 |     A simple, single threaded, web socket server.
 11 |     """
 12 | 
 13 |     _id = 1
 14 | 
 15 |     def __init__(self, host='localhost', port=0):
 16 |         self._handshake = Handshake()
 17 |         self._frame = Frame()
 18 | 
 19 |         self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 20 |         self._socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
 21 |         self._socket.bind((host, port))
 22 | 
 23 |         self._on_message_handler = None
 24 |         self._on_close_handler = None
 25 |         self._running = False
 26 |         self._conn = None
 27 |         self._address = None
 28 |         self._port = 0
 29 |         self._close_frame_send = False
 30 |         self._close_frame_received = False
 31 | 
 32 |         self._received_payload = ''
 33 |         self._id = WebSocketServer._id
 34 |         WebSocketServer._id += 1
 35 |         print("WebSocketServer id: {}".format(self._id))
 36 | 
 37 |     def start(self):
 38 |         """
 39 |         Starts the server,
 40 |         """
 41 |         self._socket.listen(1)
 42 |         self._port = self._socket.getsockname()[1]
 43 |         print('Listening on: {}'.format(self._port))
 44 |         self._running = True
 45 |         self._conn, self._address = self._socket.accept()
 46 | 
 47 |         data = self._recv_all()
 48 |         self._conn.sendall(self._handshake.perform(data).encode("utf-8"))
 49 | 
 50 |         while self._running:
 51 |             try:
 52 |                 header = self._conn.recv(24)  # Max web socket header length
 53 |             except OSError:
 54 |                 self._running = False
 55 |                 continue
 56 | 
 57 |             if len(data) > 0:
 58 |                 self._frame = Frame()
 59 | 
 60 |                 try:
 61 |                     self._frame.parse(header)
 62 |                 except IndexError:
 63 |                     print(str(e))
 64 |                     print(traceback.format_exc())
 65 |                     self._running = False
 66 |                     continue
 67 | 
 68 |                 if self._frame.terminate:
 69 |                     self._close_frame_received = True
 70 |                     if not self._close_frame_send:
 71 |                         self._conn.send(self._frame.close())
 72 |                         self._close_frame_send = True
 73 |                     self._running = False
 74 |                     continue
 75 | 
 76 |                 data = bytearray()
 77 |                 data.extend(header)
 78 |                 offset = self._frame.get_payload_offset()
 79 | 
 80 |                 if offset > 0:
 81 |                     try:
 82 |                         for offset_part in range(0, ceil(offset / 4096)):
 83 |                             data.extend(self._conn.recv(4096))
 84 |                     except MemoryError as e:
 85 |                         print(str(e))
 86 |                         print(traceback.format_exc())
 87 |                         continue
 88 | 
 89 |                 if self._frame.utf8:
 90 |                     try:
 91 |                         request = self._frame.get_payload(data).decode("utf-8")
 92 |                         self._received_payload += request.lstrip('\x00')
 93 |                     except UnicodeDecodeError:
 94 |                         continue
 95 | 
 96 |                 if self._frame.utf8 and self._frame.fin:
 97 |                     self._on_message_handler.on_message(self._received_payload)
 98 |                     self._received_payload = ''
 99 | 
100 |         print('Stop')
101 |         self.stop()
102 | 
103 |     def send_message(self, txt):
104 |         """
105 |         Sends a message if the server is in running state.
106 |         """
107 |         if not self._running:
108 |             return
109 | 
110 |         self._frame = Frame()
111 |         raw_data = self._frame.create(txt)
112 |         self._conn.send(raw_data)
113 | 
114 |     def stop(self):
115 |         """
116 |         Stops the server by sending the fin package to the client and closing the socket.
117 |         """
118 | 
119 |         self._running = False
120 |         try:
121 |             if not self._close_frame_send and not self._close_frame_received:
122 |                 self._conn.close()
123 |         except BrokenPipeError:
124 |             print('Ignored BrokenPipeError')
125 |         except OSError:
126 |             print('Ignored OSError')
127 | 
128 |         if self._on_close_handler:
129 |             print('Triggering on_close')
130 |             self._on_close_handler.on_close()
131 | 
132 |     def initiate_close(self):
133 |         """
134 |         Initiates the close handshake at the server side
135 |         """
136 |         self._conn.send(self._frame.close())
137 |         self._close_frame_send = True
138 | 
139 |     def on_message(self, handler):
140 |         """
141 |         Sets the on message handler.
142 |         """
143 |         print('Setting on message handler')
144 |         self._on_message_handler = handler
145 |         self._on_message_handler.set_web_socket_server(self)
146 | 
147 |     def on_close(self, handler):
148 |         """
149 |         Sets the on connection closed handler.
150 |         """
151 |         print('Setting on close handler')
152 |         self._on_close_handler = handler
153 |         self._on_close_handler.set_web_socket_server(self)
154 | 
155 |     def get_running(self):
156 |         """
157 |         Returns the running state.
158 |         """
159 |         return self._running
160 | 
161 |     def get_port(self):
162 |         """
163 |         Gets the port the server is listening/running on.
164 |         """
165 |         return self._port
166 | 
167 |     def get_id(self):
168 |         """
169 |         Gets the server's id.
170 |         """
171 |         return self._id
172 | 
173 |     def _recv_all(self, chunk_size=4096):
174 |         """
175 |         Receive all data.
176 |         """
177 |         msg = bytearray()
178 |         while True:
179 |             chunk = self._conn.recv(chunk_size)
180 |             msg.extend(chunk)
181 | 
182 |             if len(chunk) < chunk_size:
183 |                 break
184 | 
185 |         return msg
186 | 


--------------------------------------------------------------------------------
/GhostText.py:
--------------------------------------------------------------------------------
  1 | __author__ = 'Guido Krömer'
  2 | __license__ = 'MIT'
  3 | __version__ = '0.2'
  4 | __email__ = 'mail 64 cacodaemon 46 de'
  5 | 
  6 | import sublime
  7 | import http.server
  8 | import socketserver
  9 | from sublime import Window
 10 | from sublime_plugin import TextCommand
 11 | from sublime_plugin import EventListener
 12 | from threading import Thread
 13 | import json
 14 | from time import sleep
 15 | from .WebSocket.WebSocketServer import WebSocketServer
 16 | from .WebSocket.AbstractOnClose import AbstractOnClose
 17 | from .WebSocket.AbstractOnMessage import AbstractOnMessage
 18 | from .GhostTextTools.OnSelectionModifiedListener import OnSelectionModifiedListener
 19 | from .GhostTextTools.WindowHelper import WindowHelper
 20 | from .GhostTextTools.Utils import Utils
 21 | 
 22 | 
 23 | class WebSocketServerThread(Thread):
 24 |     def __init__(self, settings):
 25 |         super().__init__()
 26 |         self._server = WebSocketServer('localhost', 0)
 27 |         self._server.on_message(OnConnect(settings))
 28 |         self._server.on_close(OnClose(settings))
 29 | 
 30 |     def run(self):
 31 |         self._server.start()
 32 | 
 33 |     def get_server(self):
 34 |         return self._server
 35 | 
 36 | 
 37 | class OnRequest(http.server.SimpleHTTPRequestHandler):
 38 |     def do_GET(self):
 39 |         if len(sublime.windows()) == 0 or self.new_window_on_connect:
 40 |             sublime.run_command('new_window')
 41 | 
 42 |         if len(self.window_command_on_connect) > 0:
 43 |             sublime.active_window().run_command(self.window_command_on_connect)
 44 | 
 45 |         web_socket_server_thread = WebSocketServerThread(self._settings)
 46 |         web_socket_server_thread.start()
 47 |         while not web_socket_server_thread.get_server().get_running():
 48 |             sleep(0.1)
 49 | 
 50 |         port = web_socket_server_thread.get_server().get_port()
 51 |         Utils.show_status('Connection opened')
 52 | 
 53 |         self.send_response(200)
 54 |         self.send_header('Content-type', 'application/json')
 55 |         self.end_headers()
 56 |         self.wfile.write(
 57 |             json.dumps({"WebSocketPort": port, "ProtocolVersion": 1}).encode()
 58 |         )
 59 | 
 60 | 
 61 | class HttpStatusServerThread(Thread):
 62 |     def __init__(self, settings):
 63 |         super().__init__()
 64 |         server_port = int(settings.get('server_port', 4001))
 65 | 
 66 |         handler = OnRequest
 67 |         handler._settings = settings
 68 |         handler.new_window_on_connect = bool(
 69 |             settings.get('new_window_on_connect', False)
 70 |         )
 71 |         handler.window_command_on_connect = str(
 72 |             settings.get('window_command_on_connect', 'focus_sublime_window')
 73 |         )
 74 |         self._server = socketserver.TCPServer(("", server_port), OnRequest)
 75 |         Utils.show_status('Ready on port ' + str(server_port))
 76 | 
 77 |     def run(self):
 78 |         try:
 79 |             self._server.serve_forever()
 80 |         except OSError as e:
 81 |             Utils.show_error(e, 'HttpStatusServerThread')
 82 |             raise e
 83 | 
 84 |     def stop(self):
 85 |         self._server.shutdown()
 86 | 
 87 | 
 88 | class ReplaceContentCommand(TextCommand):
 89 |     """
 90 |     Replaces the views complete text content.
 91 |     """
 92 | 
 93 |     def run(self, edit, **args):
 94 |         # Temporarily disable conversion of tabs to spaces before
 95 |         # pasting text, so that the selections stay valid
 96 |         old_setting = self.view.settings().get('translate_tabs_to_spaces')
 97 |         try:
 98 |             self.view.settings().set('translate_tabs_to_spaces', False)
 99 |             self.view.replace(edit, sublime.Region(0, self.view.size()), args['text'])
100 |         finally:
101 |             self.view.settings().set('translate_tabs_to_spaces', old_setting)
102 | 
103 |         text_length = len(args['text'])
104 |         self.view.sel().clear()
105 |         if 'selections' in args and len(args['selections']) > 0:
106 |             selection = args['selections'][0]
107 |             self.view.sel().add(sublime.Region(selection['start'], selection['end']))
108 |         else:
109 |             self.view.sel().add(sublime.Region(text_length, text_length))
110 | 
111 | 
112 | class OnConnect(AbstractOnMessage):
113 |     def __init__(self, settings):
114 |         self._settings = settings
115 | 
116 |     def on_message(self, text):
117 |         try:
118 |             request = json.loads(text)
119 |             window_helper = WindowHelper()
120 |             syntax = Utils.get_syntax_by_host(request['url'])
121 |             current_view = window_helper.add_file(
122 |                 request['title'] + '.' + syntax, request['text'], request.get('selections')
123 |             )
124 |             OnSelectionModifiedListener.bind_view(current_view, self._web_socket_server)
125 |             self._web_socket_server.on_message(OnMessage(self._settings, current_view))
126 |             current_view.window().focus_view(current_view)
127 |         except ValueError as e:
128 |             Utils.show_error(e, 'Invalid JSON')
129 | 
130 | 
131 | class OnMessage(AbstractOnMessage):
132 |     def __init__(self, settings, current_view):
133 |         self._current_view = current_view
134 |         self._settings = settings
135 | 
136 |     def on_message(self, text):
137 |         try:
138 |             request = json.loads(text)
139 |             with OnSelectionModifiedListener.disabled(self._current_view):
140 |                 self._current_view.run_command('replace_content', request)
141 |                 self._current_view.window().focus_view(self._current_view)
142 |         except ValueError as e:
143 |             Utils.show_error(e, 'Invalid JSON')
144 | 
145 | 
146 | class OnClose(AbstractOnClose):
147 |     def __init__(self, settings):
148 |         self._settings = settings
149 |         self._close_view_on_disconnect = bool(
150 |             settings.get('close_view_on_disconnect', False)
151 |         )
152 | 
153 |     def on_close(self):
154 |         view_id = OnSelectionModifiedListener.find_view_id_by_web_socket_server_id(
155 |             self._web_socket_server
156 |         )
157 |         if view_id is not None:
158 |             view = Utils.find_view_by_id(view_id)
159 |             if view is not None:
160 |                 Utils.mark_view_as(view, 'disconnected')
161 | 
162 |         if self._close_view_on_disconnect:
163 |             Utils.close_view_by_id(view_id)
164 | 
165 |         OnSelectionModifiedListener.unbind_view_by_web_socket_server_id(
166 |             self._web_socket_server
167 |         )
168 |         Utils.show_status('Connection closed')
169 | 
170 | 
171 | class GhostTextGlobals:
172 |     """
173 |     'Namespace' for global vars.
174 |     """
175 | 
176 |     http_status_server_thread = None
177 | 
178 | 
179 | def plugin_loaded():
180 |     print('GhostText is starting now…')
181 |     settings = sublime.load_settings('GhostText.sublime-settings')
182 |     GhostTextGlobals.http_status_server_thread = HttpStatusServerThread(settings)
183 |     GhostTextGlobals.http_status_server_thread.start()
184 | 
185 |     Utils.replace_connected_with_disconnected_prefix()
186 | 
187 | 
188 | def plugin_unloaded():
189 |     print('GhostText is stopping now…')
190 |     print(GhostTextGlobals.http_status_server_thread)
191 |     if GhostTextGlobals.http_status_server_thread is None:
192 |         return
193 | 
194 |     GhostTextGlobals.http_status_server_thread.stop()
195 |     OnSelectionModifiedListener.unbind_all_views()
196 | 


--------------------------------------------------------------------------------