cursor can now only go to all query results from rerun previous command

refactor for more reusability of components
don't show results from previous valid query in quick panel when the
xpath query expression being typed is invalid

Author: keith-hall

Default.sublime-commands

@@ -46,7 +46,7 @@
 		"command": "show_xpath_query_history"
 	}, {
 		"caption": "XPath: Re-run last query and select all results",
-		"command": "rerun_last_xpath_query", "args": { "show_query_results": false }
+		"command": "rerun_last_xpath_query_and_select_results"
 	}, {
 		"caption": "XPath: Clean tag soup",
 		"command": "clean_tag_soup"

README.md

@@ -28,7 +28,6 @@ See [default settings](https://github.com/rosshadden/sublime-xpath/blob/master/x
 - `attributes_to_include` - Specific attributes or namespaces to include in the XPath.
 - `show_attributes_in_hierarchy` - Whether or not to include attributes when in hierarchy mode. (If `show_all_attributes` is false and the `attributes_to_include` whitelist is empty, this will have no effect.)
 - `live_mode` - whether to show the results of the xpath query while it is being typed. If false, will only show the results after the user presses enter in the input box.
-- `show_query_results` - whether or not to show the results of the xpath query. If false, the cursor will move directly to all results.  If the xpath query does not return a nodeset, the results are always displayed, regardless of this setting.
 - `default_namespace_prefix` - the prefix to use when the xml document contains a default namespace with no prefix. e.g. `<test xmlns="http://uri/">` XPath 1.0 doesn't support blank prefixes, so, for convenience, this plugin can set one for you.
 - `show_namespace_prefixes_from_query` - in case of blank namespace prefixes (see `default_namespace_prefix`) or multiple namespace URIs being referenced from the same prefix, the plugin will automatically make them unique, so that you can easily use them in a query.  If this is turned on, the xpaths that are shown in the status bar and copied to the clipboard will be directly queryable by this plugin. If this is turned off, element names in the path will reflect those in the source document.
 - `only_show_xpath_if_saved` - whether or not to only show the current xpath in the status bar if the view is not dirty. This could be useful to save wasting CPU cycles (from constant parsing) when editing a document, for example.

sublime_input.py

@@ -0,0 +1,75 @@
+import sublime
+import sublime_plugin
+
+class RequestInputCommand(sublime_plugin.TextCommand): # example usage from python console: sublime.active_window().active_view().run_command('request_input', { 'label': 'Enter text here:', 'initial_value': 'Hello World' })
+    input_panel = None
+    pending_value = None
+    current_value = None
+    live_mode = None
+    timeout_active = None
+    arguments = None
+    
+    def run(self, edit, **args):
+        self.input_panel = None
+        self.pending_value = None
+        self.current_value = None
+        self.timeout_active = False
+        self.set_args(**args)
+        self.parse_args()
+        
+        self.input_panel = self.view.window().show_input_panel(self.get_value_from_args('label', ''), self.get_value_from_args('initial_value', ''), self.input_done, self.input_changed, self.input_cancelled)
+        syntax = self.get_value_from_args('syntax', None)
+        if syntax is not None:
+            self.input_panel.set_syntax_file(syntax)
+        self.input_panel.settings().set('gutter', False)
+    
+    def set_args(self, **args):
+        self.arguments = args or {}
+    
+    def parse_args(self):    
+        self.live_mode = self.get_value_from_args('live_mode', True)
+    
+    def get_value_from_args(self, key, default):
+        if key in self.arguments:
+            if self.arguments[key] is not None:
+                return self.arguments[key]
+        return default
+    
+    def close_input_panel(self):
+        sublime.active_window().run_command('hide_panel', { 'cancel': True }) # close input panel
+        self.input_panel = None
+    
+    def compare_to_previous(self):
+        """Compare the pending_value with the current_value and process it if it is different."""
+        self.timeout_active = False
+        if self.pending_value != self.current_value: # no point reporting the same input again
+            self.current_value = self.pending_value
+            self.process_current_input()
+    
+    def input_changed(self, value):
+        """When the input is changed in live mode, after a short delay (so that it doesn't report unnecessarily while the text is still being typed), report the current value."""
+        self.pending_value = value
+        
+        if self.live_mode:
+            use_delay = self.get_value_from_args('delay', 0)
+            if self.current_value is None: # if this is the initial input, report it immediately
+                use_delay = 0
+            
+            if not self.timeout_active:
+                self.timeout_active = True
+                if self.get_value_from_args('async', True):
+                    sublime.set_timeout_async(lambda: self.compare_to_previous(), use_delay)
+                else:
+                    sublime.set_timeout(lambda: self.compare_to_previous(), use_delay)
+        
+    def input_cancelled(self):
+        self.input_panel = None
+    
+    def input_done(self, value):
+        """When input is completed, if the current value hasn't already been processed, process it now."""
+        self.input_panel = None
+        self.pending_value = value
+        self.compare_to_previous()
+    
+    def process_current_input(self):
+        pass

sublime_input_quickpanel.py

@@ -0,0 +1,58 @@
+import sublime
+import sublime_plugin
+from .sublime_input import RequestInputCommand
+
+class QuickPanelFromInputCommand(RequestInputCommand): # example usage from python console: sublime.active_window().active_view().run_command('quick_panel_from_input', { 'label': 'Enter text here:', 'initial_value': 'Hello World' })
+    items = None
+    
+    def run(self, edit, **args):
+        super().run(edit, **args)
+        self.items = None
+    
+    def close_quick_panel(self):
+        """Close existing quick panel."""
+        sublime.active_window().run_command('hide_overlay', { 'cancel': True })
+    
+    def input_cancelled(self):
+        self.close_quick_panel()
+        super().input_cancelled()
+    
+    def input_done(self, value):
+        if self.live_mode:
+            self.close_quick_panel()
+        super().input_done(value)
+        self.commit_input()
+    
+    def process_current_input(self):
+        items = self.get_items_from_input()
+        if items is not None:
+            self.items = items
+        else:
+            if self.get_value_from_args('use_previous_when_none', False):
+                return
+            else:
+                self.items = None
+        
+        self.close_quick_panel()
+        if items is not None:
+            self.view.window().show_quick_panel(self.get_items_to_show_in_quickpanel(), self.quickpanel_selection_done, sublime.KEEP_OPEN_ON_FOCUS_LOST, -1, self.quickpanel_selection_changed)
+            if self.input_panel is not None:
+                self.input_panel.window().focus_view(self.input_panel)
+        
+    def get_items_from_input(self):
+        return None
+    
+    def get_items_to_show_in_quickpanel(self):
+        return self.items
+    
+    def quickpanel_selection_changed(self, selected_index):
+        pass
+    
+    def quickpanel_selection_done(self, selected_index):
+        if selected_index > -1: # if it wasn't cancelled
+            self.close_input_panel()
+            if self.live_mode:
+                self.commit_input()
+
+    def commit_input(self):
+        pass

sublime_lxml.py

@@ -142,7 +142,7 @@ def move_cursors_to_nodes(view, nodes, position_type):
 
         view.show(cursors[0]) # scroll to show the first selection, if it is not already visible
 
-    return (len(cursors) == len(nodes), len(cursors))
+    return (len(cursors), len(nodes))
 
 def getElementXMLPreview(view, node, maxlen):
     """Generate the xml string for the given node, up to the specified number of characters."""