From d6bbf245c682048aa723a38257b11c647600681f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=96=9F=E9=85=8C=20=E9=B5=AC=E5=85=84?= Date: Sun, 13 Mar 2016 03:30:33 +0800 Subject: [PATCH 1/9] Some drafts --- botanjs/src/Components/Vim/LineFeeder.js | 195 +++++++++++++++++++++++ botanjs/src/Components/Vim/StatusBar.js | 50 ++++++ botanjs/src/Components/Vim/VimArea.js | 163 +++++++++++++++++++ botanjs/src/Components/Vim/_this.css | 4 + botanjs/src/Components/Vim/_this.js | 42 +++++ 5 files changed, 454 insertions(+) create mode 100644 botanjs/src/Components/Vim/LineFeeder.js create mode 100644 botanjs/src/Components/Vim/StatusBar.js create mode 100644 botanjs/src/Components/Vim/VimArea.js create mode 100644 botanjs/src/Components/Vim/_this.css create mode 100644 botanjs/src/Components/Vim/_this.js diff --git a/botanjs/src/Components/Vim/LineFeeder.js b/botanjs/src/Components/Vim/LineFeeder.js new file mode 100644 index 0000000..ae8af80 --- /dev/null +++ b/botanjs/src/Components/Vim/LineFeeder.js @@ -0,0 +1,195 @@ +(function(){ + var ns = __namespace( "Components.Vim" ); + + /** @type {Dandelion} */ + var Dand = __import( "Dandelion" ); + /** @type {Dandelion.IDOMElement} */ + var IDOMElement = __import( "Dandelion.IDOMElement" ); + /** @type {Dandelion.IDOMObject} */ + var IDOMObject = __import( "Dandelion.IDOMObject" ); + /** @type {System.Cycle} */ + var Cycle = __import( "System.Cycle" ); + /** @type {System.Debug} */ + var debug = __import( "System.Debug" ); + + var Line = function( cols, nextLine ) + { + this.cols = cols; + this.next = nextLine; + this.br = false; + this.placeholder = true; + }; + + Line.prototype.Push = function( content, wrap ) + { + if( content == undefined || content === "" ) + { + this.content = "~"; + this.placeholder = true; + if( this.next ) this.next.Push( content, wrap ); + return; + } + + this.placeholder = false; + + var line = ""; + var br = false; + + if( wrap ) + { + for( var i = 0; i < this.cols; i ++ ) + { + var c = content[i]; + if( c === undefined ) break; + + if( c == "\n" ) + { + br = true; + i ++; + break; + } + + line += c; + } + } + else + { + br = true; + for( var i = 0; true; i ++ ) + { + var c = content[i]; + if( c === undefined ) break; + + if( c == "\n" ) + { + i ++; + break; + } + + if( i < this.cols ) + { + line += c; + } + } + } + + if( this.next ) + { + this.next.br = br; + this.next.Push( content.substr( i ), wrap ); + } + + this.content = line; + }; + + Line.prototype.toString = function() + { + return this.content; + }; + + var Feeder = function( rows, cols ) + { + var lines = []; + + // Last line + lines[ rows - 1 ] = new Line( cols ); + + for( var i = rows - 2; 0 <= i; i -- ) + { + lines[i] = new Line( cols, lines[ i + 1 ] ); + } + + this.lines = lines; + this.setRender(); + }; + + Feeder.prototype.init = function( content, wrap ) + { + if( wrap == undefined ) wrap = true; + if( this.lines.length ) + { + this.lines[0].Push( content, wrap ); + } + }; + + // Advance the text to number of lines + Feeder.prototype.feed = function( num ) + { + }; + + Feeder.prototype.wrap = function( setwrap ) + { + }; + + Feeder.prototype.setRender = function( placeholder ) + { + if( placeholder == undefined ) placeholder = true; + + if( placeholder ) + { + this.__render = function( line, steps ) + { + var display = ( line == undefined ? "" : line ) + ""; + + for( var i = 0; + line && i < steps && ( line = line.next ); + i ++ ) + { + display += "\n" + line; + } + + return display; + }; + } + else + { + this.__render = function( line, steps ) + { + var display = ( line == undefined ? "" : line ) + ""; + + for( var i = 0; + line && i < steps && ( line = line.next ) && !line.placeholder; + i ++ ) + { + display += "\n" + line; + } + + return display; + }; + } + } + + Feeder.prototype.cursor = function( direction ) + { + switch( direction ) + { + case 0: + return { start: 0, end: 1 }; + } + }; + + Feeder.prototype.render = function( start, length ) + { + if( start == undefined ) start = 0; + else if( this.lines.length < start ) return ""; + + if( length == undefined || ( this.lines.length - start ) < length ) + length = this.lines.length - start; + + if( length == 0 ) return ""; + + return this.__render( this.lines[ start ], length - 1 ); + }; + + __readOnly( Feeder.prototype, "linesOccupied", function() { + var line = this.lines[0]; + if( line.placeholder ) return 0; + + var i = 0; + do i ++; + while( ( line = line.next ) && !line.placeholder ); + return i; + } ); + + ns[ NS_EXPORT ]( EX_CLASS, "LineFeeder", Feeder ); +})(); diff --git a/botanjs/src/Components/Vim/StatusBar.js b/botanjs/src/Components/Vim/StatusBar.js new file mode 100644 index 0000000..9aa4535 --- /dev/null +++ b/botanjs/src/Components/Vim/StatusBar.js @@ -0,0 +1,50 @@ +(function(){ var ns = __namespace( "Components.Vim" ); + + /** @type {Dandelion} */ + var Dand = __import( "Dandelion" ); + /** @type {Dandelion.IDOMElement} */ + var IDOMElement = __import( "Dandelion.IDOMElement" ); + /** @type {Dandelion.IDOMObject} */ + var IDOMObject = __import( "Dandelion.IDOMObject" ); + /** @type {System.Cycle} */ + var Cycle = __import( "System.Cycle" ); + /** @type {System.Debug} */ + var debug = __import( "System.Debug" ); + + /** @type {Components.VimArea.LineFeeder} */ + var LineFeeder = ns[ NS_INVOKE ]( "LineFeeder" ); + + var StatusBar = function( cols ) + { + this.cols = cols; + this.statStamp = {}; + }; + + StatusBar.prototype.stamp = function( pos, func ) + { + this.statStamp[ pos ] = func; + }; + + __readOnly( StatusBar.prototype, "statusText", function() + { + var display = ""; + var l = this.cols; + + for( var i = 0; i < l; i ++ ) + { + var avail = l - i; + var text = this.statStamp[ i ] || this.statStamp[ - avail ]; + if( text ) + { + text = text(); + display += text.substr( 0, avail ); + i = display.length - 1; + } + else display += " "; + } + + return display; + } ); + + ns[ NS_EXPORT ]( EX_CLASS, "StatusBar", StatusBar ); +})(); diff --git a/botanjs/src/Components/Vim/VimArea.js b/botanjs/src/Components/Vim/VimArea.js new file mode 100644 index 0000000..791f511 --- /dev/null +++ b/botanjs/src/Components/Vim/VimArea.js @@ -0,0 +1,163 @@ +(function(){ + var ns = __namespace( "Components.Vim" ); + + /** @type {Dandelion} */ + var Dand = __import( "Dandelion" ); + /** @type {Dandelion.IDOMElement} */ + var IDOMElement = __import( "Dandelion.IDOMElement" ); + /** @type {Dandelion.IDOMObject} */ + var IDOMObject = __import( "Dandelion.IDOMObject" ); + /** @type {System.utils.DataKey} */ + var DataKey = __import( "System.utils.DataKey" ); + /** @type {System.Cycle} */ + var Cycle = __import( "System.Cycle" ); + /** @type {System.Debug} */ + var debug = __import( "System.Debug" ); + + /** @type {Components.VimArea.LineFeeder} */ + var LineFeeder = ns[ NS_INVOKE ]( "LineFeeder" ); + var StatusBar = ns[ NS_INVOKE ]( "StatusBar" ); + + var KeyHandler = function( sender, handler ) + { + return function( e ) + { + e = e || window.event; + if ( e.keyCode ) code = e.keyCode; + else if ( e.which ) code = e.which; + + handler( sender, e ); + }; + }; + + var VimControls = function( sender, e ) + { + e.preventDefault(); + if( e.ctrlKey ) + { + VimComboFunc( sender, e ); + return; + } + + var kCode = e.KeyCode + ( e.shiftKey ? 1000 : 0 ); + switch( e.KeyCode ) + { + case 65: // a + case 1065: // A + break; + case 72: // h + case 1072: // H + break; + case 74: // j + case 1074: // J + break; + case 75: // k + case 1075: // K + break; + case 76: // l + case 1076: // L + break; + case 1053: // % + case 1054: // ^ + break; + } + }; + + /* stage @param {Dandelion.IDOMElement} */ + var VimArea = function( stage ) + { + if( !stage ) return; + + var element = stage.element; + + if( element.nodeName != "TEXTAREA" ) + { + debug.Error( "Element is not compatible for VimArea" ); + return; + } + + stage.setAttribute( new DataKey( "vimarea", 1 ) ); + + this.stage = stage; + this.rows = element.rows; + this.cols = element.cols; + + this.PosX = 1; + this.PosY = 1; + + stage.addEventListener( "KeyDown", KeyHandler( this, VimControls ) ); + + // Init + this.content = element.value; + this.VisualizeVimFrame(); + }; + + VimArea.prototype.startInput = function( mode ) + { + + }; + + VimArea.prototype.cursor = function( x, y ) + { + return this.__cursor(); + }; + + VimArea.prototype.flashCursor = function() + { + var _self = this; + var textarea = this.stage.element; + Cycle.perma( "VimCursorFlashCycle", function() + { + var cursor = _self.cursor(); + if( cursor ) + { + textarea.selectionStart = cursor.start; + textarea.selectionEnd = cursor.end; + } + }, 600 ); + }; + + VimArea.prototype.VisualizeVimFrame = function() + { + var element = this.stage.element; + var r = this.rows; + var c = this.cols; + + // Content feeder + var cfeeder = new LineFeeder( r, c ); + + cfeeder.init( this.content ); + + // Status feeder + sfeeder = new LineFeeder( r, c ); + sfeeder.setRender( false ); + + var statusBar = new StatusBar( c ); + statusBar.stamp( -18, function(){ + return "1,1-1"; + }); + + statusBar.stamp( -3, function(){ + return "All"; + }); + + sfeeder.init( statusBar.statusText ); + + element.value = cfeeder.render( 0, r - sfeeder.linesOccupied ) + "\n" + sfeeder.render(); + + this.contentFeeder = cfeeder; + this.statusFeeder = sfeeder; + + var f = true; + this.__cursor = function() + { + if( f = !f ) + return this.contentFeeder.cursor( 0 ); + else return { start: 0, end: 0 }; + } + + this.flashCursor(); + }; + + ns[ NS_EXPORT ]( EX_CLASS, "VimArea", VimArea ); +})(); diff --git a/botanjs/src/Components/Vim/_this.css b/botanjs/src/Components/Vim/_this.css new file mode 100644 index 0000000..1716ca4 --- /dev/null +++ b/botanjs/src/Components/Vim/_this.css @@ -0,0 +1,4 @@ +textarea[data-vimarea="1"] { + color: transparent; + text-shadow: 0 0 0 #000; +} diff --git a/botanjs/src/Components/Vim/_this.js b/botanjs/src/Components/Vim/_this.js new file mode 100644 index 0000000..706cf48 --- /dev/null +++ b/botanjs/src/Components/Vim/_this.js @@ -0,0 +1,42 @@ +(function(){ + var ns = __namespace( "Components.Vim" ); + + /** @type {Dandelion} */ + var Dand = __import( "Dandelion" ); + /** @type {Dandelion.IDOMElement} */ + var IDOMElement = __import( "Dandelion.IDOMElement" ); + /** @type {Dandelion.IDOMObject} */ + var IDOMObject = __import( "Dandelion.IDOMObject" ); + /** @type {System.Cycle} */ + var Cycle = __import( "System.Cycle" ); + /** @type {System.Debug} */ + var debug = __import( "System.Debug" ); + + var messages = { + "INSERT": "-- INSERT --" + , "MORE": "-- MORE --" + , "WRITE": "\"%1\" %2L, %3C written" + , "CONTINUE": "Press ENTER or type command to continue" + , "SEARCH_HIT_BOTTOM": "Seach hit BOTTOM, contining at TOP" + , "TOP": "Top" + , "BOTTOM": "Bot" + , "ALL": "All" + , "EXIT": "Type :quit to exit Vim" + }; + + var errors = { + "E486": "E486: Pattern not found: %1" + }; + + var Message = function( key ) + { + var restArgs = Array.prototype.slice.apply( arguments, 1 ); + var i = 0; + return messages[ key ].replace( /%\d+/g, function( e ) + { + return restArgs[ i ++ ]; + } ); + }; + + ns[ NS_EXPORT ]( EX_FUNC, "Message", Message ); +})(); From 6ce714be1e8a6b6ef088746099980dd44d2f2c50 Mon Sep 17 00:00:00 2001 From: tgckpg Date: Sun, 13 Mar 2016 03:31:55 +0800 Subject: [PATCH 2/9] Create LICENSE --- botanjs/src/Components/Vim/LICENSE | 674 +++++++++++++++++++++++++++++ 1 file changed, 674 insertions(+) create mode 100644 botanjs/src/Components/Vim/LICENSE diff --git a/botanjs/src/Components/Vim/LICENSE b/botanjs/src/Components/Vim/LICENSE new file mode 100644 index 0000000..9cecc1d --- /dev/null +++ b/botanjs/src/Components/Vim/LICENSE @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + {one line to give the program's name and a brief idea of what it does.} + Copyright (C) {year} {name of author} + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + {project} Copyright (C) {year} {fullname} + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. From 751530b42d7ea237677ac3333fc28b9fd42cab12 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=96=9F=E9=85=8C=20=E9=B5=AC=E5=85=84?= Date: Sun, 13 Mar 2016 08:35:29 +0800 Subject: [PATCH 3/9] Some navigation, but not working:( --- botanjs/src/Components/Vim/Cursor.js | 162 +++++++++++++++++++++++ botanjs/src/Components/Vim/LineBuffer.js | 111 ++++++++++++++++ botanjs/src/Components/Vim/LineFeeder.js | 120 +++-------------- botanjs/src/Components/Vim/VimArea.js | 100 ++++++++------ botanjs/src/Components/Vim/_this.js | 1 + 5 files changed, 356 insertions(+), 138 deletions(-) create mode 100644 botanjs/src/Components/Vim/Cursor.js create mode 100644 botanjs/src/Components/Vim/LineBuffer.js diff --git a/botanjs/src/Components/Vim/Cursor.js b/botanjs/src/Components/Vim/Cursor.js new file mode 100644 index 0000000..b72ea1b --- /dev/null +++ b/botanjs/src/Components/Vim/Cursor.js @@ -0,0 +1,162 @@ +(function(){ + var ns = __namespace( "Components.Vim" ); + + /** @type {Dandelion} */ + var Dand = __import( "Dandelion" ); + /** @type {Dandelion.IDOMElement} */ + var IDOMElement = __import( "Dandelion.IDOMElement" ); + /** @type {Dandelion.IDOMObject} */ + var IDOMObject = __import( "Dandelion.IDOMObject" ); + /** @type {System.Cycle} */ + var Cycle = __import( "System.Cycle" ); + /** @type {System.Debug} */ + var debug = __import( "System.Debug" ); + + var GetLine = function( buffs, l ) + { + /** @type {Components.Vim.LineBuffer} */ + var LineHead = buffs[0]; + l ++; + + for( var i = 0, line = LineHead; + line && i < l; i ++ ) + { + LineHead = line; + while( line ) + { + line = line.next; + if( line.br ) break; + } + } + + return LineHead; + }; + + var LineOffset = function( buffs, l ) + { + /** @type {Components.Vim.LineBuffer} */ + var offset = 0; + + for( var i = 0, line = buffs[0]; + line && i < l; i ++ ) + { + while( line ) + { + if( line.br ) + { + offset += line.prev.toString().length + 1; + + // Empty line has a special space + if( line.content == "" ) offset ++; + + line = line.next; + break; + } + else + { + if( offset == 0 ) offset -= 1; + + if( line.next && !line.next.br ) + offset += line.cols + 1; + } + + line = line.next; + } + } + + debug.Info( offset ); + + return offset; + }; + + var Cursor = function( buffs ) + { + this.buffers = buffs; + this.cols = buffs[0].cols; + + // The preferred X position + this.pX = 0; + + // The displaying X position + this.X = 0; + + // The current line resided + this.Y = 0; + + // The resulting position + this.P = 0; + }; + + // Can only be 1, -1 + // 0 will be treated as undefined + Cursor.prototype.moveX = function( d ) + { + var x = this.pX; + + var updatePx = Boolean( d ); + if( updatePx ) x = this.X + d; + + if( !d ) d = 1; + + var buffs = this.buffers; + + /** @type {Components.Vim.LineBuffer} */ + var line = GetLine( buffs, this.Y ); + var content = line.visualLines.join( "\n" ); + + var c = content[ x ]; + + if( c == undefined ) + { + x = d > 0 ? content.length - 1 : 0; + } + else if( c == "\n" ) + { + x += d; + } + + this.X = x; + + if( updatePx ) + { + this.pX = x; + this.updatePosition(); + } + }; + + Cursor.prototype.lineStart = function() + { + this.pX = 0; + this.moveX(); + this.updatePosition(); + }; + + Cursor.prototype.lineEnd = function() + { + /** @type {Components.Vim.LineBuffer} */ + this.moveX( Number.MAX_VALUE ); + }; + + Cursor.prototype.updatePosition = function() + { + this.P = this.X + LineOffset( this.buffers, this.Y ); + }; + + Cursor.prototype.moveY = function( d ) + { + this.Y += d; + this.moveX(); + this.updatePosition(); + }; + + __readOnly( Cursor.prototype, "position", function() + { + return { + start: this.P + , end: this.P + 1 + }; + } ); + + + ns[ NS_EXPORT ]( EX_CLASS, "Cursor", Cursor ); +})(); diff --git a/botanjs/src/Components/Vim/LineBuffer.js b/botanjs/src/Components/Vim/LineBuffer.js new file mode 100644 index 0000000..aa0360a --- /dev/null +++ b/botanjs/src/Components/Vim/LineBuffer.js @@ -0,0 +1,111 @@ +(function(){ + var ns = __namespace( "Components.Vim" ); + + /** @type {Dandelion} */ + var Dand = __import( "Dandelion" ); + /** @type {Dandelion.IDOMElement} */ + var IDOMElement = __import( "Dandelion.IDOMElement" ); + /** @type {Dandelion.IDOMObject} */ + var IDOMObject = __import( "Dandelion.IDOMObject" ); + /** @type {System.Cycle} */ + var Cycle = __import( "System.Cycle" ); + /** @type {System.Debug} */ + var debug = __import( "System.Debug" ); + + var LineBuffer = function( cols, nextLineBuffer ) + { + this.prev = null; + this.cols = cols; + this.next = nextLineBuffer; + this.br = false; + this.placeholder = true; + + if( nextLineBuffer ) + { + nextLineBuffer.prev = this; + } + + }; + + LineBuffer.prototype.Push = function( content, wrap ) + { + if( content == undefined || content === "" ) + { + this.content = "~"; + this.placeholder = true; + if( this.next ) this.next.Push( content, wrap ); + return; + } + + this.placeholder = false; + + var line = ""; + var br = false; + + if( wrap ) + { + for( var i = 0; i < this.cols; i ++ ) + { + var c = content[i]; + if( c === undefined ) break; + + if( c == "\n" ) + { + br = true; + i ++; + break; + } + + line += c; + } + } + else + { + br = true; + for( var i = 0; true; i ++ ) + { + var c = content[i]; + if( c === undefined ) break; + + if( c == "\n" ) + { + i ++; + break; + } + + if( i < this.cols ) + { + line += c; + } + } + } + + if( this.next ) + { + this.next.br = br; + this.next.Push( content.substr( i ), wrap ); + } + + this.content = line; + }; + + LineBuffer.prototype.toString = function() + { + return this.content || " "; + }; + + __readOnly( LineBuffer.prototype, "visualLines", function() + { + var lines = [ this ]; + var line = this; + while( ( line = line.next ) && !line.br ) + { + lines.push( line ); + } + + return lines; + } ); + + + ns[ NS_EXPORT ]( EX_CLASS, "LineBuffer", LineBuffer ); +})(); diff --git a/botanjs/src/Components/Vim/LineFeeder.js b/botanjs/src/Components/Vim/LineFeeder.js index ae8af80..2aba1f8 100644 --- a/botanjs/src/Components/Vim/LineFeeder.js +++ b/botanjs/src/Components/Vim/LineFeeder.js @@ -12,111 +12,38 @@ /** @type {System.Debug} */ var debug = __import( "System.Debug" ); - var Line = function( cols, nextLine ) - { - this.cols = cols; - this.next = nextLine; - this.br = false; - this.placeholder = true; - }; - - Line.prototype.Push = function( content, wrap ) - { - if( content == undefined || content === "" ) - { - this.content = "~"; - this.placeholder = true; - if( this.next ) this.next.Push( content, wrap ); - return; - } - - this.placeholder = false; - - var line = ""; - var br = false; - - if( wrap ) - { - for( var i = 0; i < this.cols; i ++ ) - { - var c = content[i]; - if( c === undefined ) break; - - if( c == "\n" ) - { - br = true; - i ++; - break; - } - - line += c; - } - } - else - { - br = true; - for( var i = 0; true; i ++ ) - { - var c = content[i]; - if( c === undefined ) break; - - if( c == "\n" ) - { - i ++; - break; - } - - if( i < this.cols ) - { - line += c; - } - } - } - - if( this.next ) - { - this.next.br = br; - this.next.Push( content.substr( i ), wrap ); - } - - this.content = line; - }; - - Line.prototype.toString = function() - { - return this.content; - }; + /** @type {Components.Vim.LineBuffer} */ + var LineBuffer = ns[ NS_INVOKE ]( "LineBuffer" ); + /** @type {Components.Vim.Cursor} */ + var Cursor = ns[ NS_INVOKE ]( "Cursor" ); var Feeder = function( rows, cols ) { - var lines = []; + var lineBuffers = []; // Last line - lines[ rows - 1 ] = new Line( cols ); + lineBuffers[ rows - 1 ] = new LineBuffer( cols ); for( var i = rows - 2; 0 <= i; i -- ) { - lines[i] = new Line( cols, lines[ i + 1 ] ); + lineBuffers[i] = new LineBuffer( cols, lineBuffers[ i + 1 ] ); } - this.lines = lines; + this.cursor = new Cursor( lineBuffers ); + + this.lineBuffers = lineBuffers; this.setRender(); }; Feeder.prototype.init = function( content, wrap ) { if( wrap == undefined ) wrap = true; - if( this.lines.length ) + if( this.lineBuffers.length ) { - this.lines[0].Push( content, wrap ); + this.lineBuffers[0].Push( content, wrap ); } }; - // Advance the text to number of lines - Feeder.prototype.feed = function( num ) - { - }; - Feeder.prototype.wrap = function( setwrap ) { }; @@ -159,30 +86,23 @@ } } - Feeder.prototype.cursor = function( direction ) - { - switch( direction ) - { - case 0: - return { start: 0, end: 1 }; - } - }; - Feeder.prototype.render = function( start, length ) { - if( start == undefined ) start = 0; - else if( this.lines.length < start ) return ""; + var buffs = this.lineBuffers; - if( length == undefined || ( this.lines.length - start ) < length ) - length = this.lines.length - start; + if( start == undefined ) start = 0; + else if( buffs.length < start ) return ""; + + if( length == undefined || ( buffs.length - start ) < length ) + length = buffs.length - start; if( length == 0 ) return ""; - return this.__render( this.lines[ start ], length - 1 ); + return this.__render( buffs[ start ], length - 1 ); }; __readOnly( Feeder.prototype, "linesOccupied", function() { - var line = this.lines[0]; + var line = this.lineBuffers[0]; if( line.placeholder ) return 0; var i = 0; diff --git a/botanjs/src/Components/Vim/VimArea.js b/botanjs/src/Components/Vim/VimArea.js index 791f511..159a34f 100644 --- a/botanjs/src/Components/Vim/VimArea.js +++ b/botanjs/src/Components/Vim/VimArea.js @@ -14,8 +14,9 @@ /** @type {System.Debug} */ var debug = __import( "System.Debug" ); - /** @type {Components.VimArea.LineFeeder} */ + /** @type {Components.Vim.LineFeeder} */ var LineFeeder = ns[ NS_INVOKE ]( "LineFeeder" ); + /** @type {Components.Vim.StatusBar} */ var StatusBar = ns[ NS_INVOKE ]( "StatusBar" ); var KeyHandler = function( sender, handler ) @@ -32,6 +33,11 @@ var VimControls = function( sender, e ) { + if( e.altKey + // F2 - F12 + || ( 112 < e.keyCode && e.keyCode < 124 ) + ) return; + e.preventDefault(); if( e.ctrlKey ) { @@ -39,28 +45,49 @@ return; } - var kCode = e.KeyCode + ( e.shiftKey ? 1000 : 0 ); - switch( e.KeyCode ) + var kCode = e.keyCode + ( e.shiftKey ? 1000 : 0 ); + + var cfeeder = sender.contentFeeder; + switch( kCode ) { + // Cursor movements + case 72: // h + cfeeder.cursor.moveX( -1 ); + break; + case 74: // j + cfeeder.cursor.moveY( 1 ); + break; + case 75: // k + cfeeder.cursor.moveY( -1 ); + break; + case 76: // l + cfeeder.cursor.moveX( 1 ); + break; + case 65: // a case 1065: // A break; - case 72: // h - case 1072: // H + case 1072: // H, First line buffer break; - case 74: // j - case 1074: // J + case 1076: // L, Last line buffer break; - case 75: // k - case 1075: // K - break; - case 76: // l - case 1076: // L + case 1052: // $ + cfeeder.cursor.lineEnd(); break; case 1053: // % - case 1054: // ^ break; + case 1054: // ^ + cfeeder.cursor.lineStart(); + break; + case 1074: // J, Join lines + break; + case 1075: // K, manual entry + break; + case 112: // F1, help } + + sender.__blink = false; + sender.select( cfeeder.cursor.position ); }; /* stage @param {Dandelion.IDOMElement} */ @@ -94,31 +121,23 @@ VimArea.prototype.startInput = function( mode ) { - }; - VimArea.prototype.cursor = function( x, y ) + VimArea.prototype.select = function( sel ) { - return this.__cursor(); - }; - - VimArea.prototype.flashCursor = function() - { - var _self = this; var textarea = this.stage.element; - Cycle.perma( "VimCursorFlashCycle", function() + + if( sel ) { - var cursor = _self.cursor(); - if( cursor ) - { - textarea.selectionStart = cursor.start; - textarea.selectionEnd = cursor.end; - } - }, 600 ); + textarea.selectionStart = sel.start; + textarea.selectionEnd = sel.end; + } }; VimArea.prototype.VisualizeVimFrame = function() { + var _self = this; + var element = this.stage.element; var r = this.rows; var c = this.cols; @@ -132,6 +151,7 @@ sfeeder = new LineFeeder( r, c ); sfeeder.setRender( false ); + // XXX: Placeholder var statusBar = new StatusBar( c ); statusBar.stamp( -18, function(){ return "1,1-1"; @@ -143,20 +163,24 @@ sfeeder.init( statusBar.statusText ); - element.value = cfeeder.render( 0, r - sfeeder.linesOccupied ) + "\n" + sfeeder.render(); + element.value = + cfeeder.render( 0, r - sfeeder.linesOccupied ) + + "\n" + sfeeder.render(); this.contentFeeder = cfeeder; this.statusFeeder = sfeeder; - var f = true; - this.__cursor = function() - { - if( f = !f ) - return this.contentFeeder.cursor( 0 ); - else return { start: 0, end: 0 }; - } + this.__cursor = cfeeder.cursor; - this.flashCursor(); + this.__blink = true; + Cycle.perma( "VimCursorBlinkCycle" + element.id, function() + { + _self.select( + ( _self.__blink = !_self.__blink ) + ? _self.__cursor.position + : { start: 0, end: 0 } + ); + }, 600 ); }; ns[ NS_EXPORT ]( EX_CLASS, "VimArea", VimArea ); diff --git a/botanjs/src/Components/Vim/_this.js b/botanjs/src/Components/Vim/_this.js index 706cf48..5de456f 100644 --- a/botanjs/src/Components/Vim/_this.js +++ b/botanjs/src/Components/Vim/_this.js @@ -14,6 +14,7 @@ var messages = { "INSERT": "-- INSERT --" + , "REPLACE": "-- REPLACE --" , "MORE": "-- MORE --" , "WRITE": "\"%1\" %2L, %3C written" , "CONTINUE": "Press ENTER or type command to continue" From 2548970f3a77df69da1f463514dfdaa2e7beb7f3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=96=9F=E9=85=8C=20=E9=B5=AC=E5=85=84?= Date: Sun, 13 Mar 2016 20:26:26 +0800 Subject: [PATCH 4/9] Partial nav of "jkhl$^" --- botanjs/src/Components/Vim/Cursor.js | 51 +++++++----- botanjs/src/Components/Vim/LineBuffer.js | 2 +- botanjs/src/Components/Vim/LineFeeder.js | 100 ++++++++++++++++------- botanjs/src/Components/Vim/VimArea.js | 27 +++++- botanjs/src/Components/Vim/_this.js | 1 + 5 files changed, 129 insertions(+), 52 deletions(-) diff --git a/botanjs/src/Components/Vim/Cursor.js b/botanjs/src/Components/Vim/Cursor.js index b72ea1b..4ce90fa 100644 --- a/botanjs/src/Components/Vim/Cursor.js +++ b/botanjs/src/Components/Vim/Cursor.js @@ -37,42 +37,39 @@ /** @type {Components.Vim.LineBuffer} */ var offset = 0; + LineLoop: for( var i = 0, line = buffs[0]; line && i < l; i ++ ) { while( line ) { - if( line.br ) + if( line.next && line.next.placeholder ) + break LineLoop; + + if( line.next && line.next.br ) { - offset += line.prev.toString().length + 1; - - // Empty line has a special space - if( line.content == "" ) offset ++; - + offset += line.toString().length + 1; line = line.next; break; } else { - if( offset == 0 ) offset -= 1; - - if( line.next && !line.next.br ) - offset += line.cols + 1; + offset += line.cols + 1; } line = line.next; } } - debug.Info( offset ); - return offset; }; - var Cursor = function( buffs ) + var Cursor = function( feeder ) { - this.buffers = buffs; - this.cols = buffs[0].cols; + /** @type {Components.Vim.LineFeeder} */ + this.feeder = feeder; + + this.cols = feeder.lineBuffers[0].cols; // The preferred X position this.pX = 0; @@ -98,7 +95,7 @@ if( !d ) d = 1; - var buffs = this.buffers; + var buffs = this.feeder.lineBuffers; /** @type {Components.Vim.LineBuffer} */ var line = GetLine( buffs, this.Y ); @@ -133,18 +130,34 @@ Cursor.prototype.lineEnd = function() { - /** @type {Components.Vim.LineBuffer} */ this.moveX( Number.MAX_VALUE ); }; Cursor.prototype.updatePosition = function() { - this.P = this.X + LineOffset( this.buffers, this.Y ); + this.P = this.X + LineOffset( this.feeder.lineBuffers, this.Y ); }; Cursor.prototype.moveY = function( d ) { - this.Y += d; + var Y = this.Y; + + Y += d; + if( Y < 0 ) Y = 0; + + if( this.feeder.moreAt < Y ) + { + this.feeder.pan( undefined, Y - this.feeder.moreAt ); + + // Keep original position after panning + this.moveX(); + this.updatePosition(); + this.refresh(); + return; + } + + this.Y = Y; + this.moveX(); this.updatePosition(); }; diff --git a/botanjs/src/Components/Vim/LineBuffer.js b/botanjs/src/Components/Vim/LineBuffer.js index aa0360a..ff54620 100644 --- a/botanjs/src/Components/Vim/LineBuffer.js +++ b/botanjs/src/Components/Vim/LineBuffer.js @@ -24,7 +24,6 @@ { nextLineBuffer.prev = this; } - }; LineBuffer.prototype.Push = function( content, wrap ) @@ -32,6 +31,7 @@ if( content == undefined || content === "" ) { this.content = "~"; + this.br = true; this.placeholder = true; if( this.next ) this.next.Push( content, wrap ); return; diff --git a/botanjs/src/Components/Vim/LineFeeder.js b/botanjs/src/Components/Vim/LineFeeder.js index 2aba1f8..7725443 100644 --- a/botanjs/src/Components/Vim/LineFeeder.js +++ b/botanjs/src/Components/Vim/LineFeeder.js @@ -29,10 +29,18 @@ lineBuffers[i] = new LineBuffer( cols, lineBuffers[ i + 1 ] ); } - this.cursor = new Cursor( lineBuffers ); - this.lineBuffers = lineBuffers; + + this.panX = 0; + this.panY = 0; + this.setRender(); + + this.cursor = new Cursor( this ); + this.dispatcher = new EventDispatcher(); + + this.__clseLine = null; + this.__moreAt = -1; }; Feeder.prototype.init = function( content, wrap ) @@ -52,38 +60,35 @@ { if( placeholder == undefined ) placeholder = true; - if( placeholder ) - { - this.__render = function( line, steps ) - { - var display = ( line == undefined ? "" : line ) + ""; + var _self = this; - for( var i = 0; - line && i < steps && ( line = line.next ); - i ++ ) + var placeholdCond = placeholder + ? function( line ) { return true; } + : function( line ) { return !line.placeholder; } + ; + + this.__render = function( line, steps ) + { + var display = ( line == undefined ? "" : line ) + ""; + + var atSpace = false + for( var i = 0; + line && i < steps && ( line = line.next ) && placeholdCond( line ); + i ++ ) + { + if( atSpace || ( line.br && steps < ( i + line.visualLines.length ) ) ) { - display += "\n" + line; + if( !atSpace ) _self.__clseLine = line; + atSpace = true; + display += "\n@"; + continue; } - return display; - }; - } - else - { - this.__render = function( line, steps ) - { - var display = ( line == undefined ? "" : line ) + ""; + display += "\n" + line; + } - for( var i = 0; - line && i < steps && ( line = line.next ) && !line.placeholder; - i ++ ) - { - display += "\n" + line; - } - - return display; - }; - } + return display; + }; } Feeder.prototype.render = function( start, length ) @@ -101,6 +106,43 @@ return this.__render( buffs[ start ], length - 1 ); }; + Feeder.prototype.pan = function( dX, dY ) + { + if( dX == undefined ) dX = 0; + if( dY == undefined ) dY = 0; + + var X = this.panX + dX; + var Y = this.panY + dY; + + // this.dispatcher.dispatchEvent( new BotanEvent( "VisualUpdate" ) ); + }; + + __readOnly( Feeder.prototype, "moreAt", function() { + if( 0 < this.__moreAt ) return this.__moreAt; + + var line = this.lineBuffers[0]; + if( line.placeholder ) return 0; + + var i = 0; + do + { + if( this.__clseLine == line ) break; + if( line.br ) i ++; + } + while( line = line.next ); + + return ( this.__moreAt = i ); + } ); + + __readOnly( Feeder.prototype, "lineStat", function() { + var X = this.cursor.X; + return ( this.cursor.Y + this.panY + 1 ) + "," + X + "-" + ( X ); + } ); + + __readOnly( Feeder.prototype, "docPos", function() { + return "Top"; + } ); + __readOnly( Feeder.prototype, "linesOccupied", function() { var line = this.lineBuffers[0]; if( line.placeholder ) return 0; diff --git a/botanjs/src/Components/Vim/VimArea.js b/botanjs/src/Components/Vim/VimArea.js index 159a34f..0cea4d7 100644 --- a/botanjs/src/Components/Vim/VimArea.js +++ b/botanjs/src/Components/Vim/VimArea.js @@ -52,6 +52,7 @@ { // Cursor movements case 72: // h + case 8: // Backspace cfeeder.cursor.moveX( -1 ); break; case 74: // j @@ -86,6 +87,14 @@ case 112: // F1, help } + var sfeeder = sender.statusFeeder; + var statusBar = sender.statusBar; + + sfeeder.init( statusBar.statusText ); + sender.stage.element.value = + cfeeder.render( 0, sender.rows - sfeeder.linesOccupied ) + + "\n" + sfeeder.render(); + sender.__blink = false; sender.select( cfeeder.cursor.position ); }; @@ -112,7 +121,13 @@ this.PosX = 1; this.PosY = 1; + this.__active = false; + + var _self = this; + stage.addEventListener( "KeyDown", KeyHandler( this, VimControls ) ); + stage.addEventListener( "Focus", function() { _self.__active = true; } ); + stage.addEventListener( "Blur", function() { _self.__active = false; } ); // Init this.content = element.value; @@ -125,6 +140,7 @@ VimArea.prototype.select = function( sel ) { + if( !this.__active ) return; var textarea = this.stage.element; if( sel ) @@ -154,12 +170,12 @@ // XXX: Placeholder var statusBar = new StatusBar( c ); statusBar.stamp( -18, function(){ - return "1,1-1"; + return cfeeder.lineStat; }); statusBar.stamp( -3, function(){ - return "All"; - }); + return cfeeder.docPos; + } ); sfeeder.init( statusBar.statusText ); @@ -167,8 +183,13 @@ cfeeder.render( 0, r - sfeeder.linesOccupied ) + "\n" + sfeeder.render(); + cfeeder.dispatcher.addEventListener( "VisualUpdate", function() + { + } ); + this.contentFeeder = cfeeder; this.statusFeeder = sfeeder; + this.statusBar = statusBar; this.__cursor = cfeeder.cursor; diff --git a/botanjs/src/Components/Vim/_this.js b/botanjs/src/Components/Vim/_this.js index 5de456f..d61f8fc 100644 --- a/botanjs/src/Components/Vim/_this.js +++ b/botanjs/src/Components/Vim/_this.js @@ -16,6 +16,7 @@ "INSERT": "-- INSERT --" , "REPLACE": "-- REPLACE --" , "MORE": "-- MORE --" + , "VISLINE": "-- VISUAL LINE --" , "WRITE": "\"%1\" %2L, %3C written" , "CONTINUE": "Press ENTER or type command to continue" , "SEARCH_HIT_BOTTOM": "Seach hit BOTTOM, contining at TOP" From bd35ed56b1ab9e605eea45b57becec6956178ada Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=96=9F=E9=85=8C=20=E9=B5=AC=E5=85=84?= Date: Mon, 14 Mar 2016 02:15:24 +0800 Subject: [PATCH 5/9] j for collapsed line ( partial ) --- botanjs/src/Components/Vim/Cursor.js | 55 +++++++++++++++--- botanjs/src/Components/Vim/LineBuffer.js | 14 +++-- botanjs/src/Components/Vim/LineFeeder.js | 74 ++++++++++++++++++------ botanjs/src/Components/Vim/StatusBar.js | 3 +- botanjs/src/Components/Vim/VimArea.js | 44 +++++++------- botanjs/src/Components/Vim/_this.js | 20 ++++++- 6 files changed, 154 insertions(+), 56 deletions(-) diff --git a/botanjs/src/Components/Vim/Cursor.js b/botanjs/src/Components/Vim/Cursor.js index 4ce90fa..0fb6284 100644 --- a/botanjs/src/Components/Vim/Cursor.js +++ b/botanjs/src/Components/Vim/Cursor.js @@ -69,7 +69,7 @@ /** @type {Components.Vim.LineFeeder} */ this.feeder = feeder; - this.cols = feeder.lineBuffers[0].cols; + this.cols = feeder.firstBuffer.cols; // The preferred X position this.pX = 0; @@ -136,6 +136,7 @@ Cursor.prototype.updatePosition = function() { this.P = this.X + LineOffset( this.feeder.lineBuffers, this.Y ); + this.feeder.dispatcher.dispatchEvent( new BotanEvent( "VisualUpdate" ) ); }; Cursor.prototype.moveY = function( d ) @@ -143,16 +144,42 @@ var Y = this.Y; Y += d; - if( Y < 0 ) Y = 0; - - if( this.feeder.moreAt < Y ) + if( Y < 0 ) { - this.feeder.pan( undefined, Y - this.feeder.moreAt ); + Y = 0; + } + else if( this.feeder.moreAt < Y ) + { + var feeder = this.feeder; + var lastLine = feeder.lastBuffer.lineNum; + var i = 0; + while( true ) + { + feeder.pan( undefined, Y - feeder.moreAt + i ); + + // If it is the same line we keep scrolling it + // until the entire line cosumes the screen + if( feeder.lastBuffer.lineNum == lastLine ) + { + i ++; + } + else break; + } + + for( i = 0, line = feeder.firstBuffer; + line != feeder.lastBuffer; + line = line.next ) + { + if( line.br ) i ++; + if( line.lineNum == Y ) break; + } + + this.Y = i; // Keep original position after panning this.moveX(); this.updatePosition(); - this.refresh(); + return; } @@ -162,6 +189,21 @@ this.updatePosition(); }; + Cursor.prototype.getLine = function() + { + var feeder = this.feeder; + var line = feeder.firstBuffer; + for( var i = 0; + line != feeder.lastBuffer; + line = line.next ) + { + if( line.br ) i ++; + if( this.Y == i ) break; + } + + return line; + }; + __readOnly( Cursor.prototype, "position", function() { return { @@ -170,6 +212,5 @@ }; } ); - ns[ NS_EXPORT ]( EX_CLASS, "Cursor", Cursor ); })(); diff --git a/botanjs/src/Components/Vim/LineBuffer.js b/botanjs/src/Components/Vim/LineBuffer.js index ff54620..ed612a6 100644 --- a/botanjs/src/Components/Vim/LineBuffer.js +++ b/botanjs/src/Components/Vim/LineBuffer.js @@ -19,6 +19,7 @@ this.next = nextLineBuffer; this.br = false; this.placeholder = true; + this.lineNum = 0; if( nextLineBuffer ) { @@ -26,14 +27,15 @@ } }; - LineBuffer.prototype.Push = function( content, wrap ) + LineBuffer.prototype.Push = function( content, wrap, n ) { + this.lineNum = n; if( content == undefined || content === "" ) { this.content = "~"; this.br = true; this.placeholder = true; - if( this.next ) this.next.Push( content, wrap ); + if( this.next ) this.next.Push( content, wrap, n + 1 ); return; } @@ -42,9 +44,10 @@ var line = ""; var br = false; + var i = 0; if( wrap ) { - for( var i = 0; i < this.cols; i ++ ) + for( ; i < this.cols; i ++ ) { var c = content[i]; if( c === undefined ) break; @@ -62,7 +65,7 @@ else { br = true; - for( var i = 0; true; i ++ ) + for( ; true; i ++ ) { var c = content[i]; if( c === undefined ) break; @@ -83,7 +86,7 @@ if( this.next ) { this.next.br = br; - this.next.Push( content.substr( i ), wrap ); + this.next.Push( content.substr( i ), wrap, br ? n + 1 : n ); } this.content = line; @@ -106,6 +109,5 @@ return lines; } ); - ns[ NS_EXPORT ]( EX_CLASS, "LineBuffer", LineBuffer ); })(); diff --git a/botanjs/src/Components/Vim/LineFeeder.js b/botanjs/src/Components/Vim/LineFeeder.js index 7725443..3edc1b7 100644 --- a/botanjs/src/Components/Vim/LineFeeder.js +++ b/botanjs/src/Components/Vim/LineFeeder.js @@ -21,12 +21,12 @@ { var lineBuffers = []; - // Last line - lineBuffers[ rows - 1 ] = new LineBuffer( cols ); + // Last line, hidden buffer that won't be rendered + this.__xBuffer = lineBuffers[ rows ] = new LineBuffer( cols ); - for( var i = rows - 2; 0 <= i; i -- ) + for( var i = rows - 1; 0 <= i; i -- ) { - lineBuffers[i] = new LineBuffer( cols, lineBuffers[ i + 1 ] ); + lineBuffers[ i ] = new LineBuffer( cols, lineBuffers[ i + 1 ] ); } this.lineBuffers = lineBuffers; @@ -41,19 +41,23 @@ this.__clseLine = null; this.__moreAt = -1; + this.__rows = rows; + + this.__wrap = true; }; Feeder.prototype.init = function( content, wrap ) { - if( wrap == undefined ) wrap = true; - if( this.lineBuffers.length ) - { - this.lineBuffers[0].Push( content, wrap ); - } + this.content = content; + this.setWrap( wrap ); + + this.firstBuffer.Push( content, this.__wrap, 0 ); }; - Feeder.prototype.wrap = function( setwrap ) + Feeder.prototype.setWrap = function( wrap ) { + if( wrap == undefined ) return; + this.__wrap = wrap; }; Feeder.prototype.setRender = function( placeholder ) @@ -96,10 +100,10 @@ var buffs = this.lineBuffers; if( start == undefined ) start = 0; - else if( buffs.length < start ) return ""; + else if( this.__rows < start ) return ""; - if( length == undefined || ( buffs.length - start ) < length ) - length = buffs.length - start; + if( length == undefined || ( this.__rows - start ) < length ) + length = this.rows - start; if( length == 0 ) return ""; @@ -111,16 +115,40 @@ if( dX == undefined ) dX = 0; if( dY == undefined ) dY = 0; + if( dX == 0 && dY == 0 ) return; + var X = this.panX + dX; var Y = this.panY + dY; - // this.dispatcher.dispatchEvent( new BotanEvent( "VisualUpdate" ) ); + var f = this.content.indexOf( "\n" ); + var i = 1; + + while( f != - 1 && i < Y ) + { + i ++; + f = this.content.indexOf( "\n", f + 1 ); + } + + this.firstBuffer.Push( + this.content.substr( f + 1 ) + , this.__wrap, i ); + + this.panX = X; + this.panY = Y; }; + __readOnly( Feeder.prototype, "firstBuffer", function() { + return this.lineBuffers[ 0 ]; + } ); + + __readOnly( Feeder.prototype, "lastBuffer", function() { + return this.lineBuffers[ this.__rows - 1 ]; + } ); + __readOnly( Feeder.prototype, "moreAt", function() { if( 0 < this.__moreAt ) return this.__moreAt; - var line = this.lineBuffers[0]; + var line = this.firstBuffer; if( line.placeholder ) return 0; var i = 0; @@ -136,15 +164,25 @@ __readOnly( Feeder.prototype, "lineStat", function() { var X = this.cursor.X; - return ( this.cursor.Y + this.panY + 1 ) + "," + X + "-" + ( X ); + return ( this.cursor.getLine().lineNum + 1 ) + "," + X + "-" + ( X ); } ); __readOnly( Feeder.prototype, "docPos", function() { - return "Top"; + var pos = "ALL"; + + if( this.panY == 0 ) + { + if( this.__clseLine || !this.EOF ) + { + pos = "TOP"; + } + } + + return pos; } ); __readOnly( Feeder.prototype, "linesOccupied", function() { - var line = this.lineBuffers[0]; + var line = this.firstBuffer; if( line.placeholder ) return 0; var i = 0; diff --git a/botanjs/src/Components/Vim/StatusBar.js b/botanjs/src/Components/Vim/StatusBar.js index 9aa4535..20424c8 100644 --- a/botanjs/src/Components/Vim/StatusBar.js +++ b/botanjs/src/Components/Vim/StatusBar.js @@ -1,4 +1,5 @@ -(function(){ var ns = __namespace( "Components.Vim" ); +(function(){ + var ns = __namespace( "Components.Vim" ); /** @type {Dandelion} */ var Dand = __import( "Dandelion" ); diff --git a/botanjs/src/Components/Vim/VimArea.js b/botanjs/src/Components/Vim/VimArea.js index 0cea4d7..bf3105b 100644 --- a/botanjs/src/Components/Vim/VimArea.js +++ b/botanjs/src/Components/Vim/VimArea.js @@ -19,6 +19,8 @@ /** @type {Components.Vim.StatusBar} */ var StatusBar = ns[ NS_INVOKE ]( "StatusBar" ); + var mesg = ns[ NS_INVOKE ]( "Message" ); + var KeyHandler = function( sender, handler ) { return function( e ) @@ -87,16 +89,6 @@ case 112: // F1, help } - var sfeeder = sender.statusFeeder; - var statusBar = sender.statusBar; - - sfeeder.init( statusBar.statusText ); - sender.stage.element.value = - cfeeder.render( 0, sender.rows - sfeeder.linesOccupied ) - + "\n" + sfeeder.render(); - - sender.__blink = false; - sender.select( cfeeder.cursor.position ); }; /* stage @param {Dandelion.IDOMElement} */ @@ -130,8 +122,7 @@ stage.addEventListener( "Blur", function() { _self.__active = false; } ); // Init - this.content = element.value; - this.VisualizeVimFrame(); + this.VisualizeVimFrame( element.value ); }; VimArea.prototype.startInput = function( mode ) @@ -150,7 +141,7 @@ } }; - VimArea.prototype.VisualizeVimFrame = function() + VimArea.prototype.VisualizeVimFrame = function( content ) { var _self = this; @@ -161,7 +152,7 @@ // Content feeder var cfeeder = new LineFeeder( r, c ); - cfeeder.init( this.content ); + cfeeder.init( content ); // Status feeder sfeeder = new LineFeeder( r, c ); @@ -174,18 +165,25 @@ }); statusBar.stamp( -3, function(){ - return cfeeder.docPos; + return mesg( cfeeder.docPos ); } ); sfeeder.init( statusBar.statusText ); - element.value = - cfeeder.render( 0, r - sfeeder.linesOccupied ) - + "\n" + sfeeder.render(); - - cfeeder.dispatcher.addEventListener( "VisualUpdate", function() + var Update = function() { - } ); + sfeeder.init( statusBar.statusText ); + + element.value = + cfeeder.render( 0, r - sfeeder.linesOccupied ) + + "\n" + sfeeder.render(); + + _self.__blink = false; + _self.select( cfeeder.cursor.position ); + }; + + cfeeder.dispatcher.addEventListener( "VisualUpdate", Update ); + Update(); this.contentFeeder = cfeeder; this.statusFeeder = sfeeder; @@ -204,5 +202,9 @@ }, 600 ); }; + __readOnly( VimArea.prototype, "content", function() { + return this.contentFeeder.content; + } ); + ns[ NS_EXPORT ]( EX_CLASS, "VimArea", VimArea ); })(); diff --git a/botanjs/src/Components/Vim/_this.js b/botanjs/src/Components/Vim/_this.js index d61f8fc..d45751f 100644 --- a/botanjs/src/Components/Vim/_this.js +++ b/botanjs/src/Components/Vim/_this.js @@ -30,15 +30,29 @@ "E486": "E486: Pattern not found: %1" }; - var Message = function( key ) + var GetString = function( arr, key, restArgs ) { - var restArgs = Array.prototype.slice.apply( arguments, 1 ); + if( arr[ key ] == undefined ) return key; + var i = 0; - return messages[ key ].replace( /%\d+/g, function( e ) + return arr[ key ].replace( /%\d+/g, function( e ) { return restArgs[ i ++ ]; } ); }; + var Message = function( key ) + { + var restArgs = Array.prototype.slice.call( arguments, 1 ); + return GetString( messages, key, restArgs ); + }; + + var Error = function( key ) + { + var restArgs = Array.prototype.slice.call( arguments, 1 ); + return GetString( errors, key, restArgs ); + }; + ns[ NS_EXPORT ]( EX_FUNC, "Message", Message ); + ns[ NS_EXPORT ]( EX_FUNC, "Error", Error ); })(); From 9757dec7a0d4c423f45731e2ef252110ef2f7b68 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=96=9F=E9=85=8C=20=E9=B5=AC=E5=85=84?= Date: Mon, 14 Mar 2016 03:33:36 +0800 Subject: [PATCH 6/9] Handle the tabwidth --- botanjs/src/Components/Vim/Cursor.js | 4 +- botanjs/src/Components/Vim/LineBuffer.js | 14 +++++- botanjs/src/Components/Vim/LineFeeder.js | 57 ++++++++++++++++++++++-- 3 files changed, 68 insertions(+), 7 deletions(-) diff --git a/botanjs/src/Components/Vim/Cursor.js b/botanjs/src/Components/Vim/Cursor.js index 0fb6284..542051c 100644 --- a/botanjs/src/Components/Vim/Cursor.js +++ b/botanjs/src/Components/Vim/Cursor.js @@ -54,7 +54,7 @@ } else { - offset += line.cols + 1; + offset += line.toString().length + 1; } line = line.next; @@ -180,6 +180,8 @@ this.moveX(); this.updatePosition(); + feeder.softReset(); + return; } diff --git a/botanjs/src/Components/Vim/LineBuffer.js b/botanjs/src/Components/Vim/LineBuffer.js index ed612a6..05a7f5c 100644 --- a/botanjs/src/Components/Vim/LineBuffer.js +++ b/botanjs/src/Components/Vim/LineBuffer.js @@ -20,6 +20,7 @@ this.br = false; this.placeholder = true; this.lineNum = 0; + this.tabWidth = 8; if( nextLineBuffer ) { @@ -45,9 +46,10 @@ var br = false; var i = 0; + var numTabs = 0; if( wrap ) { - for( ; i < this.cols; i ++ ) + for( ; i < this.cols - numTabs * this.tabWidth; i ++ ) { var c = content[i]; if( c === undefined ) break; @@ -58,6 +60,10 @@ i ++; break; } + else if( c == "\t" ) + { + numTabs ++; + } line += c; } @@ -75,8 +81,12 @@ i ++; break; } + else if( c == "\t" ) + { + numTabs ++; + } - if( i < this.cols ) + if( i < this.cols - numTabs * this.tabWidth ) { line += c; } diff --git a/botanjs/src/Components/Vim/LineFeeder.js b/botanjs/src/Components/Vim/LineFeeder.js index 3edc1b7..b86f17f 100644 --- a/botanjs/src/Components/Vim/LineFeeder.js +++ b/botanjs/src/Components/Vim/LineFeeder.js @@ -75,7 +75,8 @@ { var display = ( line == undefined ? "" : line ) + ""; - var atSpace = false + var atSpace = false; + for( var i = 0; line && i < steps && ( line = line.next ) && placeholdCond( line ); i ++ ) @@ -93,6 +94,23 @@ return display; }; + + this.__softRender = function() + { + var line = _self.lineBuffers[ _self.__rStart ]; + var steps = _self.__rLength; + + for( var i = 0; + line && i < steps && ( line = line.next ) && placeholdCond( line ); + i ++ ) + { + if( line.br && steps < ( i + line.visualLines.length ) ) + { + _self.__clseLine = line; + break; + } + } + }; } Feeder.prototype.render = function( start, length ) @@ -107,7 +125,9 @@ if( length == 0 ) return ""; - return this.__render( buffs[ start ], length - 1 ); + this.__rStart = start; + this.__rLength = length - 1; + return this.__render( buffs[ start ], this.__rLength ); }; Feeder.prototype.pan = function( dX, dY ) @@ -137,6 +157,13 @@ this.panY = Y; }; + Feeder.prototype.softReset = function() + { + this.__moreAt = -1; + this.__clseLine = null; + this.__softRender(); + }; + __readOnly( Feeder.prototype, "firstBuffer", function() { return this.lineBuffers[ 0 ]; } ); @@ -145,6 +172,10 @@ return this.lineBuffers[ this.__rows - 1 ]; } ); + __readOnly( Feeder.prototype, "EOF", function() { + return this.lineBuffers[ this.__rows ].placeholder; + } ); + __readOnly( Feeder.prototype, "moreAt", function() { if( 0 < this.__moreAt ) return this.__moreAt; @@ -159,18 +190,35 @@ } while( line = line.next ); + if( line == undefined ) i --; + return ( this.__moreAt = i ); } ); __readOnly( Feeder.prototype, "lineStat", function() { var X = this.cursor.X; - return ( this.cursor.getLine().lineNum + 1 ) + "," + X + "-" + ( X ); + + var line = this.cursor.getLine(); + var tabStat = ""; + + var tabs = line.content.match( /\t/g ); + + if( tabs ) + { + tabStat = "-" + ( X + tabs.length * line.tabWidth ); + } + + return ( line.lineNum + 1 ) + "," + X + tabStat; } ); __readOnly( Feeder.prototype, "docPos", function() { var pos = "ALL"; - if( this.panY == 0 ) + if( 0 < this.panY && this.EOF ) + { + pos = "BOTTOM"; + } + else { if( this.__clseLine || !this.EOF ) { @@ -178,6 +226,7 @@ } } + return pos; } ); From 97480cd0c61e50b3e5e5aaeec65041b6f6b84b19 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=96=9F=E9=85=8C=20=E9=B5=AC=E5=85=84?= Date: Mon, 14 Mar 2016 23:28:30 +0800 Subject: [PATCH 7/9] wordwrap panning for j --- botanjs/src/Components/Vim/Cursor.js | 39 ++++++++++++++++-------- botanjs/src/Components/Vim/LineBuffer.js | 11 +++++++ botanjs/src/Components/Vim/VimArea.js | 7 +++-- 3 files changed, 42 insertions(+), 15 deletions(-) diff --git a/botanjs/src/Components/Vim/Cursor.js b/botanjs/src/Components/Vim/Cursor.js index 542051c..b9caecf 100644 --- a/botanjs/src/Components/Vim/Cursor.js +++ b/botanjs/src/Components/Vim/Cursor.js @@ -46,18 +46,12 @@ if( line.next && line.next.placeholder ) break LineLoop; - if( line.next && line.next.br ) - { - offset += line.toString().length + 1; - line = line.next; - break; - } - else - { - offset += line.toString().length + 1; - } - + // Using toString because tab is 1 byte + // but variable width + offset += line.toString().length + 1; line = line.next; + + if( line && line.br ) break; } } @@ -142,6 +136,7 @@ Cursor.prototype.moveY = function( d ) { var Y = this.Y; + var line; Y += d; if( Y < 0 ) @@ -152,13 +147,16 @@ { var feeder = this.feeder; var lastLine = feeder.lastBuffer.lineNum; + var lineShift = Y - feeder.moreAt; var i = 0; while( true ) { - feeder.pan( undefined, Y - feeder.moreAt + i ); + feeder.pan( undefined, lineShift + i ); - // If it is the same line we keep scrolling it + // if it turns out to be the same line + // before after panning + // we keep scrolling it ( panning ) // until the entire line cosumes the screen if( feeder.lastBuffer.lineNum == lastLine ) { @@ -167,6 +165,10 @@ else break; } + // The line number cursor need to be in + Y = lastLine + lineShift; + + // Calculate the visual line position for( i = 0, line = feeder.firstBuffer; line != feeder.lastBuffer; line = line.next ) @@ -184,6 +186,17 @@ return; } + else if ( this.Y < Y ) + { + // If panning is forward + // and next line does not exists + line = this.getLine().nextLine; + if( !line || line.placeholder ) + { + // do nothing + return; + } + } this.Y = Y; diff --git a/botanjs/src/Components/Vim/LineBuffer.js b/botanjs/src/Components/Vim/LineBuffer.js index 05a7f5c..51c9861 100644 --- a/botanjs/src/Components/Vim/LineBuffer.js +++ b/botanjs/src/Components/Vim/LineBuffer.js @@ -33,6 +33,7 @@ this.lineNum = n; if( content == undefined || content === "" ) { + this.lineNum = ++n; this.content = "~"; this.br = true; this.placeholder = true; @@ -107,6 +108,16 @@ return this.content || " "; }; + __readOnly( LineBuffer.prototype, "nextLine", function() + { + var line = this; + var thisLine = this.lineNum; + + while( ( line = line.next ) && line.lineNum == thisLine ); + + return line; + } ); + __readOnly( LineBuffer.prototype, "visualLines", function() { var lines = [ this ]; diff --git a/botanjs/src/Components/Vim/VimArea.js b/botanjs/src/Components/Vim/VimArea.js index bf3105b..a030595 100644 --- a/botanjs/src/Components/Vim/VimArea.js +++ b/botanjs/src/Components/Vim/VimArea.js @@ -149,12 +149,15 @@ var r = this.rows; var c = this.cols; + // StatusFeeder always consumes at least 1 line + var cRange = r - 1; + // Content feeder - var cfeeder = new LineFeeder( r, c ); + var cfeeder = new LineFeeder( cRange, c ); cfeeder.init( content ); - // Status feeder + // Status can consumes up to full screen, I think sfeeder = new LineFeeder( r, c ); sfeeder.setRender( false ); From cbec2c747589527be78f9f509e6ad235f45cb4ef Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=96=9F=E9=85=8C=20=E9=B5=AC=E5=85=84?= Date: Mon, 14 Mar 2016 23:57:17 +0800 Subject: [PATCH 8/9] wordwrap panning for k --- botanjs/src/Components/Vim/Cursor.js | 14 ++++++++++---- botanjs/src/Components/Vim/LineFeeder.js | 17 ++++++++++++----- 2 files changed, 22 insertions(+), 9 deletions(-) diff --git a/botanjs/src/Components/Vim/Cursor.js b/botanjs/src/Components/Vim/Cursor.js index b9caecf..eba3821 100644 --- a/botanjs/src/Components/Vim/Cursor.js +++ b/botanjs/src/Components/Vim/Cursor.js @@ -135,13 +135,19 @@ Cursor.prototype.moveY = function( d ) { - var Y = this.Y; + var Y = this.Y + d; var line; - Y += d; if( Y < 0 ) { - Y = 0; + this.feeder.pan( undefined, d ); + + this.Y = 0; + this.moveX(); + this.updatePosition(); + + this.feeder.softReset(); + return; } else if( this.feeder.moreAt < Y ) { @@ -186,7 +192,7 @@ return; } - else if ( this.Y < Y ) + else if ( 0 < d ) { // If panning is forward // and next line does not exists diff --git a/botanjs/src/Components/Vim/LineFeeder.js b/botanjs/src/Components/Vim/LineFeeder.js index b86f17f..61807a2 100644 --- a/botanjs/src/Components/Vim/LineFeeder.js +++ b/botanjs/src/Components/Vim/LineFeeder.js @@ -130,6 +130,7 @@ return this.__render( buffs[ start ], this.__rLength ); }; + // Performs a line panning Feeder.prototype.pan = function( dX, dY ) { if( dX == undefined ) dX = 0; @@ -140,13 +141,19 @@ var X = this.panX + dX; var Y = this.panY + dY; - var f = this.content.indexOf( "\n" ); - var i = 1; + var f = -1; + var i = 0; - while( f != - 1 && i < Y ) + // Y cannot be negative + if( Y < 0 ) Y = 0; + + if( 0 < Y ) { - i ++; - f = this.content.indexOf( "\n", f + 1 ); + f = this.content.indexOf( "\n" ); + for( i = 1; f != - 1 && i < Y; i ++ ) + { + f = this.content.indexOf( "\n", f + 1 ); + } } this.firstBuffer.Push( From 52e4733fcc4e2301ecc45ab2f946b33d4db04289 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E6=96=9F=E9=85=8C=20=E9=B5=AC=E5=85=84?= Date: Tue, 15 Mar 2016 03:06:16 +0800 Subject: [PATCH 9/9] Some interfaces --- botanjs/src/Components/Vim/Actions/INSERT.js | 38 ++++++++++++++++++++ botanjs/src/Components/Vim/Cursor.js | 20 +++++++++++ botanjs/src/Components/Vim/StatusBar.js | 2 ++ botanjs/src/Components/Vim/VimArea.js | 25 +++++++++++-- 4 files changed, 83 insertions(+), 2 deletions(-) create mode 100644 botanjs/src/Components/Vim/Actions/INSERT.js diff --git a/botanjs/src/Components/Vim/Actions/INSERT.js b/botanjs/src/Components/Vim/Actions/INSERT.js new file mode 100644 index 0000000..4757065 --- /dev/null +++ b/botanjs/src/Components/Vim/Actions/INSERT.js @@ -0,0 +1,38 @@ +(function(){ + var ns = __namespace( "Components.Vim.Actions" ); + + /** @type {Dandelion} */ + var Dand = __import( "Dandelion" ); + /** @type {Dandelion.IDOMElement} */ + var IDOMElement = __import( "Dandelion.IDOMElement" ); + /** @type {Dandelion.IDOMObject} */ + var IDOMObject = __import( "Dandelion.IDOMObject" ); + /** @type {System.Cycle} */ + var Cycle = __import( "System.Cycle" ); + /** @type {System.Debug} */ + var debug = __import( "System.Debug" ); + + var Mesg = __import( "Components.Vim.Message" ); + + /** @type {Components.Vim.Cursor.IAction} */ + var INSERT = function( Cursor ) + { + /** @type {Components.Vim.Cursor} */ + this.cursor = Cursor; + }; + + INSERT.prototype.dispose = function() + { + }; + + INSERT.prototype.getMessage = function() + { + var l = this.cursor.feeder.firstBuffer.cols; + var msg = Mesg( "INSERT" ); + + for( var i = msg.length; i < l; i ++ ) msg += " "; + return msg; + }; + + ns[ NS_EXPORT ]( EX_CLASS, "INSERT", INSERT ); +})(); diff --git a/botanjs/src/Components/Vim/Cursor.js b/botanjs/src/Components/Vim/Cursor.js index eba3821..cb58611 100644 --- a/botanjs/src/Components/Vim/Cursor.js +++ b/botanjs/src/Components/Vim/Cursor.js @@ -12,6 +12,8 @@ /** @type {System.Debug} */ var debug = __import( "System.Debug" ); + var Actions = __import( "Components.Vim.Actions.*" ); + var GetLine = function( buffs, l ) { /** @type {Components.Vim.LineBuffer} */ @@ -76,6 +78,9 @@ // The resulting position this.P = 0; + + /** @type {Components.Vim.IAction} */ + this.action = null; }; // Can only be 1, -1 @@ -210,6 +215,15 @@ this.updatePosition(); }; + Cursor.prototype.openInsert = function() + { + var feeder = this.feeder; + if( this.action ) this.action.dispose(); + this.action = new Actions[ "INSERT" ]; + + feeder.dispatcher.dispatchEvent( new BotanEvent( "VisualUpdate" ) ); + }; + Cursor.prototype.getLine = function() { var feeder = this.feeder; @@ -225,6 +239,12 @@ return line; }; + __readOnly( Cursor.prototype, "message", function() + { + return this.action && this.action.getMessage(); + } ); + + __readOnly( Cursor.prototype, "position", function() { return { diff --git a/botanjs/src/Components/Vim/StatusBar.js b/botanjs/src/Components/Vim/StatusBar.js index 20424c8..ecdec78 100644 --- a/botanjs/src/Components/Vim/StatusBar.js +++ b/botanjs/src/Components/Vim/StatusBar.js @@ -38,6 +38,8 @@ if( text ) { text = text(); + if( text == undefined || text === "" ) continue; + display += text.substr( 0, avail ); i = display.length - 1; } diff --git a/botanjs/src/Components/Vim/VimArea.js b/botanjs/src/Components/Vim/VimArea.js index a030595..e4d00c9 100644 --- a/botanjs/src/Components/Vim/VimArea.js +++ b/botanjs/src/Components/Vim/VimArea.js @@ -50,11 +50,13 @@ var kCode = e.keyCode + ( e.shiftKey ? 1000 : 0 ); var cfeeder = sender.contentFeeder; + var sfeeder = sender.statusFeeder; switch( kCode ) { // Cursor movements + case 8: // Backspace, go back 1 char, regardless of line + break; case 72: // h - case 8: // Backspace cfeeder.cursor.moveX( -1 ); break; case 74: // j @@ -67,9 +69,24 @@ cfeeder.cursor.moveX( 1 ); break; + // Insert case 65: // a - case 1065: // A + cfeeder.cursor.openInsert(); break; + + case 1065: // A, append at the line end + break; + case 73: // i + break; + case 1073: // I, append before the line start, after spaces + break; + + // remove characters + case 88: // x, remove in cursor + break; + case 1088: // X, remove before cursor + break; + case 1072: // H, First line buffer break; case 1076: // L, Last line buffer @@ -171,6 +188,10 @@ return mesg( cfeeder.docPos ); } ); + statusBar.stamp( 0, function(){ + return cfeeder.cursor.message; + } ); + sfeeder.init( statusBar.statusText ); var Update = function()