redcar-dev 0.12.0dev-java

data/plugins/edit_view_swt/lib/edit_view_swt/document.rb

@@ -0,0 +1,224 @@
+
+module Redcar
+  class EditViewSWT
+    class Document
+      include Redcar::Observable
+      attr_reader :jface_document
+
+      def initialize(model, swt_mate_document)
+        @model          = model
+        @swt_mate_document = swt_mate_document
+        @jface_document = swt_mate_document.mateText.get_document
+      end
+
+      def right_click(edit_view)
+        menu = Menu.new
+        Redcar.plugin_manager.objects_implementing(:edit_view_context_menus).each do |object|
+          case object.method(:edit_view_context_menus).arity
+          when 0
+            menu.merge(object.edit_view_context_menus)
+          when 1
+            menu.merge(object.edit_view_context_menus(edit_view))
+          else
+            puts("Invalid edit_view_context_menus hook detected in "+object.class.name)
+          end
+        end
+        Application::Dialog.popup_menu(menu, :pointer)
+      end
+      
+      def attach_modification_listeners
+        jface_document.add_document_listener(DocumentListener.new(@model))
+        styledText.add_selection_listener(SelectionListener.new(@model))
+        styledText.add_caret_listener(CaretListener.new(@model))
+      end
+
+      def single_line?
+        @swt_mate_document.mateText.isSingleLine
+      end
+
+      def to_s
+        jface_document.get
+      end
+
+      def length
+        jface_document.length
+      end
+
+      def line_count
+        jface_document.get_number_of_lines
+      end
+
+      def get_line_delimiter
+        styledText.get_line_delimiter
+      end
+
+      def line_at_offset(offset)
+        jface_document.get_line_of_offset(offset)
+      end
+
+      def offset_at_line(line_ix)
+        line_ix = [line_ix, line_count - 1].min
+        jface_document.get_line_offset(line_ix)
+      end
+
+      def get_line(line_ix)
+        line_info = jface_document.get_line_information(line_ix)
+        jface_document.get(line_info.offset, line_info.length)
+      end
+
+      def get_range(start, length)
+        jface_document.get(start, length)
+      end
+
+      def replace(offset, length, text)
+        @model.verify_text(offset, offset+length, text)
+        jface_document.replace(offset, length, text)
+        @model.modify_text
+      end
+
+      def text=(text)
+        @model.verify_text(0, length, text)
+        top_pixel   = styledText.getTopPixel
+        caret       = cursor_offset
+        line        = line_at_offset(caret)
+        caret       = caret - offset_at_line(line)
+
+        styledText.setRedraw(false)
+        styledText.setText(text)
+
+        unless line > line_count - 1
+          # The documents new text is still longer than our previous position, restore position
+          line_offset = offset_at_line(line)
+          styledText.setCaretOffset([line_offset + caret, offset_at_line(line + 1) - 1].min)
+          styledText.setTopPixel(top_pixel)
+        end
+
+        styledText.setRedraw(true)
+        @model.modify_text
+        notify_listeners(:set_text)
+      end
+
+      def cursor_offset
+        styledText.get_caret_offset
+      end
+
+      def selection_offset
+        range = styledText.get_selection_range
+        range.x == cursor_offset ? range.x + range.y : range.x
+      end
+
+      def cursor_offset=(offset)
+        styledText.set_caret_offset(offset)
+      end
+
+      def selection_range
+        range = styledText.get_selection_range
+        range.x...(range.x + range.y)
+      end
+
+      def selection_ranges
+        ranges = styledText.get_selection_ranges
+        ranges.to_a.each_slice(2).map do |from, length|
+          from...(from + length)
+        end
+      end
+
+      def set_selection_range(cursor_offset, selection_offset)
+        if block_selection_mode?
+          start_offset, end_offset = *[cursor_offset, selection_offset].sort
+          start_location = styledText.getLocationAtOffset(start_offset)
+          end_location   = styledText.getLocationAtOffset(end_offset)
+          styledText.set_block_selection_bounds(
+            start_location.x,
+            start_location.y,
+            end_location.x - start_location.x,
+            end_location.y - start_location.y + styledText.get_line_height
+          )
+        else
+          styledText.set_selection_range(selection_offset, cursor_offset - selection_offset)
+        end
+        @model.selection_range_changed(cursor_offset, selection_offset)
+      end
+
+      @markStruct ||= Struct.new(:location, :category) # save away the parent class
+      class Mark < @markStruct
+        def get_offset;      location.get_offset;      end
+        def get_line;        location.get_line;        end
+        def get_line_offset; location.get_line_offset; end
+        def inspect;         "<Mark #{get_line}:#{get_line_offset} (#{get_offset})>"; end
+      end
+
+      def create_mark(offset, gravity)
+        line = line_at_offset(offset)
+        line_offset = offset - offset_at_line(line)
+        case gravity
+        when :left
+          category = "lefts"
+        when :right
+          category = "rights"
+        end
+  			location = @swt_mate_document.get_text_location(line, line_offset)
+				@swt_mate_document.add_text_location(category, location)
+				Mark.new(location, category)
+      end
+
+      def delete_mark(mark)
+        @swt_mate_document.remove_text_location(mark.category, mark.location)
+      end
+
+      def block_selection_mode?
+        styledText.get_block_selection
+      end
+
+      def block_selection_mode=(bool)
+        styledText.set_block_selection(bool)
+      end
+
+      def styledText
+        @swt_mate_document.mateText.getControl
+      end
+
+      def scope_at(line, line_offset)
+        @swt_mate_document.mateText.scope_at(line, line_offset)
+      end
+
+      class CaretListener
+        def initialize(model)
+          @model = model
+        end
+
+        def caret_moved(event)
+          @model.cursor_moved(event.caretOffset)
+        end
+      end
+
+      class SelectionListener
+        def initialize(model)
+          @model = model
+        end
+
+        def widget_default_selected(e)
+          @model.selection_range_changed(e.x, e.y)
+        end
+
+        def widget_selected(e)
+          @model.selection_range_changed(e.x, e.y)
+        end
+      end
+
+      class DocumentListener
+        def initialize(model)
+          @model = model
+        end
+
+        def document_about_to_be_changed(e)
+          @model.about_to_be_changed(e.offset, e.length, e.text)
+        end
+
+        def document_changed(e)
+          @model.changed(e.offset, e.length, e.text)
+        end
+      end
+    end
+  end
+end

data/plugins/edit_view_swt/lib/edit_view_swt/edit_tab.rb

@@ -0,0 +1,50 @@
+module Redcar
+  class EditViewSWT
+    class Tab < ApplicationSWT::Tab
+      include Redcar::Observable
+      
+      attr_reader :item, :edit_view
+      
+      def initialize(*args)
+        super
+        @model.add_listener(:changed_title) { |title| @item.text = title }
+      end
+      
+      # Focuses the CTabItem within the CTabFolder, and gives the keyboard
+      # focus to the EditViewSWT.
+      def focus
+        super
+        edit_view.focus
+      end
+      
+      # Close the EditTab, disposing of any resources along the way.
+      def close
+        @edit_view.dispose
+        @widget.dispose
+        super
+      end
+      
+      private
+      
+      def create_tab_widget
+        @widget = Swt::Widgets::Composite.new(notebook.tab_folder, Swt::SWT::NONE)
+        layout = Swt::Layout::GridLayout.new(1, false)
+        layout.verticalSpacing = 0
+        layout.marginHeight = 0
+        layout.horizontalSpacing = 0
+        layout.marginWidth = 0
+        @widget.layout = layout
+        @edit_view = EditViewSWT.new(model.edit_view, @widget)
+        
+        grid_data = Swt::Layout::GridData.new(
+                      Swt::Layout::GridData::FILL_BOTH | 
+                      Swt::Layout::GridData::VERTICAL_ALIGN_FILL |
+                      Swt::Layout::GridData::HORIZONTAL_ALIGN_FILL)
+        @edit_view.mate_text.get_control.parent.set_layout_data(grid_data)
+
+        @item.control = @widget
+        @widget.pack
+      end
+    end
+  end
+end

data/plugins/edit_view_swt/lib/edit_view_swt/word_movement.rb

@@ -0,0 +1,68 @@
+
+module Redcar
+  class EditViewSWT
+    class WordMoveListener
+      MOVE_FORWARD_RE = /\s{3,}|[^\w]{2,}|(\s|[^\w])?\w+/
+    
+      def initialize(controller)
+        @controller = controller
+      end
+      
+      def get_next_offset(e)
+        if [Swt::SWT::MOVEMENT_WORD, Swt::SWT::MOVEMENT_WORD_END].include? e.movement
+          e.newOffset = next_offset(e.offset, e.lineOffset, e.lineText)
+          # SWT gets pissy without this:
+          if e.newOffset == e.lineOffset + e.lineText.chars.length + 1
+            e.newOffset += 1
+          end
+        end
+      end
+      
+      def next_offset(chars_offset, chars_line_offset, line_text)
+        if chars_offset == chars_line_offset + line_text.chars.length
+          chars_offset + 1
+        else
+          future_text = line_text.chars[(chars_offset - chars_line_offset)..-1].to_s
+          if future_text == nil or future_text == ""
+            chars_line_offset + line_text.chars.length
+          else
+            if md = future_text.match(MOVE_FORWARD_RE)
+              chars_match_end = future_text.byte_offset_to_char_offset(md.end(0))
+              chars_offset + chars_match_end
+            else
+              chars_line_offset + line_text.chars.length
+            end
+          end
+        end
+      end
+      
+      def get_previous_offset(e)
+        if [Swt::SWT::MOVEMENT_WORD, Swt::SWT::MOVEMENT_WORD_START].include? e.movement
+          e.newOffset = previous_offset(e.offset, e.lineOffset, e.lineText)
+          # SWT gets pissy without this:
+          if e.newOffset == e.lineOffset - 1
+            e.newOffset -= 1
+          end
+        end
+      end
+      
+      def previous_offset(chars_offset, chars_line_offset, line_text)
+        if chars_offset == chars_line_offset
+          chars_offset - 1
+        else
+          future_text = line_text.chars[0..(chars_offset - chars_line_offset - 1)].reverse.to_s
+          if future_text == nil or future_text == ""
+            chars_line_offset
+          else
+            if md = future_text.match(MOVE_FORWARD_RE)
+              chars_match_end = future_text.byte_offset_to_char_offset(md.end(0))
+              chars_offset - chars_match_end
+            else
+              chars_line_offset
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/plugins/edit_view_swt/plugin.rb

@@ -0,0 +1,9 @@
+
+Plugin.define do
+  name    "edit_view_swt"
+  version "1.0"
+  file    "lib", "edit_view_swt"
+  object  "Redcar::EditViewSWT"
+  dependencies "core", ">0",
+               "application_swt", ">0"
+end

data/plugins/edit_view_swt/spec/edit_view_swt/word_movement_spec.rb

@@ -0,0 +1,29 @@
+require File.join(File.dirname(__FILE__), "..", "spec_helper")
+
+describe Redcar::EditViewSWT::WordMoveListener do
+  before do
+    @word = Redcar::EditViewSWT::WordMoveListener.new(nil)
+  end
+  
+  describe "moving forwards" do
+    it "should move over a word to the next non-word char" do
+      @word.next_offset(0, 0, "foo.bar").should == 3
+    end
+  
+    it "should move over a symbol and a word to the next non-word char" do
+      @word.next_offset(0, 0, ".foo.bar").should == 4
+    end
+  
+    it "should move over multiple symbols to the next word" do
+      @word.next_offset(0, 0, "..foo.bar").should == 2
+    end
+  
+    it "should move over a space and the next word " do
+      @word.next_offset(0, 0, " foo.bar").should == 4
+    end
+  
+    it "should move over multiple spaces to the next word " do
+      @word.next_offset(0, 0, "  foo.bar").should == 2
+    end
+  end
+end

data/plugins/edit_view_swt/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+$:.push File.join(File.dirname(__FILE__), '..', '..', '..', 'lib')
+
+require 'redcar'
+Redcar.environment = :test
+Redcar.load_unthreaded

data/plugins/edit_view_swt/vendor/dummy

@@ -0,0 +1 @@
+dummy

data/plugins/edit_view_swt/vendor/java-mateview.rb

@@ -0,0 +1,35 @@
+
+module JavaMateView
+  import com.redcareditor.mate.Bundle
+  import com.redcareditor.mate.Grammar
+  import com.redcareditor.mate.MateText
+  import com.redcareditor.mate.Parser
+  import com.redcareditor.mate.ParserScheduler
+  import com.redcareditor.mate.Pattern
+  import com.redcareditor.mate.Scope
+  import com.redcareditor.mate.ScopeMatcher
+  import com.redcareditor.theme.Theme
+  import com.redcareditor.theme.ThemeManager
+  
+  class MateText
+    def set_root_scope_by_content_name(grammar_name, name)
+      scope = JavaMateView::Scope.new(self, "re")
+      bs = JavaMateView::Bundle.bundles
+      ruby = bs.detect {|b| b.name == grammar_name}
+      ps = ruby.grammars.first.patterns
+      dps = ps.select {|pt| pt.is_a?(Java::ComRedcareditorMate::DoublePattern) }  
+      rps = dps.detect {|pt| pt.contentName == name }
+      scope.pattern = rps
+      scope.isOpen = true
+      self.parser.root = scope
+    end
+    
+    def delay_parsing
+      parser.parserScheduler.deactivate
+      yield
+      parser.parserScheduler.reactivate
+    end
+  end
+end
+
+ 

data/plugins/encryption/encryption.rb

@@ -0,0 +1,52 @@
+
+
+module Encryption
+  def self.encrypt(text, password)
+    EncryptionTools.encrypt_and_armour(text, password)
+  end
+  
+  def self.decrypt(text, password)
+    EncryptionTools.dearmour_and_decrypt(text, password)
+  end
+  
+  def self.menus
+    Redcar::Menu::Builder.build do
+      sub_menu "Plugins" do
+        sub_menu "Encryption", :priority => 55 do
+          item "Encrypt Document", EncryptDocumentCommand
+          item "Decrypt Document", DecryptDocumentCommand
+        end
+      end
+    end
+  end
+
+  def self.lazy_load
+    require File.dirname(__FILE__) + "/jarmor-1.1"
+    require File.dirname(__FILE__) + "/ezcrypto"
+  end
+
+  class DecryptDocumentCommand < Redcar::EditTabCommand
+    def execute
+      Encryption.lazy_load
+      result = Redcar::Application::Dialog.input("Password", "Enter password")
+      return if result[:button] == :cancel
+      pw = result[:value]
+      begin
+        doc.text = Encryption.decrypt(doc.to_s, pw)
+      rescue => e
+        Redcar::Application::Dialog.message_box("Couldn't decrypt!", :type => :error)
+      end
+    end
+  end
+  
+  class EncryptDocumentCommand < Redcar::EditTabCommand
+    def execute
+      Encryption.lazy_load
+      result = Redcar::Application::Dialog.input("Password", "Enter password")
+      return if result[:button] == :cancel
+      pw = result[:value]
+      doc.text = Encryption.encrypt(doc.to_s, pw)
+    end
+  end
+end
+