I recently had a need for the Hebrew text of the traditional marriage documents, the ketubah and tenaim, and was very surprised that they are nowhere to be found, at least with my Google-fu. So I transcribed them and offer them with a liberal license to the world. The ketubah text is from Goldin's 1939 Hamadrikh and the tenaim text is that of haRav Feinstein (example).

These documents are licensed under a Creative Commons Attribution 3.0 Unported License.

tenaim (ODT)

tenaim (PDF)

ketubah (ODT)

ketubah (PDF)

Now that sendkeys is fixed to work with contenteditable and I've analyzed Lebedev's VirtualKeyboard to allow typing on the physical keyboard, updating the hebrewKeyboard plugin was straightforward. I had to learn a fair amount about the difference between keyup, keydown, and keypress events, but I think everything works. Check it out!

The big disadvantage is that the Caps Lock key is now disabled as a caps lock key. This is generally a good thing, but the standard Israeli keyboard uses it to insert nikud (the vowel markings that are placed over and under the consonants). So my keyboard can't insert nikud, which is not a problem for my usual uses, and the page is set to change to the original code with the query string ?keyboard=original.

The code was some minor changes in virtualkeyboard.js:

And a new button sprite image to reflect the new use of the Caps Lock key (this is in the css folder, in the desired theme; it's the button_set.png image): .

From the publisher's summary:

A comprehensive overview of Jewish History from Creation through the redaction of the Talmud, illuminating the intricacies and complexities of Torah tradition and philosophy according to the sages and classical commentaries, spanning the length and breadth of Jewish experience to resolve many of history’s most perplexing episodes, offering profound insights and showing their relevance to life in the modern world. An invaluable resource for scholars and laymen. A priceless tool for education and outreach.

How did the sin of Adam transform mankind and the world? How were the prophecies of Noah fulfilled through the rise of the Greek Empire? How did the builders of the Tower of Babel believe they could wage war against G-d? Why did there have to be three patriarchs? What was King David's crime regarding his involvement with BasSheva? Why did some Jews oppose the construction of the Second Temple? How can we trust the transmission of Torah if our scholars engaged in such fierce disagreements? These and many other questions are answered in this unique volume.

The Hebrew pop-up keyboard on the YI site search box was always hard-coded and kind of obtrusive, so I wanted to make a jQuery plugin to add a keyboard to any input type="text" or textarea. To make it more flexible, I factored it into a general-purpose popup widget and the keyboard itself.

Download the code.

$.ui.textpopup

The $.ui.textpopup widget is meant to be a base class for real popup widgets. It requires jQuery UI 1.7 and my subclassing code. The subclass needs to override the _fill method to fill the box with the desired controls. For example:

<div id="example1">
	Example 1: <input>
</div>

$.ui.textpopup.subclass("ui.helloWorld", {
	_fill: function(box){
		var self = this;
		$('<input type="button" value="Hello, World" />').appendTo(box).click(function() {
			self.element.val('Hello, World')
		});
	}
});

$('#example1 input').helloWorld();

textpopup has the following options:

show {Function}
Called to show the popup; this is set to the popup div and 
the speed is the argument(s) (this is meant to be a function called like $.fn.show). 
hide {Function}
Called to show the popup; this is set to the popup div and
the speed is the argument(s) (this is meant to be a function called like $.fn.hide)
box {jQuery object|undefined}
Element to contain the popup box. If undefined, a new, absolutely-positioned <div> is created. Set this to create an "inline" popup.
shown {Function}
Callback (this is set to the input element) called when show is completed
Also available as the custom event textpopupshown
hidden {Function}
Callback (this is set to the input element) called when hide is completed
Also available as the custom event textpopuphidden
created {Function}
Callback (this is set to the input element) called when the popup is created. Signature is
Function(Event, box {jQuery object})
Also available as the custom event textpopupcreated
speed {String|Number|Array}
Parameter to pass to show/hide above. If it is an array, it is passed with apply
so you can pass multiple arguments.
 For instance, to use jQuery UI effects, use speed: ['slide', {direction: 'right'}, 'slow']
hideOnOutsideClick {Boolean}
true to hide the popup if the mouse is clicked outside the popup or the target element
position {'tl'|'lt|'bl'|'lb'|'tr'|'rt'|'br'|'rb'|Object}
String that indicates where to position the popup
  relative to the textbox. 'tl' means on top of the input box, aligned to the left edge;
  'lt' means on the left of the input box aligned to the top edge; similarly 'b' for bottom
 and 'r' for right. If an object is passed, it will be passed unchanged to position, except that if the of option
 is not specified, it will be set to this.element
trigger {'self'|null|String|jQuery|DOM element}
Element(s) to use as the trigger to show the
  popup. uses the code 
    if (trigger == 'self') trigger = self.element; if (trigger) $(trigger).click(function(){self.show()})
class {String}
class to be added to the popup box

$.ui.textpopup.defaults.extend({
	show: $.fn.show,
	hide: $.fn.hide,
	speed: 'slow',
	hideOnOutsideClick: true,
	position: 'tl',
	trigger: 'self',
	'class': 'ui-textpopup-box'
});

Note that the event names prepend the actual name of the widget, so if you subclass textpopup, use the new name. Thus $.ui.textpopup.subclass('foo'); $(selector).foo().bind('fooshown', function(){});.

Examples of position:

<div id="example2">
<div><strong>tl</strong><input/></div>
<div><strong>lt</strong><input/></div>
<div><strong>br</strong><input/></div>
<div><strong>rb</strong><input/></div>
<div><strong>lb</strong><input/></div>
</div>

$('#example2 input').each(function(){
  $(this).css({height: '50px'}).helloWorld({position: $(this).prev().text()});
});

$('#example2 div, #example2 span').css({margin:'2px'});

<div id="example3">
<div><strong>Slide Right</strong><input/></div>
</div>

$('#example3 input').each(function(){
  $(this).css({height: '50px'}).helloWorld({
    speed: ['slide', {direction: 'right'}, 'slow'],
    position: {my: 'bottom', at: 'top'}
  });
});

$('#example3 div, #example3 span').css({margin:'2px'});

Callable functions include (obviously, use the name of the subclass you created):

$(...).textpopup('show') and $(...).helloWorld('hide')
show and hide the popup. These return the jQuery object.
$(...).textpopup('box')
returns the popup div as a single-element jQuery object
$(...).textpopup('position')
repositions the popup. Use this if the size of the popup changes. Returns the jQuery object.

Example of using callable functions and the trigger option:

<div id="example4">
	<label>Example 4 hidden:</label><br/><input id="input4">
</div>

$('<span> Hide </span>').css({outline: 'black dotted thin'}).insertAfter('#input4').click (function(){
  $('#input4').helloWorld('hide');
});
var triggerElement = $('<span> Show </span>').css({outline: 'black dotted thin'}).insertAfter('#example4 input');
$('#input4').helloWorld({
  hideOnOutsideClick: false,
  position: {my: 'right', at: 'left'},
  speed: ['fold', {}, 1000],
  trigger: triggerElement,
  shown: function() {$('#example4 label').text('Example 4 visible:')},
  hidden: function() {$('#example4 label').text('Example 4 hidden:')}
});
$('#input4').helloWorld('box').css('border', '2px outset #eee');

$.ui.hebrewKeyboard

The $.ui.hebrewKeyboard is just a subclass of $.ui.textpopup that uses AJAX to load a Hebrew keyboard into the popup div and $.fn.sendkeys to insert the Hebrew characters.

Inspired by Ilya Lebedev's VirtualKeyboard, the plugin also catches keystrokes to allow typing directly in Hebrew, using the CapsLock key as a toggle between English and Hebrew keyboards.

<div id="example5">
	Example 5 (Hebrew): <input id="input5">
</div>

$('#input5').hebrewKeyboard();

It works with contenteditable="true" elements as well:

<div id="example6" contenteditable="true" >
	Example 6 (Hebrew): Edit me!
</div>

$('#example6').hebrewKeyboard();

Download the html for the keyboard.

The keyboard uses CSS sprites and a single image:

to simulate the keypresses (hotlinking is OK for now). IE (of course) can't handle a:hover styling unless there's a real link, so each key has a pretend href="javascript:insertLetter", but really uses $('a').click(function(){sendkeys...return false;})