diff --git a/README.md b/README.md index b835832..02836a7 100644 --- a/README.md +++ b/README.md @@ -11,4 +11,6 @@ WIP # Images ![1 Newton default view. ](images/pic1.png) -![2 Newton search and replace plus menu shown. ](images/pic2.png) \ No newline at end of file +![2 Newton search and replace plus menu shown. ](images/pic2.png +![3 Newton displaying inline colors. ](images/pic3.png +![4 Newton as transparent with youtube playing below it. ](images/pic3.png) diff --git a/images/pic3.png b/images/pic3.png new file mode 100644 index 0000000..43d5548 Binary files /dev/null and b/images/pic3.png differ diff --git a/images/pic4.png b/images/pic4.png new file mode 100644 index 0000000..3829a8e Binary files /dev/null and b/images/pic4.png differ diff --git a/plugins/colorize/color_converter_mixin.py b/plugins/colorize/color_converter_mixin.py index 4e33240..0e8cd39 100644 --- a/plugins/colorize/color_converter_mixin.py +++ b/plugins/colorize/color_converter_mixin.py @@ -7,8 +7,10 @@ import colorsys class ColorConverterMixin: + # NOTE: HSV HSL, and Hex Alpha parsing are available in Gtk 4.0- not lower. + # So, for compatability we're gunna convert to rgba string ourselves... def get_color_text(self, buffer, start, end): - text = buffer.get_text(start, end, include_hidden_chars = False) + text = buffer.get_text(start, end, include_hidden_chars = False) try: if "hsl" in text: @@ -16,11 +18,53 @@ class ColorConverterMixin: if "hsv" in text: text = self.hsv_to_rgb(text) + + if "#" == text[0]: + hex = text[1:] + size = len(hex) + if size in [4, 8, 16]: + rgba = self.hex_to_rgba(hex, size) + print(rgba) + except Exception as e: ... return text + def hex_to_rgba(self, hex, size): + rgba = [] + slots = None + step = 2 + bytes = 16 + + if size == 4: # NOTE: RGBA + step = 1 + slots = (0, 1, 2, 3) + + if size == 6: # NOTE: RR GG BB + slots = (0, 2, 4) + + if size == 8: # NOTE: RR GG BB AA + step = 2 + slots = (0, 2, 4, 6) + + if size == 16: # NOTE: RRRR GGGG BBBB AAAA + step = 4 + slots = (0, 4, 8, 12) + + for i in slots: + v = int(hex[i : i + step], bytes) + rgba.append(v) + + + rgb_sub = ','.join(map(str, tuple(rgba))) + + return f"rgba({rgb_sub})" + + # return tuple(rgba) + + + def hsl_to_rgb(self, text): _h, _s , _l = text.replace("hsl", "") \ .replace("deg", "") \ diff --git a/plugins/colorize/plugin.py b/plugins/colorize/plugin.py index 3e45455..ba16125 100644 --- a/plugins/colorize/plugin.py +++ b/plugins/colorize/plugin.py @@ -1,4 +1,5 @@ # Python imports +import random # Lib imports import gi @@ -20,6 +21,8 @@ class Plugin(ColorConverterMixin, PluginBase): self.name = "Colorize" # NOTE: Need to remove after establishing private bidirectional 1-1 message bus # where self.name should not be needed for message comms self.tag_stub_name = "colorize_tag" + self._buffer = None + def run(self): ... @@ -36,29 +39,83 @@ class Plugin(ColorConverterMixin, PluginBase): def _set_active_src_view(self, source_view): self._active_src_view = source_view + def _buffer_changed_first_load(self, buffer): + self._buffer = buffer self._do_colorize(buffer) - def _buffer_changed(self, buffer): - tag_table = buffer.get_tag_table() - mark = buffer.get_insert() - iter = buffer.get_iter_at_mark(mark) - tags = iter.get_tags() + self._event_system.emit("pause_event_processing") + self._handle_colorize(buffer) + self._event_system.emit("resume_event_processing") - iter.forward_line() # NOTE: Jump to start of next line - end = iter.copy() - iter.backward_line() # NOTE: To now easily get start of prior line - start = iter.copy() + def _handle_colorize(self, buffer): + self._buffer = buffer + tag_table = buffer.get_tag_table() + mark = buffer.get_insert() + start = None + end = buffer.get_iter_at_mark(mark) - for tag in tags: - if tag.props.name and self.tag_stub_name in tag.props.name: - buffer.remove_tag(tag, start, end) - tag_table.remove(tag) + i = 0 + walker_iter = end.copy() + working_tag = self.find_working_tag(walker_iter, i) + if working_tag: + start = self.find_start_range(walker_iter, working_tag) + + self.find_end_range(end, working_tag) + buffer.remove_tag(working_tag, start, end) + else: + start = self.traverse_backward_25_or_less(walker_iter) + self.traverse_forward_25_or_less(end) self._do_colorize(buffer, start, end) + + def find_working_tag(self, walker_iter, i): + tags = walker_iter.get_tags() + for tag in tags: + if tag.props.name and self.tag_stub_name in tag.props.name: + return tag + + res = walker_iter.backward_char() + + if not res: return + if i > 25: return + return self.find_working_tag(walker_iter, i + 1) + + def find_start_range(self, walker_iter, working_tag): + tags = walker_iter.get_tags() + for tag in tags: + if tag.props.name and working_tag.props.name in tag.props.name: + res = walker_iter.backward_char() + if res: + self.find_start_range(walker_iter, working_tag) + + return walker_iter + + def find_end_range(self, end, working_tag): + tags = end.get_tags() + for tag in tags: + if tag.props.name and working_tag.props.name in tag.props.name: + res = end.forward_char() + if res: + self.find_end_range(end, working_tag) + + def traverse_backward_25_or_less(self, walker_iter): + i = 1 + while i <= 25: + res = walker_iter.backward_char() + if not res: break + i += 1 + + def traverse_forward_25_or_less(self, end): + i = 1 + while i <= 25: + res = end.forward_char() + if not res: break + i += 1 + def _do_colorize(self, buffer = None, start_itr = None, end_itr = None): # rgb(a), hsl, hsv results = self.finalize_non_hex_matches( self.collect_preliminary_results(buffer, start_itr, end_itr) ) @@ -135,18 +192,28 @@ class Plugin(ColorConverterMixin, PluginBase): results = [] for start, end in result_hits: - while not end.get_char() in [";", " "]: - end.forward_char() + i = 0 + _ch = end.get_char() + ch = ord(end.get_char()) if _ch else -1 - results.append([start, end]) + while ((ch >= 48 and ch <= 57) or (ch >= 65 and ch <= 70) or (ch >= 97 and ch <= 102)): + if i > 16: break + + i += 1 + end.forward_char() + _ch = end.get_char() + ch = ord(end.get_char()) if _ch else -1 + + if i in [3, 4, 6, 8, 9, 12, 16]: + results.append([start, end]) return results def process_results(self, buffer, results): - # NOTE: HSV and HSL parsing are available in Gtk 4.0. Not lower... for start, end in results: text = self.get_color_text(buffer, start, end) color = Gdk.RGBA() + if color.parse(text): tag = self.get_colorized_tag(buffer, text, color) buffer.apply_tag(tag, start, end) diff --git a/plugins/commentzar/add_comment_mixin.py b/plugins/commentzar/add_comment_mixin.py index 54a3693..6e123f3 100755 --- a/plugins/commentzar/add_comment_mixin.py +++ b/plugins/commentzar/add_comment_mixin.py @@ -7,24 +7,23 @@ class AddCommentMixin: - def add_comment_characters(self, document, start_tag, end_tag, start, end, deselect, oldPos): - smark = document.create_mark("start", start, False) - imark = document.create_mark("iter", start, False) - emark = document.create_mark("end", end, False) + def add_comment_characters(self, buffer, start_tag, end_tag, start, end, deselect, oldPos): + smark = buffer.create_mark("start", start, False) + imark = buffer.create_mark("iter", start, False) + emark = buffer.create_mark("end", end, False) number_lines = end.get_line() - start.get_line() + 1 comment_pos_iter = None count = 0 - document.begin_user_action() + buffer.begin_user_action() for i in range(0, number_lines): - iter = document.get_iter_at_mark(imark) - + iter = buffer.get_iter_at_mark(imark) if not comment_pos_iter: (comment_pos_iter, count) = self.discard_white_spaces(iter) if self.is_commented(comment_pos_iter, start_tag): - new_code = self.remove_comment_characters(document, start_tag, end_tag, start, end) + new_code = self.remove_comment_characters(buffer, start_tag, end_tag, start, end) return else: comment_pos_iter = iter @@ -35,33 +34,33 @@ class AddCommentMixin: iter.forward_char() - document.insert(comment_pos_iter, start_tag) - document.insert(comment_pos_iter, " ") + buffer.insert(comment_pos_iter, start_tag) + buffer.insert(comment_pos_iter, " ") if end_tag: if i != number_lines -1: - iter = document.get_iter_at_mark(imark) + iter = buffer.get_iter_at_mark(imark) iter.forward_to_line_end() - document.insert(iter, end_tag) + buffer.insert(iter, end_tag) else: - iter = document.get_iter_at_mark(emark) - document.insert(iter, end_tag) + iter = buffer.get_iter_at_mark(emark) + buffer.insert(iter, end_tag) - iter = document.get_iter_at_mark(imark) + iter = buffer.get_iter_at_mark(imark) iter.forward_line() - document.delete_mark(imark) - imark = document.create_mark("iter", iter, True) + buffer.delete_mark(imark) + imark = buffer.create_mark("iter", iter, True) - document.end_user_action() + buffer.end_user_action() - document.delete_mark(imark) - new_start = document.get_iter_at_mark(smark) - new_end = document.get_iter_at_mark(emark) + buffer.delete_mark(imark) + new_start = buffer.get_iter_at_mark(smark) + new_end = buffer.get_iter_at_mark(emark) - document.select_range(new_start, new_end) - document.delete_mark(smark) - document.delete_mark(emark) + buffer.select_range(new_start, new_end) + buffer.delete_mark(smark) + buffer.delete_mark(emark) if deselect: - oldPosIter = document.get_iter_at_offset(oldPos + 2) - document.place_cursor(oldPosIter) + oldPosIter = buffer.get_iter_at_offset(oldPos + 2) + buffer.place_cursor(oldPosIter) diff --git a/plugins/commentzar/plugin.py b/plugins/commentzar/plugin.py index c832362..cbf41bf 100644 --- a/plugins/commentzar/plugin.py +++ b/plugins/commentzar/plugin.py @@ -76,8 +76,9 @@ class Plugin(AddCommentMixin, RemoveCommentMixin, CodeCommentTags, PluginBase): buffer.end_user_action() return + self._event_system.emit("pause_event_processing") new_code = self.add_comment_characters(buffer, start_tag, end_tag, start, end, deselect, oldPos) - + self._event_system.emit("resume_event_processing") def discard_white_spaces(self, iter): count = 0 diff --git a/src/utils/event_system.py b/src/utils/event_system.py index 88f7299..cd6975f 100644 --- a/src/utils/event_system.py +++ b/src/utils/event_system.py @@ -4,16 +4,29 @@ from collections import defaultdict # Lib imports # Application imports +from .singleton import Singleton - -class EventSystem: +class EventSystem(Singleton): """ Create event system. """ def __init__(self): self.subscribers = defaultdict(list) + self._is_paused = False + self._subscribe_to_events() + + + def _subscribe_to_events(self): + self.subscribe("pause_event_processing", self._pause_processing_events) + self.subscribe("resume_event_processing", self._resume_processing_events) + + def _pause_processing_events(self): + self._is_paused = True + + def _resume_processing_events(self): + self._is_paused = False def subscribe(self, event_type, fn): self.subscribers[event_type].append(fn) @@ -25,6 +38,9 @@ class EventSystem: self.subscribers.pop(event_type, None) def emit(self, event_type, data = None): + if self._is_paused and event_type != "resume_event_processing": + return + if event_type in self.subscribers: for fn in self.subscribers[event_type]: if data: @@ -36,6 +52,9 @@ class EventSystem: fn() def emit_and_await(self, event_type, data = None): + if self._is_paused and event_type != "resume_event_processing": + return + """ NOTE: Should be used when signal has only one listener and vis-a-vis """ if event_type in self.subscribers: response = None diff --git a/user_config/usr/share/newton/key-bindings.json b/user_config/usr/share/newton/key-bindings.json index a8af42a..4f8dbf3 100644 --- a/user_config/usr/share/newton/key-bindings.json +++ b/user_config/usr/share/newton/key-bindings.json @@ -6,15 +6,14 @@ "tear_down" : "q", "toggle_highlight_line" : "h", "open_files" : "o", - "move_lines_up" : "Up", - "move_lines_down" : "Down", + "keyboard_move_lines_up" : "Up", + "keyboard_move_lines_down" : "Down", "keyboard_undo" : "z", "keyboard_redo" : "y", "keyboard_create_tab" : "t", "keyboard_close_tab" : "w", "keyboard_save_file" : "s", "keyboard_insert_mark" : "m", - "keyboard_tggl_comment" : "slash", "keyboard_clear_marks" : "m", "keyboard_save_file_as" : "s", "keyboard_up" : "Up", diff --git a/user_config/usr/share/newton/settings.json b/user_config/usr/share/newton/settings.json index c6112e3..1515094 100644 --- a/user_config/usr/share/newton/settings.json +++ b/user_config/usr/share/newton/settings.json @@ -117,7 +117,7 @@ "error_color":"#ff0000" }, "debugging":{ - "ch_log_lvl":10, + "ch_log_lvl":20, "fh_log_lvl":20 } -} \ No newline at end of file +}