##// END OF EJS Templates
Don't enter edit mode when changing cell type and preserve renderd.
Brian E. Granger -
Show More
@@ -1,2284 +1,2286 b''
1 1 //----------------------------------------------------------------------------
2 2 // Copyright (C) 2011 The IPython Development Team
3 3 //
4 4 // Distributed under the terms of the BSD License. The full license is in
5 5 // the file COPYING, distributed as part of this software.
6 6 //----------------------------------------------------------------------------
7 7
8 8 //============================================================================
9 9 // Notebook
10 10 //============================================================================
11 11
12 12 var IPython = (function (IPython) {
13 13 "use strict";
14 14
15 15 var utils = IPython.utils;
16 16
17 17 /**
18 18 * A notebook contains and manages cells.
19 19 *
20 20 * @class Notebook
21 21 * @constructor
22 22 * @param {String} selector A jQuery selector for the notebook's DOM element
23 23 * @param {Object} [options] A config object
24 24 */
25 25 var Notebook = function (selector, options) {
26 26 var options = options || {};
27 27 this._baseProjectUrl = options.baseProjectUrl;
28 28 this.notebook_path = options.notebookPath;
29 29 this.notebook_name = options.notebookName;
30 30 this.element = $(selector);
31 31 this.element.scroll();
32 32 this.element.data("notebook", this);
33 33 this.next_prompt_number = 1;
34 34 this.session = null;
35 35 this.kernel = null;
36 36 this.clipboard = null;
37 37 this.undelete_backup = null;
38 38 this.undelete_index = null;
39 39 this.undelete_below = false;
40 40 this.paste_enabled = false;
41 41 // It is important to start out in command mode to match the intial mode
42 42 // of the KeyboardManager.
43 43 this.mode = 'command';
44 44 this.set_dirty(false);
45 45 this.metadata = {};
46 46 this._checkpoint_after_save = false;
47 47 this.last_checkpoint = null;
48 48 this.checkpoints = [];
49 49 this.autosave_interval = 0;
50 50 this.autosave_timer = null;
51 51 // autosave *at most* every two minutes
52 52 this.minimum_autosave_interval = 120000;
53 53 // single worksheet for now
54 54 this.worksheet_metadata = {};
55 55 this.notebook_name_blacklist_re = /[\/\\:]/;
56 56 this.nbformat = 3 // Increment this when changing the nbformat
57 57 this.nbformat_minor = 0 // Increment this when changing the nbformat
58 58 this.style();
59 59 this.create_elements();
60 60 this.bind_events();
61 61 };
62 62
63 63 /**
64 64 * Tweak the notebook's CSS style.
65 65 *
66 66 * @method style
67 67 */
68 68 Notebook.prototype.style = function () {
69 69 $('div#notebook').addClass('border-box-sizing');
70 70 };
71 71
72 72 /**
73 73 * Get the root URL of the notebook server.
74 74 *
75 75 * @method baseProjectUrl
76 76 * @return {String} The base project URL
77 77 */
78 78 Notebook.prototype.baseProjectUrl = function() {
79 79 return this._baseProjectUrl || $('body').data('baseProjectUrl');
80 80 };
81 81
82 82 Notebook.prototype.notebookName = function() {
83 83 return $('body').data('notebookName');
84 84 };
85 85
86 86 Notebook.prototype.notebookPath = function() {
87 87 return $('body').data('notebookPath');
88 88 };
89 89
90 90 /**
91 91 * Create an HTML and CSS representation of the notebook.
92 92 *
93 93 * @method create_elements
94 94 */
95 95 Notebook.prototype.create_elements = function () {
96 96 var that = this;
97 97 this.element.attr('tabindex','-1');
98 98 this.container = $("<div/>").addClass("container").attr("id", "notebook-container");
99 99 // We add this end_space div to the end of the notebook div to:
100 100 // i) provide a margin between the last cell and the end of the notebook
101 101 // ii) to prevent the div from scrolling up when the last cell is being
102 102 // edited, but is too low on the page, which browsers will do automatically.
103 103 var end_space = $('<div/>').addClass('end_space');
104 104 end_space.dblclick(function (e) {
105 105 var ncells = that.ncells();
106 106 that.insert_cell_below('code',ncells-1);
107 107 });
108 108 this.element.append(this.container);
109 109 this.container.append(end_space);
110 110 };
111 111
112 112 /**
113 113 * Bind JavaScript events: key presses and custom IPython events.
114 114 *
115 115 * @method bind_events
116 116 */
117 117 Notebook.prototype.bind_events = function () {
118 118 var that = this;
119 119
120 120 $([IPython.events]).on('set_next_input.Notebook', function (event, data) {
121 121 var index = that.find_cell_index(data.cell);
122 122 var new_cell = that.insert_cell_below('code',index);
123 123 new_cell.set_text(data.text);
124 124 that.dirty = true;
125 125 });
126 126
127 127 $([IPython.events]).on('set_dirty.Notebook', function (event, data) {
128 128 that.dirty = data.value;
129 129 });
130 130
131 131 $([IPython.events]).on('select.Cell', function (event, data) {
132 132 var index = that.find_cell_index(data.cell);
133 133 that.select(index);
134 134 });
135 135
136 136 $([IPython.events]).on('edit_mode.Cell', function (event, data) {
137 137 var index = that.find_cell_index(data.cell);
138 138 that.select(index);
139 139 that.edit_mode();
140 140 });
141 141
142 142 $([IPython.events]).on('command_mode.Cell', function (event, data) {
143 143 that.command_mode();
144 144 });
145 145
146 146 $([IPython.events]).on('status_autorestarting.Kernel', function () {
147 147 IPython.dialog.modal({
148 148 title: "Kernel Restarting",
149 149 body: "The kernel appears to have died. It will restart automatically.",
150 150 buttons: {
151 151 OK : {
152 152 class : "btn-primary"
153 153 }
154 154 }
155 155 });
156 156 });
157 157
158 158 var collapse_time = function (time) {
159 159 var app_height = $('#ipython-main-app').height(); // content height
160 160 var splitter_height = $('div#pager_splitter').outerHeight(true);
161 161 var new_height = app_height - splitter_height;
162 162 that.element.animate({height : new_height + 'px'}, time);
163 163 };
164 164
165 165 this.element.bind('collapse_pager', function (event, extrap) {
166 166 var time = (extrap != undefined) ? ((extrap.duration != undefined ) ? extrap.duration : 'fast') : 'fast';
167 167 collapse_time(time);
168 168 });
169 169
170 170 var expand_time = function (time) {
171 171 var app_height = $('#ipython-main-app').height(); // content height
172 172 var splitter_height = $('div#pager_splitter').outerHeight(true);
173 173 var pager_height = $('div#pager').outerHeight(true);
174 174 var new_height = app_height - pager_height - splitter_height;
175 175 that.element.animate({height : new_height + 'px'}, time);
176 176 };
177 177
178 178 this.element.bind('expand_pager', function (event, extrap) {
179 179 var time = (extrap != undefined) ? ((extrap.duration != undefined ) ? extrap.duration : 'fast') : 'fast';
180 180 expand_time(time);
181 181 });
182 182
183 183 // Firefox 22 broke $(window).on("beforeunload")
184 184 // I'm not sure why or how.
185 185 window.onbeforeunload = function (e) {
186 186 // TODO: Make killing the kernel configurable.
187 187 var kill_kernel = false;
188 188 if (kill_kernel) {
189 189 that.session.kill_kernel();
190 190 }
191 191 // if we are autosaving, trigger an autosave on nav-away.
192 192 // still warn, because if we don't the autosave may fail.
193 193 if (that.dirty) {
194 194 if ( that.autosave_interval ) {
195 195 // schedule autosave in a timeout
196 196 // this gives you a chance to forcefully discard changes
197 197 // by reloading the page if you *really* want to.
198 198 // the timer doesn't start until you *dismiss* the dialog.
199 199 setTimeout(function () {
200 200 if (that.dirty) {
201 201 that.save_notebook();
202 202 }
203 203 }, 1000);
204 204 return "Autosave in progress, latest changes may be lost.";
205 205 } else {
206 206 return "Unsaved changes will be lost.";
207 207 }
208 208 };
209 209 // Null is the *only* return value that will make the browser not
210 210 // pop up the "don't leave" dialog.
211 211 return null;
212 212 };
213 213 };
214 214
215 215 /**
216 216 * Set the dirty flag, and trigger the set_dirty.Notebook event
217 217 *
218 218 * @method set_dirty
219 219 */
220 220 Notebook.prototype.set_dirty = function (value) {
221 221 if (value === undefined) {
222 222 value = true;
223 223 }
224 224 if (this.dirty == value) {
225 225 return;
226 226 }
227 227 $([IPython.events]).trigger('set_dirty.Notebook', {value: value});
228 228 };
229 229
230 230 /**
231 231 * Scroll the top of the page to a given cell.
232 232 *
233 233 * @method scroll_to_cell
234 234 * @param {Number} cell_number An index of the cell to view
235 235 * @param {Number} time Animation time in milliseconds
236 236 * @return {Number} Pixel offset from the top of the container
237 237 */
238 238 Notebook.prototype.scroll_to_cell = function (cell_number, time) {
239 239 var cells = this.get_cells();
240 240 var time = time || 0;
241 241 cell_number = Math.min(cells.length-1,cell_number);
242 242 cell_number = Math.max(0 ,cell_number);
243 243 var scroll_value = cells[cell_number].element.position().top-cells[0].element.position().top ;
244 244 this.element.animate({scrollTop:scroll_value}, time);
245 245 return scroll_value;
246 246 };
247 247
248 248 /**
249 249 * Scroll to the bottom of the page.
250 250 *
251 251 * @method scroll_to_bottom
252 252 */
253 253 Notebook.prototype.scroll_to_bottom = function () {
254 254 this.element.animate({scrollTop:this.element.get(0).scrollHeight}, 0);
255 255 };
256 256
257 257 /**
258 258 * Scroll to the top of the page.
259 259 *
260 260 * @method scroll_to_top
261 261 */
262 262 Notebook.prototype.scroll_to_top = function () {
263 263 this.element.animate({scrollTop:0}, 0);
264 264 };
265 265
266 266 // Edit Notebook metadata
267 267
268 268 Notebook.prototype.edit_metadata = function () {
269 269 var that = this;
270 270 IPython.dialog.edit_metadata(this.metadata, function (md) {
271 271 that.metadata = md;
272 272 }, 'Notebook');
273 273 };
274 274
275 275 // Cell indexing, retrieval, etc.
276 276
277 277 /**
278 278 * Get all cell elements in the notebook.
279 279 *
280 280 * @method get_cell_elements
281 281 * @return {jQuery} A selector of all cell elements
282 282 */
283 283 Notebook.prototype.get_cell_elements = function () {
284 284 return this.container.children("div.cell");
285 285 };
286 286
287 287 /**
288 288 * Get a particular cell element.
289 289 *
290 290 * @method get_cell_element
291 291 * @param {Number} index An index of a cell to select
292 292 * @return {jQuery} A selector of the given cell.
293 293 */
294 294 Notebook.prototype.get_cell_element = function (index) {
295 295 var result = null;
296 296 var e = this.get_cell_elements().eq(index);
297 297 if (e.length !== 0) {
298 298 result = e;
299 299 }
300 300 return result;
301 301 };
302 302
303 303 /**
304 304 * Try to get a particular cell by msg_id.
305 305 *
306 306 * @method get_msg_cell
307 307 * @param {String} msg_id A message UUID
308 308 * @return {Cell} Cell or null if no cell was found.
309 309 */
310 310 Notebook.prototype.get_msg_cell = function (msg_id) {
311 311 return IPython.CodeCell.msg_cells[msg_id] || null;
312 312 };
313 313
314 314 /**
315 315 * Count the cells in this notebook.
316 316 *
317 317 * @method ncells
318 318 * @return {Number} The number of cells in this notebook
319 319 */
320 320 Notebook.prototype.ncells = function () {
321 321 return this.get_cell_elements().length;
322 322 };
323 323
324 324 /**
325 325 * Get all Cell objects in this notebook.
326 326 *
327 327 * @method get_cells
328 328 * @return {Array} This notebook's Cell objects
329 329 */
330 330 // TODO: we are often calling cells as cells()[i], which we should optimize
331 331 // to cells(i) or a new method.
332 332 Notebook.prototype.get_cells = function () {
333 333 return this.get_cell_elements().toArray().map(function (e) {
334 334 return $(e).data("cell");
335 335 });
336 336 };
337 337
338 338 /**
339 339 * Get a Cell object from this notebook.
340 340 *
341 341 * @method get_cell
342 342 * @param {Number} index An index of a cell to retrieve
343 343 * @return {Cell} A particular cell
344 344 */
345 345 Notebook.prototype.get_cell = function (index) {
346 346 var result = null;
347 347 var ce = this.get_cell_element(index);
348 348 if (ce !== null) {
349 349 result = ce.data('cell');
350 350 }
351 351 return result;
352 352 }
353 353
354 354 /**
355 355 * Get the cell below a given cell.
356 356 *
357 357 * @method get_next_cell
358 358 * @param {Cell} cell The provided cell
359 359 * @return {Cell} The next cell
360 360 */
361 361 Notebook.prototype.get_next_cell = function (cell) {
362 362 var result = null;
363 363 var index = this.find_cell_index(cell);
364 364 if (this.is_valid_cell_index(index+1)) {
365 365 result = this.get_cell(index+1);
366 366 }
367 367 return result;
368 368 }
369 369
370 370 /**
371 371 * Get the cell above a given cell.
372 372 *
373 373 * @method get_prev_cell
374 374 * @param {Cell} cell The provided cell
375 375 * @return {Cell} The previous cell
376 376 */
377 377 Notebook.prototype.get_prev_cell = function (cell) {
378 378 // TODO: off-by-one
379 379 // nb.get_prev_cell(nb.get_cell(1)) is null
380 380 var result = null;
381 381 var index = this.find_cell_index(cell);
382 382 if (index !== null && index > 1) {
383 383 result = this.get_cell(index-1);
384 384 }
385 385 return result;
386 386 }
387 387
388 388 /**
389 389 * Get the numeric index of a given cell.
390 390 *
391 391 * @method find_cell_index
392 392 * @param {Cell} cell The provided cell
393 393 * @return {Number} The cell's numeric index
394 394 */
395 395 Notebook.prototype.find_cell_index = function (cell) {
396 396 var result = null;
397 397 this.get_cell_elements().filter(function (index) {
398 398 if ($(this).data("cell") === cell) {
399 399 result = index;
400 400 };
401 401 });
402 402 return result;
403 403 };
404 404
405 405 /**
406 406 * Get a given index , or the selected index if none is provided.
407 407 *
408 408 * @method index_or_selected
409 409 * @param {Number} index A cell's index
410 410 * @return {Number} The given index, or selected index if none is provided.
411 411 */
412 412 Notebook.prototype.index_or_selected = function (index) {
413 413 var i;
414 414 if (index === undefined || index === null) {
415 415 i = this.get_selected_index();
416 416 if (i === null) {
417 417 i = 0;
418 418 }
419 419 } else {
420 420 i = index;
421 421 }
422 422 return i;
423 423 };
424 424
425 425 /**
426 426 * Get the currently selected cell.
427 427 * @method get_selected_cell
428 428 * @return {Cell} The selected cell
429 429 */
430 430 Notebook.prototype.get_selected_cell = function () {
431 431 var index = this.get_selected_index();
432 432 return this.get_cell(index);
433 433 };
434 434
435 435 /**
436 436 * Check whether a cell index is valid.
437 437 *
438 438 * @method is_valid_cell_index
439 439 * @param {Number} index A cell index
440 440 * @return True if the index is valid, false otherwise
441 441 */
442 442 Notebook.prototype.is_valid_cell_index = function (index) {
443 443 if (index !== null && index >= 0 && index < this.ncells()) {
444 444 return true;
445 445 } else {
446 446 return false;
447 447 };
448 448 }
449 449
450 450 /**
451 451 * Get the index of the currently selected cell.
452 452
453 453 * @method get_selected_index
454 454 * @return {Number} The selected cell's numeric index
455 455 */
456 456 Notebook.prototype.get_selected_index = function () {
457 457 var result = null;
458 458 this.get_cell_elements().filter(function (index) {
459 459 if ($(this).data("cell").selected === true) {
460 460 result = index;
461 461 };
462 462 });
463 463 return result;
464 464 };
465 465
466 466
467 467 // Cell selection.
468 468
469 469 /**
470 470 * Programmatically select a cell.
471 471 *
472 472 * @method select
473 473 * @param {Number} index A cell's index
474 474 * @return {Notebook} This notebook
475 475 */
476 476 Notebook.prototype.select = function (index) {
477 477 if (this.is_valid_cell_index(index)) {
478 478 var sindex = this.get_selected_index()
479 479 if (sindex !== null && index !== sindex) {
480 480 this.command_mode();
481 481 this.get_cell(sindex).unselect();
482 482 };
483 483 var cell = this.get_cell(index);
484 484 cell.select();
485 485 if (cell.cell_type === 'heading') {
486 486 $([IPython.events]).trigger('selected_cell_type_changed.Notebook',
487 487 {'cell_type':cell.cell_type,level:cell.level}
488 488 );
489 489 } else {
490 490 $([IPython.events]).trigger('selected_cell_type_changed.Notebook',
491 491 {'cell_type':cell.cell_type}
492 492 );
493 493 };
494 494 };
495 495 return this;
496 496 };
497 497
498 498 /**
499 499 * Programmatically select the next cell.
500 500 *
501 501 * @method select_next
502 502 * @return {Notebook} This notebook
503 503 */
504 504 Notebook.prototype.select_next = function () {
505 505 var index = this.get_selected_index();
506 506 this.select(index+1);
507 507 return this;
508 508 };
509 509
510 510 /**
511 511 * Programmatically select the previous cell.
512 512 *
513 513 * @method select_prev
514 514 * @return {Notebook} This notebook
515 515 */
516 516 Notebook.prototype.select_prev = function () {
517 517 var index = this.get_selected_index();
518 518 this.select(index-1);
519 519 return this;
520 520 };
521 521
522 522
523 523 // Edit/Command mode
524 524
525 525 Notebook.prototype.get_edit_index = function () {
526 526 var result = null;
527 527 this.get_cell_elements().filter(function (index) {
528 528 if ($(this).data("cell").mode === 'edit') {
529 529 result = index;
530 530 };
531 531 });
532 532 return result;
533 533 };
534 534
535 535 Notebook.prototype.command_mode = function () {
536 536 if (this.mode !== 'command') {
537 537 var index = this.get_edit_index();
538 538 var cell = this.get_cell(index);
539 539 if (cell) {
540 540 cell.command_mode();
541 541 };
542 542 this.mode = 'command';
543 543 IPython.keyboard_manager.command_mode();
544 544 };
545 545 };
546 546
547 547 Notebook.prototype.edit_mode = function () {
548 548 if (this.mode !== 'edit') {
549 549 var cell = this.get_selected_cell();
550 550 if (cell === null) {return;} // No cell is selected
551 551 // We need to set the mode to edit to prevent reentering this method
552 552 // when cell.edit_mode() is called below.
553 553 this.mode = 'edit';
554 554 IPython.keyboard_manager.edit_mode();
555 555 cell.edit_mode();
556 556 };
557 557 };
558 558
559 559 Notebook.prototype.focus_cell = function () {
560 560 var cell = this.get_selected_cell();
561 561 if (cell === null) {return;} // No cell is selected
562 562 cell.focus_cell();
563 563 };
564 564
565 565 // Cell movement
566 566
567 567 /**
568 568 * Move given (or selected) cell up and select it.
569 569 *
570 570 * @method move_cell_up
571 571 * @param [index] {integer} cell index
572 572 * @return {Notebook} This notebook
573 573 **/
574 574 Notebook.prototype.move_cell_up = function (index) {
575 575 var i = this.index_or_selected(index);
576 576 if (this.is_valid_cell_index(i) && i > 0) {
577 577 var pivot = this.get_cell_element(i-1);
578 578 var tomove = this.get_cell_element(i);
579 579 if (pivot !== null && tomove !== null) {
580 580 tomove.detach();
581 581 pivot.before(tomove);
582 582 this.select(i-1);
583 583 var cell = this.get_selected_cell();
584 584 cell.focus_cell();
585 585 };
586 586 this.set_dirty(true);
587 587 };
588 588 return this;
589 589 };
590 590
591 591
592 592 /**
593 593 * Move given (or selected) cell down and select it
594 594 *
595 595 * @method move_cell_down
596 596 * @param [index] {integer} cell index
597 597 * @return {Notebook} This notebook
598 598 **/
599 599 Notebook.prototype.move_cell_down = function (index) {
600 600 var i = this.index_or_selected(index);
601 601 if (this.is_valid_cell_index(i) && this.is_valid_cell_index(i+1)) {
602 602 var pivot = this.get_cell_element(i+1);
603 603 var tomove = this.get_cell_element(i);
604 604 if (pivot !== null && tomove !== null) {
605 605 tomove.detach();
606 606 pivot.after(tomove);
607 607 this.select(i+1);
608 608 var cell = this.get_selected_cell();
609 609 cell.focus_cell();
610 610 };
611 611 };
612 612 this.set_dirty();
613 613 return this;
614 614 };
615 615
616 616
617 617 // Insertion, deletion.
618 618
619 619 /**
620 620 * Delete a cell from the notebook.
621 621 *
622 622 * @method delete_cell
623 623 * @param [index] A cell's numeric index
624 624 * @return {Notebook} This notebook
625 625 */
626 626 Notebook.prototype.delete_cell = function (index) {
627 627 var i = this.index_or_selected(index);
628 628 var cell = this.get_selected_cell();
629 629 this.undelete_backup = cell.toJSON();
630 630 $('#undelete_cell').removeClass('disabled');
631 631 if (this.is_valid_cell_index(i)) {
632 632 var old_ncells = this.ncells();
633 633 var ce = this.get_cell_element(i);
634 634 ce.remove();
635 635 if (i === 0) {
636 636 // Always make sure we have at least one cell.
637 637 if (old_ncells === 1) {
638 638 this.insert_cell_below('code');
639 639 }
640 640 this.select(0);
641 641 this.undelete_index = 0;
642 642 this.undelete_below = false;
643 643 } else if (i === old_ncells-1 && i !== 0) {
644 644 this.select(i-1);
645 645 this.undelete_index = i - 1;
646 646 this.undelete_below = true;
647 647 } else {
648 648 this.select(i);
649 649 this.undelete_index = i;
650 650 this.undelete_below = false;
651 651 };
652 652 $([IPython.events]).trigger('delete.Cell', {'cell': cell, 'index': i});
653 653 this.set_dirty(true);
654 654 };
655 655 return this;
656 656 };
657 657
658 658 /**
659 659 * Restore the most recently deleted cell.
660 660 *
661 661 * @method undelete
662 662 */
663 663 Notebook.prototype.undelete_cell = function() {
664 664 if (this.undelete_backup !== null && this.undelete_index !== null) {
665 665 var current_index = this.get_selected_index();
666 666 if (this.undelete_index < current_index) {
667 667 current_index = current_index + 1;
668 668 }
669 669 if (this.undelete_index >= this.ncells()) {
670 670 this.select(this.ncells() - 1);
671 671 }
672 672 else {
673 673 this.select(this.undelete_index);
674 674 }
675 675 var cell_data = this.undelete_backup;
676 676 var new_cell = null;
677 677 if (this.undelete_below) {
678 678 new_cell = this.insert_cell_below(cell_data.cell_type);
679 679 } else {
680 680 new_cell = this.insert_cell_above(cell_data.cell_type);
681 681 }
682 682 new_cell.fromJSON(cell_data);
683 683 if (this.undelete_below) {
684 684 this.select(current_index+1);
685 685 } else {
686 686 this.select(current_index);
687 687 }
688 688 this.undelete_backup = null;
689 689 this.undelete_index = null;
690 690 }
691 691 $('#undelete_cell').addClass('disabled');
692 692 }
693 693
694 694 /**
695 695 * Insert a cell so that after insertion the cell is at given index.
696 696 *
697 697 * Similar to insert_above, but index parameter is mandatory
698 698 *
699 699 * Index will be brought back into the accissible range [0,n]
700 700 *
701 701 * @method insert_cell_at_index
702 702 * @param type {string} in ['code','markdown','heading']
703 703 * @param [index] {int} a valid index where to inser cell
704 704 *
705 705 * @return cell {cell|null} created cell or null
706 706 **/
707 707 Notebook.prototype.insert_cell_at_index = function(type, index){
708 708
709 709 var ncells = this.ncells();
710 710 var index = Math.min(index,ncells);
711 711 index = Math.max(index,0);
712 712 var cell = null;
713 713
714 714 if (ncells === 0 || this.is_valid_cell_index(index) || index === ncells) {
715 715 if (type === 'code') {
716 716 cell = new IPython.CodeCell(this.kernel);
717 717 cell.set_input_prompt();
718 718 } else if (type === 'markdown') {
719 719 cell = new IPython.MarkdownCell();
720 720 } else if (type === 'raw') {
721 721 cell = new IPython.RawCell();
722 722 } else if (type === 'heading') {
723 723 cell = new IPython.HeadingCell();
724 724 }
725 725
726 726 if(this._insert_element_at_index(cell.element,index)) {
727 727 cell.render();
728 728 $([IPython.events]).trigger('create.Cell', {'cell': cell, 'index': index});
729 729 cell.refresh();
730 730 // We used to select the cell after we refresh it, but there
731 731 // are now cases were this method is called where select is
732 732 // not appropriate. The selection logic should be handled by the
733 733 // caller of the the top level insert_cell methods.
734 734 this.set_dirty(true);
735 735 }
736 736 }
737 737 return cell;
738 738
739 739 };
740 740
741 741 /**
742 742 * Insert an element at given cell index.
743 743 *
744 744 * @method _insert_element_at_index
745 745 * @param element {dom element} a cell element
746 746 * @param [index] {int} a valid index where to inser cell
747 747 * @private
748 748 *
749 749 * return true if everything whent fine.
750 750 **/
751 751 Notebook.prototype._insert_element_at_index = function(element, index){
752 752 if (element === undefined){
753 753 return false;
754 754 }
755 755
756 756 var ncells = this.ncells();
757 757
758 758 if (ncells === 0) {
759 759 // special case append if empty
760 760 this.element.find('div.end_space').before(element);
761 761 } else if ( ncells === index ) {
762 762 // special case append it the end, but not empty
763 763 this.get_cell_element(index-1).after(element);
764 764 } else if (this.is_valid_cell_index(index)) {
765 765 // otherwise always somewhere to append to
766 766 this.get_cell_element(index).before(element);
767 767 } else {
768 768 return false;
769 769 }
770 770
771 771 if (this.undelete_index !== null && index <= this.undelete_index) {
772 772 this.undelete_index = this.undelete_index + 1;
773 773 this.set_dirty(true);
774 774 }
775 775 return true;
776 776 };
777 777
778 778 /**
779 779 * Insert a cell of given type above given index, or at top
780 780 * of notebook if index smaller than 0.
781 781 *
782 782 * default index value is the one of currently selected cell
783 783 *
784 784 * @method insert_cell_above
785 785 * @param type {string} cell type
786 786 * @param [index] {integer}
787 787 *
788 788 * @return handle to created cell or null
789 789 **/
790 790 Notebook.prototype.insert_cell_above = function (type, index) {
791 791 index = this.index_or_selected(index);
792 792 return this.insert_cell_at_index(type, index);
793 793 };
794 794
795 795 /**
796 796 * Insert a cell of given type below given index, or at bottom
797 797 * of notebook if index greater thatn number of cell
798 798 *
799 799 * default index value is the one of currently selected cell
800 800 *
801 801 * @method insert_cell_below
802 802 * @param type {string} cell type
803 803 * @param [index] {integer}
804 804 *
805 805 * @return handle to created cell or null
806 806 *
807 807 **/
808 808 Notebook.prototype.insert_cell_below = function (type, index) {
809 809 index = this.index_or_selected(index);
810 810 return this.insert_cell_at_index(type, index+1);
811 811 };
812 812
813 813
814 814 /**
815 815 * Insert cell at end of notebook
816 816 *
817 817 * @method insert_cell_at_bottom
818 818 * @param {String} type cell type
819 819 *
820 820 * @return the added cell; or null
821 821 **/
822 822 Notebook.prototype.insert_cell_at_bottom = function (type){
823 823 var len = this.ncells();
824 824 return this.insert_cell_below(type,len-1);
825 825 };
826 826
827 827 /**
828 828 * Turn a cell into a code cell.
829 829 *
830 830 * @method to_code
831 831 * @param {Number} [index] A cell's index
832 832 */
833 833 Notebook.prototype.to_code = function (index) {
834 834 var i = this.index_or_selected(index);
835 835 if (this.is_valid_cell_index(i)) {
836 836 var source_element = this.get_cell_element(i);
837 837 var source_cell = source_element.data("cell");
838 838 if (!(source_cell instanceof IPython.CodeCell)) {
839 839 var target_cell = this.insert_cell_below('code',i);
840 840 var text = source_cell.get_text();
841 841 if (text === source_cell.placeholder) {
842 842 text = '';
843 843 }
844 844 target_cell.set_text(text);
845 845 // make this value the starting point, so that we can only undo
846 846 // to this state, instead of a blank cell
847 847 target_cell.code_mirror.clearHistory();
848 848 source_element.remove();
849 849 this.select(i);
850 this.edit_mode();
851 850 this.set_dirty(true);
852 851 };
853 852 };
854 853 };
855 854
856 855 /**
857 856 * Turn a cell into a Markdown cell.
858 857 *
859 858 * @method to_markdown
860 859 * @param {Number} [index] A cell's index
861 860 */
862 861 Notebook.prototype.to_markdown = function (index) {
863 862 var i = this.index_or_selected(index);
864 863 if (this.is_valid_cell_index(i)) {
865 864 var source_element = this.get_cell_element(i);
866 865 var source_cell = source_element.data("cell");
867 866 if (!(source_cell instanceof IPython.MarkdownCell)) {
868 867 var target_cell = this.insert_cell_below('markdown',i);
869 868 var text = source_cell.get_text();
870 869 if (text === source_cell.placeholder) {
871 870 text = '';
872 871 };
873 872 // We must show the editor before setting its contents
874 873 target_cell.unrender();
875 874 target_cell.set_text(text);
876 875 // make this value the starting point, so that we can only undo
877 876 // to this state, instead of a blank cell
878 877 target_cell.code_mirror.clearHistory();
879 878 source_element.remove();
880 879 this.select(i);
881 this.edit_mode();
880 if ((source_cell instanceof IPython.TextCell) && source_cell.rendered) {
881 target_cell.render();
882 }
882 883 this.set_dirty(true);
883 884 };
884 885 };
885 886 };
886 887
887 888 /**
888 889 * Turn a cell into a raw text cell.
889 890 *
890 891 * @method to_raw
891 892 * @param {Number} [index] A cell's index
892 893 */
893 894 Notebook.prototype.to_raw = function (index) {
894 895 var i = this.index_or_selected(index);
895 896 if (this.is_valid_cell_index(i)) {
896 897 var source_element = this.get_cell_element(i);
897 898 var source_cell = source_element.data("cell");
898 899 var target_cell = null;
899 900 if (!(source_cell instanceof IPython.RawCell)) {
900 901 target_cell = this.insert_cell_below('raw',i);
901 902 var text = source_cell.get_text();
902 903 if (text === source_cell.placeholder) {
903 904 text = '';
904 905 };
905 906 // We must show the editor before setting its contents
906 907 target_cell.unrender();
907 908 target_cell.set_text(text);
908 909 // make this value the starting point, so that we can only undo
909 910 // to this state, instead of a blank cell
910 911 target_cell.code_mirror.clearHistory();
911 912 source_element.remove();
912 913 this.select(i);
913 this.edit_mode();
914 914 this.set_dirty(true);
915 915 };
916 916 };
917 917 };
918 918
919 919 /**
920 920 * Turn a cell into a heading cell.
921 921 *
922 922 * @method to_heading
923 923 * @param {Number} [index] A cell's index
924 924 * @param {Number} [level] A heading level (e.g., 1 becomes &lt;h1&gt;)
925 925 */
926 926 Notebook.prototype.to_heading = function (index, level) {
927 927 level = level || 1;
928 928 var i = this.index_or_selected(index);
929 929 if (this.is_valid_cell_index(i)) {
930 930 var source_element = this.get_cell_element(i);
931 931 var source_cell = source_element.data("cell");
932 932 var target_cell = null;
933 933 if (source_cell instanceof IPython.HeadingCell) {
934 934 source_cell.set_level(level);
935 935 } else {
936 936 target_cell = this.insert_cell_below('heading',i);
937 937 var text = source_cell.get_text();
938 938 if (text === source_cell.placeholder) {
939 939 text = '';
940 940 };
941 941 // We must show the editor before setting its contents
942 942 target_cell.set_level(level);
943 943 target_cell.unrender();
944 944 target_cell.set_text(text);
945 945 // make this value the starting point, so that we can only undo
946 946 // to this state, instead of a blank cell
947 947 target_cell.code_mirror.clearHistory();
948 948 source_element.remove();
949 949 this.select(i);
950 if ((source_cell instanceof IPython.TextCell) && source_cell.rendered) {
951 target_cell.render();
952 }
950 953 };
951 this.edit_mode();
952 954 this.set_dirty(true);
953 955 $([IPython.events]).trigger('selected_cell_type_changed.Notebook',
954 956 {'cell_type':'heading',level:level}
955 957 );
956 958 };
957 959 };
958 960
959 961
960 962 // Cut/Copy/Paste
961 963
962 964 /**
963 965 * Enable UI elements for pasting cells.
964 966 *
965 967 * @method enable_paste
966 968 */
967 969 Notebook.prototype.enable_paste = function () {
968 970 var that = this;
969 971 if (!this.paste_enabled) {
970 972 $('#paste_cell_replace').removeClass('disabled')
971 973 .on('click', function () {that.paste_cell_replace();});
972 974 $('#paste_cell_above').removeClass('disabled')
973 975 .on('click', function () {that.paste_cell_above();});
974 976 $('#paste_cell_below').removeClass('disabled')
975 977 .on('click', function () {that.paste_cell_below();});
976 978 this.paste_enabled = true;
977 979 };
978 980 };
979 981
980 982 /**
981 983 * Disable UI elements for pasting cells.
982 984 *
983 985 * @method disable_paste
984 986 */
985 987 Notebook.prototype.disable_paste = function () {
986 988 if (this.paste_enabled) {
987 989 $('#paste_cell_replace').addClass('disabled').off('click');
988 990 $('#paste_cell_above').addClass('disabled').off('click');
989 991 $('#paste_cell_below').addClass('disabled').off('click');
990 992 this.paste_enabled = false;
991 993 };
992 994 };
993 995
994 996 /**
995 997 * Cut a cell.
996 998 *
997 999 * @method cut_cell
998 1000 */
999 1001 Notebook.prototype.cut_cell = function () {
1000 1002 this.copy_cell();
1001 1003 this.delete_cell();
1002 1004 }
1003 1005
1004 1006 /**
1005 1007 * Copy a cell.
1006 1008 *
1007 1009 * @method copy_cell
1008 1010 */
1009 1011 Notebook.prototype.copy_cell = function () {
1010 1012 var cell = this.get_selected_cell();
1011 1013 this.clipboard = cell.toJSON();
1012 1014 this.enable_paste();
1013 1015 };
1014 1016
1015 1017 /**
1016 1018 * Replace the selected cell with a cell in the clipboard.
1017 1019 *
1018 1020 * @method paste_cell_replace
1019 1021 */
1020 1022 Notebook.prototype.paste_cell_replace = function () {
1021 1023 if (this.clipboard !== null && this.paste_enabled) {
1022 1024 var cell_data = this.clipboard;
1023 1025 var new_cell = this.insert_cell_above(cell_data.cell_type);
1024 1026 new_cell.fromJSON(cell_data);
1025 1027 var old_cell = this.get_next_cell(new_cell);
1026 1028 this.delete_cell(this.find_cell_index(old_cell));
1027 1029 this.select(this.find_cell_index(new_cell));
1028 1030 };
1029 1031 };
1030 1032
1031 1033 /**
1032 1034 * Paste a cell from the clipboard above the selected cell.
1033 1035 *
1034 1036 * @method paste_cell_above
1035 1037 */
1036 1038 Notebook.prototype.paste_cell_above = function () {
1037 1039 if (this.clipboard !== null && this.paste_enabled) {
1038 1040 var cell_data = this.clipboard;
1039 1041 var new_cell = this.insert_cell_above(cell_data.cell_type);
1040 1042 new_cell.fromJSON(cell_data);
1041 1043 };
1042 1044 };
1043 1045
1044 1046 /**
1045 1047 * Paste a cell from the clipboard below the selected cell.
1046 1048 *
1047 1049 * @method paste_cell_below
1048 1050 */
1049 1051 Notebook.prototype.paste_cell_below = function () {
1050 1052 if (this.clipboard !== null && this.paste_enabled) {
1051 1053 var cell_data = this.clipboard;
1052 1054 var new_cell = this.insert_cell_below(cell_data.cell_type);
1053 1055 new_cell.fromJSON(cell_data);
1054 1056 };
1055 1057 };
1056 1058
1057 1059 // Split/merge
1058 1060
1059 1061 /**
1060 1062 * Split the selected cell into two, at the cursor.
1061 1063 *
1062 1064 * @method split_cell
1063 1065 */
1064 1066 Notebook.prototype.split_cell = function () {
1065 1067 var mdc = IPython.MarkdownCell;
1066 1068 var rc = IPython.RawCell;
1067 1069 var cell = this.get_selected_cell();
1068 1070 if (cell.is_splittable()) {
1069 1071 var texta = cell.get_pre_cursor();
1070 1072 var textb = cell.get_post_cursor();
1071 1073 if (cell instanceof IPython.CodeCell) {
1072 1074 // In this case the operations keep the notebook in its existing mode
1073 1075 // so we don't need to do any post-op mode changes.
1074 1076 cell.set_text(textb);
1075 1077 var new_cell = this.insert_cell_above('code');
1076 1078 new_cell.set_text(texta);
1077 1079 } else if ((cell instanceof mdc && !cell.rendered) || (cell instanceof rc)) {
1078 1080 // We know cell is !rendered so we can use set_text.
1079 1081 cell.set_text(textb);
1080 1082 var new_cell = this.insert_cell_above(cell.cell_type);
1081 1083 // Unrender the new cell so we can call set_text.
1082 1084 new_cell.unrender();
1083 1085 new_cell.set_text(texta);
1084 1086 }
1085 1087 };
1086 1088 };
1087 1089
1088 1090 /**
1089 1091 * Combine the selected cell into the cell above it.
1090 1092 *
1091 1093 * @method merge_cell_above
1092 1094 */
1093 1095 Notebook.prototype.merge_cell_above = function () {
1094 1096 var mdc = IPython.MarkdownCell;
1095 1097 var rc = IPython.RawCell;
1096 1098 var index = this.get_selected_index();
1097 1099 var cell = this.get_cell(index);
1098 1100 var render = cell.rendered;
1099 1101 if (!cell.is_mergeable()) {
1100 1102 return;
1101 1103 }
1102 1104 if (index > 0) {
1103 1105 var upper_cell = this.get_cell(index-1);
1104 1106 if (!upper_cell.is_mergeable()) {
1105 1107 return;
1106 1108 }
1107 1109 var upper_text = upper_cell.get_text();
1108 1110 var text = cell.get_text();
1109 1111 if (cell instanceof IPython.CodeCell) {
1110 1112 cell.set_text(upper_text+'\n'+text);
1111 1113 } else if ((cell instanceof mdc) || (cell instanceof rc)) {
1112 1114 cell.unrender(); // Must unrender before we set_text.
1113 1115 cell.set_text(upper_text+'\n\n'+text);
1114 1116 if (render) {
1115 1117 // The rendered state of the final cell should match
1116 1118 // that of the original selected cell;
1117 1119 cell.render();
1118 1120 }
1119 1121 };
1120 1122 this.delete_cell(index-1);
1121 1123 this.select(this.find_cell_index(cell));
1122 1124 };
1123 1125 };
1124 1126
1125 1127 /**
1126 1128 * Combine the selected cell into the cell below it.
1127 1129 *
1128 1130 * @method merge_cell_below
1129 1131 */
1130 1132 Notebook.prototype.merge_cell_below = function () {
1131 1133 var mdc = IPython.MarkdownCell;
1132 1134 var rc = IPython.RawCell;
1133 1135 var index = this.get_selected_index();
1134 1136 var cell = this.get_cell(index);
1135 1137 var render = cell.rendered;
1136 1138 if (!cell.is_mergeable()) {
1137 1139 return;
1138 1140 }
1139 1141 if (index < this.ncells()-1) {
1140 1142 var lower_cell = this.get_cell(index+1);
1141 1143 if (!lower_cell.is_mergeable()) {
1142 1144 return;
1143 1145 }
1144 1146 var lower_text = lower_cell.get_text();
1145 1147 var text = cell.get_text();
1146 1148 if (cell instanceof IPython.CodeCell) {
1147 1149 cell.set_text(text+'\n'+lower_text);
1148 1150 } else if ((cell instanceof mdc) || (cell instanceof rc)) {
1149 1151 cell.unrender(); // Must unrender before we set_text.
1150 1152 cell.set_text(text+'\n\n'+lower_text);
1151 1153 if (render) {
1152 1154 // The rendered state of the final cell should match
1153 1155 // that of the original selected cell;
1154 1156 cell.render();
1155 1157 }
1156 1158 };
1157 1159 this.delete_cell(index+1);
1158 1160 this.select(this.find_cell_index(cell));
1159 1161 };
1160 1162 };
1161 1163
1162 1164
1163 1165 // Cell collapsing and output clearing
1164 1166
1165 1167 /**
1166 1168 * Hide a cell's output.
1167 1169 *
1168 1170 * @method collapse_output
1169 1171 * @param {Number} index A cell's numeric index
1170 1172 */
1171 1173 Notebook.prototype.collapse_output = function (index) {
1172 1174 var i = this.index_or_selected(index);
1173 1175 var cell = this.get_cell(i);
1174 1176 if (cell !== null && (cell instanceof IPython.CodeCell)) {
1175 1177 cell.collapse_output();
1176 1178 this.set_dirty(true);
1177 1179 }
1178 1180 };
1179 1181
1180 1182 /**
1181 1183 * Hide each code cell's output area.
1182 1184 *
1183 1185 * @method collapse_all_output
1184 1186 */
1185 1187 Notebook.prototype.collapse_all_output = function () {
1186 1188 $.map(this.get_cells(), function (cell, i) {
1187 1189 if (cell instanceof IPython.CodeCell) {
1188 1190 cell.collapse_output();
1189 1191 }
1190 1192 });
1191 1193 // this should not be set if the `collapse` key is removed from nbformat
1192 1194 this.set_dirty(true);
1193 1195 };
1194 1196
1195 1197 /**
1196 1198 * Show a cell's output.
1197 1199 *
1198 1200 * @method expand_output
1199 1201 * @param {Number} index A cell's numeric index
1200 1202 */
1201 1203 Notebook.prototype.expand_output = function (index) {
1202 1204 var i = this.index_or_selected(index);
1203 1205 var cell = this.get_cell(i);
1204 1206 if (cell !== null && (cell instanceof IPython.CodeCell)) {
1205 1207 cell.expand_output();
1206 1208 this.set_dirty(true);
1207 1209 }
1208 1210 };
1209 1211
1210 1212 /**
1211 1213 * Expand each code cell's output area, and remove scrollbars.
1212 1214 *
1213 1215 * @method expand_all_output
1214 1216 */
1215 1217 Notebook.prototype.expand_all_output = function () {
1216 1218 $.map(this.get_cells(), function (cell, i) {
1217 1219 if (cell instanceof IPython.CodeCell) {
1218 1220 cell.expand_output();
1219 1221 }
1220 1222 });
1221 1223 // this should not be set if the `collapse` key is removed from nbformat
1222 1224 this.set_dirty(true);
1223 1225 };
1224 1226
1225 1227 /**
1226 1228 * Clear the selected CodeCell's output area.
1227 1229 *
1228 1230 * @method clear_output
1229 1231 * @param {Number} index A cell's numeric index
1230 1232 */
1231 1233 Notebook.prototype.clear_output = function (index) {
1232 1234 var i = this.index_or_selected(index);
1233 1235 var cell = this.get_cell(i);
1234 1236 if (cell !== null && (cell instanceof IPython.CodeCell)) {
1235 1237 cell.clear_output();
1236 1238 this.set_dirty(true);
1237 1239 }
1238 1240 };
1239 1241
1240 1242 /**
1241 1243 * Clear each code cell's output area.
1242 1244 *
1243 1245 * @method clear_all_output
1244 1246 */
1245 1247 Notebook.prototype.clear_all_output = function () {
1246 1248 $.map(this.get_cells(), function (cell, i) {
1247 1249 if (cell instanceof IPython.CodeCell) {
1248 1250 cell.clear_output();
1249 1251 }
1250 1252 });
1251 1253 this.set_dirty(true);
1252 1254 };
1253 1255
1254 1256 /**
1255 1257 * Scroll the selected CodeCell's output area.
1256 1258 *
1257 1259 * @method scroll_output
1258 1260 * @param {Number} index A cell's numeric index
1259 1261 */
1260 1262 Notebook.prototype.scroll_output = function (index) {
1261 1263 var i = this.index_or_selected(index);
1262 1264 var cell = this.get_cell(i);
1263 1265 if (cell !== null && (cell instanceof IPython.CodeCell)) {
1264 1266 cell.scroll_output();
1265 1267 this.set_dirty(true);
1266 1268 }
1267 1269 };
1268 1270
1269 1271 /**
1270 1272 * Expand each code cell's output area, and add a scrollbar for long output.
1271 1273 *
1272 1274 * @method scroll_all_output
1273 1275 */
1274 1276 Notebook.prototype.scroll_all_output = function () {
1275 1277 $.map(this.get_cells(), function (cell, i) {
1276 1278 if (cell instanceof IPython.CodeCell) {
1277 1279 cell.scroll_output();
1278 1280 }
1279 1281 });
1280 1282 // this should not be set if the `collapse` key is removed from nbformat
1281 1283 this.set_dirty(true);
1282 1284 };
1283 1285
1284 1286 /** Toggle whether a cell's output is collapsed or expanded.
1285 1287 *
1286 1288 * @method toggle_output
1287 1289 * @param {Number} index A cell's numeric index
1288 1290 */
1289 1291 Notebook.prototype.toggle_output = function (index) {
1290 1292 var i = this.index_or_selected(index);
1291 1293 var cell = this.get_cell(i);
1292 1294 if (cell !== null && (cell instanceof IPython.CodeCell)) {
1293 1295 cell.toggle_output();
1294 1296 this.set_dirty(true);
1295 1297 }
1296 1298 };
1297 1299
1298 1300 /**
1299 1301 * Hide/show the output of all cells.
1300 1302 *
1301 1303 * @method toggle_all_output
1302 1304 */
1303 1305 Notebook.prototype.toggle_all_output = function () {
1304 1306 $.map(this.get_cells(), function (cell, i) {
1305 1307 if (cell instanceof IPython.CodeCell) {
1306 1308 cell.toggle_output();
1307 1309 }
1308 1310 });
1309 1311 // this should not be set if the `collapse` key is removed from nbformat
1310 1312 this.set_dirty(true);
1311 1313 };
1312 1314
1313 1315 /**
1314 1316 * Toggle a scrollbar for long cell outputs.
1315 1317 *
1316 1318 * @method toggle_output_scroll
1317 1319 * @param {Number} index A cell's numeric index
1318 1320 */
1319 1321 Notebook.prototype.toggle_output_scroll = function (index) {
1320 1322 var i = this.index_or_selected(index);
1321 1323 var cell = this.get_cell(i);
1322 1324 if (cell !== null && (cell instanceof IPython.CodeCell)) {
1323 1325 cell.toggle_output_scroll();
1324 1326 this.set_dirty(true);
1325 1327 }
1326 1328 };
1327 1329
1328 1330 /**
1329 1331 * Toggle the scrolling of long output on all cells.
1330 1332 *
1331 1333 * @method toggle_all_output_scrolling
1332 1334 */
1333 1335 Notebook.prototype.toggle_all_output_scroll = function () {
1334 1336 $.map(this.get_cells(), function (cell, i) {
1335 1337 if (cell instanceof IPython.CodeCell) {
1336 1338 cell.toggle_output_scroll();
1337 1339 }
1338 1340 });
1339 1341 // this should not be set if the `collapse` key is removed from nbformat
1340 1342 this.set_dirty(true);
1341 1343 };
1342 1344
1343 1345 // Other cell functions: line numbers, ...
1344 1346
1345 1347 /**
1346 1348 * Toggle line numbers in the selected cell's input area.
1347 1349 *
1348 1350 * @method cell_toggle_line_numbers
1349 1351 */
1350 1352 Notebook.prototype.cell_toggle_line_numbers = function() {
1351 1353 this.get_selected_cell().toggle_line_numbers();
1352 1354 };
1353 1355
1354 1356 // Session related things
1355 1357
1356 1358 /**
1357 1359 * Start a new session and set it on each code cell.
1358 1360 *
1359 1361 * @method start_session
1360 1362 */
1361 1363 Notebook.prototype.start_session = function () {
1362 1364 this.session = new IPython.Session(this.notebook_name, this.notebook_path, this);
1363 1365 this.session.start($.proxy(this._session_started, this));
1364 1366 };
1365 1367
1366 1368
1367 1369 /**
1368 1370 * Once a session is started, link the code cells to the kernel and pass the
1369 1371 * comm manager to the widget manager
1370 1372 *
1371 1373 */
1372 1374 Notebook.prototype._session_started = function(){
1373 1375 this.kernel = this.session.kernel;
1374 1376 var ncells = this.ncells();
1375 1377 for (var i=0; i<ncells; i++) {
1376 1378 var cell = this.get_cell(i);
1377 1379 if (cell instanceof IPython.CodeCell) {
1378 1380 cell.set_kernel(this.session.kernel);
1379 1381 };
1380 1382 };
1381 1383 };
1382 1384
1383 1385 /**
1384 1386 * Prompt the user to restart the IPython kernel.
1385 1387 *
1386 1388 * @method restart_kernel
1387 1389 */
1388 1390 Notebook.prototype.restart_kernel = function () {
1389 1391 var that = this;
1390 1392 IPython.dialog.modal({
1391 1393 title : "Restart kernel or continue running?",
1392 1394 body : $("<p/>").text(
1393 1395 'Do you want to restart the current kernel? You will lose all variables defined in it.'
1394 1396 ),
1395 1397 buttons : {
1396 1398 "Continue running" : {},
1397 1399 "Restart" : {
1398 1400 "class" : "btn-danger",
1399 1401 "click" : function() {
1400 1402 that.session.restart_kernel();
1401 1403 }
1402 1404 }
1403 1405 }
1404 1406 });
1405 1407 };
1406 1408
1407 1409 /**
1408 1410 * Execute or render cell outputs and go into command mode.
1409 1411 *
1410 1412 * @method execute_cell
1411 1413 */
1412 1414 Notebook.prototype.execute_cell = function () {
1413 1415 // mode = shift, ctrl, alt
1414 1416 var cell = this.get_selected_cell();
1415 1417 var cell_index = this.find_cell_index(cell);
1416 1418
1417 1419 cell.execute();
1418 1420 this.command_mode();
1419 1421 cell.focus_cell();
1420 1422 this.set_dirty(true);
1421 1423 }
1422 1424
1423 1425 /**
1424 1426 * Execute or render cell outputs and insert a new cell below.
1425 1427 *
1426 1428 * @method execute_cell_and_insert_below
1427 1429 */
1428 1430 Notebook.prototype.execute_cell_and_insert_below = function () {
1429 1431 var cell = this.get_selected_cell();
1430 1432 var cell_index = this.find_cell_index(cell);
1431 1433
1432 1434 cell.execute();
1433 1435
1434 1436 // If we are at the end always insert a new cell and return
1435 1437 if (cell_index === (this.ncells()-1)) {
1436 1438 this.insert_cell_below('code');
1437 1439 this.select(cell_index+1);
1438 1440 this.edit_mode();
1439 1441 this.scroll_to_bottom();
1440 1442 this.set_dirty(true);
1441 1443 return;
1442 1444 }
1443 1445
1444 1446 // Only insert a new cell, if we ended up in an already populated cell
1445 1447 var next_text = this.get_cell(cell_index+1).get_text();
1446 1448 if (/\S/.test(next_text) === true) {
1447 1449 this.insert_cell_below('code');
1448 1450 }
1449 1451 this.select(cell_index+1);
1450 1452 this.edit_mode();
1451 1453 this.set_dirty(true);
1452 1454 };
1453 1455
1454 1456 /**
1455 1457 * Execute or render cell outputs and select the next cell.
1456 1458 *
1457 1459 * @method execute_cell_and_select_below
1458 1460 */
1459 1461 Notebook.prototype.execute_cell_and_select_below = function () {
1460 1462
1461 1463 var cell = this.get_selected_cell();
1462 1464 var cell_index = this.find_cell_index(cell);
1463 1465
1464 1466 cell.execute();
1465 1467
1466 1468 // If we are at the end always insert a new cell and return
1467 1469 if (cell_index === (this.ncells()-1)) {
1468 1470 this.insert_cell_below('code');
1469 1471 this.select(cell_index+1);
1470 1472 this.edit_mode();
1471 1473 this.scroll_to_bottom();
1472 1474 this.set_dirty(true);
1473 1475 return;
1474 1476 }
1475 1477
1476 1478 this.select(cell_index+1);
1477 1479 this.get_cell(cell_index+1).focus_cell();
1478 1480 this.set_dirty(true);
1479 1481 };
1480 1482
1481 1483 /**
1482 1484 * Execute all cells below the selected cell.
1483 1485 *
1484 1486 * @method execute_cells_below
1485 1487 */
1486 1488 Notebook.prototype.execute_cells_below = function () {
1487 1489 this.execute_cell_range(this.get_selected_index(), this.ncells());
1488 1490 this.scroll_to_bottom();
1489 1491 };
1490 1492
1491 1493 /**
1492 1494 * Execute all cells above the selected cell.
1493 1495 *
1494 1496 * @method execute_cells_above
1495 1497 */
1496 1498 Notebook.prototype.execute_cells_above = function () {
1497 1499 this.execute_cell_range(0, this.get_selected_index());
1498 1500 };
1499 1501
1500 1502 /**
1501 1503 * Execute all cells.
1502 1504 *
1503 1505 * @method execute_all_cells
1504 1506 */
1505 1507 Notebook.prototype.execute_all_cells = function () {
1506 1508 this.execute_cell_range(0, this.ncells());
1507 1509 this.scroll_to_bottom();
1508 1510 };
1509 1511
1510 1512 /**
1511 1513 * Execute a contiguous range of cells.
1512 1514 *
1513 1515 * @method execute_cell_range
1514 1516 * @param {Number} start Index of the first cell to execute (inclusive)
1515 1517 * @param {Number} end Index of the last cell to execute (exclusive)
1516 1518 */
1517 1519 Notebook.prototype.execute_cell_range = function (start, end) {
1518 1520 for (var i=start; i<end; i++) {
1519 1521 this.select(i);
1520 1522 this.execute_cell();
1521 1523 };
1522 1524 };
1523 1525
1524 1526 // Persistance and loading
1525 1527
1526 1528 /**
1527 1529 * Getter method for this notebook's name.
1528 1530 *
1529 1531 * @method get_notebook_name
1530 1532 * @return {String} This notebook's name
1531 1533 */
1532 1534 Notebook.prototype.get_notebook_name = function () {
1533 1535 var nbname = this.notebook_name.substring(0,this.notebook_name.length-6);
1534 1536 return nbname;
1535 1537 };
1536 1538
1537 1539 /**
1538 1540 * Setter method for this notebook's name.
1539 1541 *
1540 1542 * @method set_notebook_name
1541 1543 * @param {String} name A new name for this notebook
1542 1544 */
1543 1545 Notebook.prototype.set_notebook_name = function (name) {
1544 1546 this.notebook_name = name;
1545 1547 };
1546 1548
1547 1549 /**
1548 1550 * Check that a notebook's name is valid.
1549 1551 *
1550 1552 * @method test_notebook_name
1551 1553 * @param {String} nbname A name for this notebook
1552 1554 * @return {Boolean} True if the name is valid, false if invalid
1553 1555 */
1554 1556 Notebook.prototype.test_notebook_name = function (nbname) {
1555 1557 nbname = nbname || '';
1556 1558 if (this.notebook_name_blacklist_re.test(nbname) == false && nbname.length>0) {
1557 1559 return true;
1558 1560 } else {
1559 1561 return false;
1560 1562 };
1561 1563 };
1562 1564
1563 1565 /**
1564 1566 * Load a notebook from JSON (.ipynb).
1565 1567 *
1566 1568 * This currently handles one worksheet: others are deleted.
1567 1569 *
1568 1570 * @method fromJSON
1569 1571 * @param {Object} data JSON representation of a notebook
1570 1572 */
1571 1573 Notebook.prototype.fromJSON = function (data) {
1572 1574 var content = data.content;
1573 1575 var ncells = this.ncells();
1574 1576 var i;
1575 1577 for (i=0; i<ncells; i++) {
1576 1578 // Always delete cell 0 as they get renumbered as they are deleted.
1577 1579 this.delete_cell(0);
1578 1580 };
1579 1581 // Save the metadata and name.
1580 1582 this.metadata = content.metadata;
1581 1583 this.notebook_name = data.name;
1582 1584 // Only handle 1 worksheet for now.
1583 1585 var worksheet = content.worksheets[0];
1584 1586 if (worksheet !== undefined) {
1585 1587 if (worksheet.metadata) {
1586 1588 this.worksheet_metadata = worksheet.metadata;
1587 1589 }
1588 1590 var new_cells = worksheet.cells;
1589 1591 ncells = new_cells.length;
1590 1592 var cell_data = null;
1591 1593 var new_cell = null;
1592 1594 for (i=0; i<ncells; i++) {
1593 1595 cell_data = new_cells[i];
1594 1596 // VERSIONHACK: plaintext -> raw
1595 1597 // handle never-released plaintext name for raw cells
1596 1598 if (cell_data.cell_type === 'plaintext'){
1597 1599 cell_data.cell_type = 'raw';
1598 1600 }
1599 1601
1600 1602 new_cell = this.insert_cell_at_index(cell_data.cell_type, i);
1601 1603 new_cell.fromJSON(cell_data);
1602 1604 };
1603 1605 };
1604 1606 if (content.worksheets.length > 1) {
1605 1607 IPython.dialog.modal({
1606 1608 title : "Multiple worksheets",
1607 1609 body : "This notebook has " + data.worksheets.length + " worksheets, " +
1608 1610 "but this version of IPython can only handle the first. " +
1609 1611 "If you save this notebook, worksheets after the first will be lost.",
1610 1612 buttons : {
1611 1613 OK : {
1612 1614 class : "btn-danger"
1613 1615 }
1614 1616 }
1615 1617 });
1616 1618 }
1617 1619 };
1618 1620
1619 1621 /**
1620 1622 * Dump this notebook into a JSON-friendly object.
1621 1623 *
1622 1624 * @method toJSON
1623 1625 * @return {Object} A JSON-friendly representation of this notebook.
1624 1626 */
1625 1627 Notebook.prototype.toJSON = function () {
1626 1628 var cells = this.get_cells();
1627 1629 var ncells = cells.length;
1628 1630 var cell_array = new Array(ncells);
1629 1631 for (var i=0; i<ncells; i++) {
1630 1632 cell_array[i] = cells[i].toJSON();
1631 1633 };
1632 1634 var data = {
1633 1635 // Only handle 1 worksheet for now.
1634 1636 worksheets : [{
1635 1637 cells: cell_array,
1636 1638 metadata: this.worksheet_metadata
1637 1639 }],
1638 1640 metadata : this.metadata
1639 1641 };
1640 1642 return data;
1641 1643 };
1642 1644
1643 1645 /**
1644 1646 * Start an autosave timer, for periodically saving the notebook.
1645 1647 *
1646 1648 * @method set_autosave_interval
1647 1649 * @param {Integer} interval the autosave interval in milliseconds
1648 1650 */
1649 1651 Notebook.prototype.set_autosave_interval = function (interval) {
1650 1652 var that = this;
1651 1653 // clear previous interval, so we don't get simultaneous timers
1652 1654 if (this.autosave_timer) {
1653 1655 clearInterval(this.autosave_timer);
1654 1656 }
1655 1657
1656 1658 this.autosave_interval = this.minimum_autosave_interval = interval;
1657 1659 if (interval) {
1658 1660 this.autosave_timer = setInterval(function() {
1659 1661 if (that.dirty) {
1660 1662 that.save_notebook();
1661 1663 }
1662 1664 }, interval);
1663 1665 $([IPython.events]).trigger("autosave_enabled.Notebook", interval);
1664 1666 } else {
1665 1667 this.autosave_timer = null;
1666 1668 $([IPython.events]).trigger("autosave_disabled.Notebook");
1667 1669 };
1668 1670 };
1669 1671
1670 1672 /**
1671 1673 * Save this notebook on the server.
1672 1674 *
1673 1675 * @method save_notebook
1674 1676 */
1675 1677 Notebook.prototype.save_notebook = function (extra_settings) {
1676 1678 // Create a JSON model to be sent to the server.
1677 1679 var model = {};
1678 1680 model.name = this.notebook_name;
1679 1681 model.path = this.notebook_path;
1680 1682 model.content = this.toJSON();
1681 1683 model.content.nbformat = this.nbformat;
1682 1684 model.content.nbformat_minor = this.nbformat_minor;
1683 1685 // time the ajax call for autosave tuning purposes.
1684 1686 var start = new Date().getTime();
1685 1687 // We do the call with settings so we can set cache to false.
1686 1688 var settings = {
1687 1689 processData : false,
1688 1690 cache : false,
1689 1691 type : "PUT",
1690 1692 data : JSON.stringify(model),
1691 1693 headers : {'Content-Type': 'application/json'},
1692 1694 success : $.proxy(this.save_notebook_success, this, start),
1693 1695 error : $.proxy(this.save_notebook_error, this)
1694 1696 };
1695 1697 if (extra_settings) {
1696 1698 for (var key in extra_settings) {
1697 1699 settings[key] = extra_settings[key];
1698 1700 }
1699 1701 }
1700 1702 $([IPython.events]).trigger('notebook_saving.Notebook');
1701 1703 var url = utils.url_join_encode(
1702 1704 this._baseProjectUrl,
1703 1705 'api/notebooks',
1704 1706 this.notebook_path,
1705 1707 this.notebook_name
1706 1708 );
1707 1709 $.ajax(url, settings);
1708 1710 };
1709 1711
1710 1712 /**
1711 1713 * Success callback for saving a notebook.
1712 1714 *
1713 1715 * @method save_notebook_success
1714 1716 * @param {Integer} start the time when the save request started
1715 1717 * @param {Object} data JSON representation of a notebook
1716 1718 * @param {String} status Description of response status
1717 1719 * @param {jqXHR} xhr jQuery Ajax object
1718 1720 */
1719 1721 Notebook.prototype.save_notebook_success = function (start, data, status, xhr) {
1720 1722 this.set_dirty(false);
1721 1723 $([IPython.events]).trigger('notebook_saved.Notebook');
1722 1724 this._update_autosave_interval(start);
1723 1725 if (this._checkpoint_after_save) {
1724 1726 this.create_checkpoint();
1725 1727 this._checkpoint_after_save = false;
1726 1728 };
1727 1729 };
1728 1730
1729 1731 /**
1730 1732 * update the autosave interval based on how long the last save took
1731 1733 *
1732 1734 * @method _update_autosave_interval
1733 1735 * @param {Integer} timestamp when the save request started
1734 1736 */
1735 1737 Notebook.prototype._update_autosave_interval = function (start) {
1736 1738 var duration = (new Date().getTime() - start);
1737 1739 if (this.autosave_interval) {
1738 1740 // new save interval: higher of 10x save duration or parameter (default 30 seconds)
1739 1741 var interval = Math.max(10 * duration, this.minimum_autosave_interval);
1740 1742 // round to 10 seconds, otherwise we will be setting a new interval too often
1741 1743 interval = 10000 * Math.round(interval / 10000);
1742 1744 // set new interval, if it's changed
1743 1745 if (interval != this.autosave_interval) {
1744 1746 this.set_autosave_interval(interval);
1745 1747 }
1746 1748 }
1747 1749 };
1748 1750
1749 1751 /**
1750 1752 * Failure callback for saving a notebook.
1751 1753 *
1752 1754 * @method save_notebook_error
1753 1755 * @param {jqXHR} xhr jQuery Ajax object
1754 1756 * @param {String} status Description of response status
1755 1757 * @param {String} error HTTP error message
1756 1758 */
1757 1759 Notebook.prototype.save_notebook_error = function (xhr, status, error) {
1758 1760 $([IPython.events]).trigger('notebook_save_failed.Notebook', [xhr, status, error]);
1759 1761 };
1760 1762
1761 1763 Notebook.prototype.new_notebook = function(){
1762 1764 var path = this.notebook_path;
1763 1765 var base_project_url = this._baseProjectUrl;
1764 1766 var settings = {
1765 1767 processData : false,
1766 1768 cache : false,
1767 1769 type : "POST",
1768 1770 dataType : "json",
1769 1771 async : false,
1770 1772 success : function (data, status, xhr){
1771 1773 var notebook_name = data.name;
1772 1774 window.open(
1773 1775 utils.url_join_encode(
1774 1776 base_project_url,
1775 1777 'notebooks',
1776 1778 path,
1777 1779 notebook_name
1778 1780 ),
1779 1781 '_blank'
1780 1782 );
1781 1783 }
1782 1784 };
1783 1785 var url = utils.url_join_encode(
1784 1786 base_project_url,
1785 1787 'api/notebooks',
1786 1788 path
1787 1789 );
1788 1790 $.ajax(url,settings);
1789 1791 };
1790 1792
1791 1793
1792 1794 Notebook.prototype.copy_notebook = function(){
1793 1795 var path = this.notebook_path;
1794 1796 var base_project_url = this._baseProjectUrl;
1795 1797 var settings = {
1796 1798 processData : false,
1797 1799 cache : false,
1798 1800 type : "POST",
1799 1801 dataType : "json",
1800 1802 data : JSON.stringify({copy_from : this.notebook_name}),
1801 1803 async : false,
1802 1804 success : function (data, status, xhr) {
1803 1805 window.open(utils.url_join_encode(
1804 1806 base_project_url,
1805 1807 'notebooks',
1806 1808 data.path,
1807 1809 data.name
1808 1810 ), '_blank');
1809 1811 }
1810 1812 };
1811 1813 var url = utils.url_join_encode(
1812 1814 base_project_url,
1813 1815 'api/notebooks',
1814 1816 path
1815 1817 );
1816 1818 $.ajax(url,settings);
1817 1819 };
1818 1820
1819 1821 Notebook.prototype.rename = function (nbname) {
1820 1822 var that = this;
1821 1823 var data = {name: nbname + '.ipynb'};
1822 1824 var settings = {
1823 1825 processData : false,
1824 1826 cache : false,
1825 1827 type : "PATCH",
1826 1828 data : JSON.stringify(data),
1827 1829 dataType: "json",
1828 1830 headers : {'Content-Type': 'application/json'},
1829 1831 success : $.proxy(that.rename_success, this),
1830 1832 error : $.proxy(that.rename_error, this)
1831 1833 };
1832 1834 $([IPython.events]).trigger('rename_notebook.Notebook', data);
1833 1835 var url = utils.url_join_encode(
1834 1836 this._baseProjectUrl,
1835 1837 'api/notebooks',
1836 1838 this.notebook_path,
1837 1839 this.notebook_name
1838 1840 );
1839 1841 $.ajax(url, settings);
1840 1842 };
1841 1843
1842 1844
1843 1845 Notebook.prototype.rename_success = function (json, status, xhr) {
1844 1846 this.notebook_name = json.name;
1845 1847 var name = this.notebook_name;
1846 1848 var path = json.path;
1847 1849 this.session.rename_notebook(name, path);
1848 1850 $([IPython.events]).trigger('notebook_renamed.Notebook', json);
1849 1851 }
1850 1852
1851 1853 Notebook.prototype.rename_error = function (xhr, status, error) {
1852 1854 var that = this;
1853 1855 var dialog = $('<div/>').append(
1854 1856 $("<p/>").addClass("rename-message")
1855 1857 .text('This notebook name already exists.')
1856 1858 )
1857 1859 $([IPython.events]).trigger('notebook_rename_failed.Notebook', [xhr, status, error]);
1858 1860 IPython.dialog.modal({
1859 1861 title: "Notebook Rename Error!",
1860 1862 body: dialog,
1861 1863 buttons : {
1862 1864 "Cancel": {},
1863 1865 "OK": {
1864 1866 class: "btn-primary",
1865 1867 click: function () {
1866 1868 IPython.save_widget.rename_notebook();
1867 1869 }}
1868 1870 },
1869 1871 open : function (event, ui) {
1870 1872 var that = $(this);
1871 1873 // Upon ENTER, click the OK button.
1872 1874 that.find('input[type="text"]').keydown(function (event, ui) {
1873 1875 if (event.which === utils.keycodes.ENTER) {
1874 1876 that.find('.btn-primary').first().click();
1875 1877 }
1876 1878 });
1877 1879 that.find('input[type="text"]').focus();
1878 1880 }
1879 1881 });
1880 1882 }
1881 1883
1882 1884 /**
1883 1885 * Request a notebook's data from the server.
1884 1886 *
1885 1887 * @method load_notebook
1886 1888 * @param {String} notebook_name and path A notebook to load
1887 1889 */
1888 1890 Notebook.prototype.load_notebook = function (notebook_name, notebook_path) {
1889 1891 var that = this;
1890 1892 this.notebook_name = notebook_name;
1891 1893 this.notebook_path = notebook_path;
1892 1894 // We do the call with settings so we can set cache to false.
1893 1895 var settings = {
1894 1896 processData : false,
1895 1897 cache : false,
1896 1898 type : "GET",
1897 1899 dataType : "json",
1898 1900 success : $.proxy(this.load_notebook_success,this),
1899 1901 error : $.proxy(this.load_notebook_error,this),
1900 1902 };
1901 1903 $([IPython.events]).trigger('notebook_loading.Notebook');
1902 1904 var url = utils.url_join_encode(
1903 1905 this._baseProjectUrl,
1904 1906 'api/notebooks',
1905 1907 this.notebook_path,
1906 1908 this.notebook_name
1907 1909 );
1908 1910 $.ajax(url, settings);
1909 1911 };
1910 1912
1911 1913 /**
1912 1914 * Success callback for loading a notebook from the server.
1913 1915 *
1914 1916 * Load notebook data from the JSON response.
1915 1917 *
1916 1918 * @method load_notebook_success
1917 1919 * @param {Object} data JSON representation of a notebook
1918 1920 * @param {String} status Description of response status
1919 1921 * @param {jqXHR} xhr jQuery Ajax object
1920 1922 */
1921 1923 Notebook.prototype.load_notebook_success = function (data, status, xhr) {
1922 1924 this.fromJSON(data);
1923 1925 if (this.ncells() === 0) {
1924 1926 this.insert_cell_below('code');
1925 1927 this.select(0);
1926 1928 this.edit_mode();
1927 1929 } else {
1928 1930 this.select(0);
1929 1931 this.command_mode();
1930 1932 };
1931 1933 this.set_dirty(false);
1932 1934 this.scroll_to_top();
1933 1935 if (data.orig_nbformat !== undefined && data.nbformat !== data.orig_nbformat) {
1934 1936 var msg = "This notebook has been converted from an older " +
1935 1937 "notebook format (v"+data.orig_nbformat+") to the current notebook " +
1936 1938 "format (v"+data.nbformat+"). The next time you save this notebook, the " +
1937 1939 "newer notebook format will be used and older versions of IPython " +
1938 1940 "may not be able to read it. To keep the older version, close the " +
1939 1941 "notebook without saving it.";
1940 1942 IPython.dialog.modal({
1941 1943 title : "Notebook converted",
1942 1944 body : msg,
1943 1945 buttons : {
1944 1946 OK : {
1945 1947 class : "btn-primary"
1946 1948 }
1947 1949 }
1948 1950 });
1949 1951 } else if (data.orig_nbformat_minor !== undefined && data.nbformat_minor !== data.orig_nbformat_minor) {
1950 1952 var that = this;
1951 1953 var orig_vs = 'v' + data.nbformat + '.' + data.orig_nbformat_minor;
1952 1954 var this_vs = 'v' + data.nbformat + '.' + this.nbformat_minor;
1953 1955 var msg = "This notebook is version " + orig_vs + ", but we only fully support up to " +
1954 1956 this_vs + ". You can still work with this notebook, but some features " +
1955 1957 "introduced in later notebook versions may not be available."
1956 1958
1957 1959 IPython.dialog.modal({
1958 1960 title : "Newer Notebook",
1959 1961 body : msg,
1960 1962 buttons : {
1961 1963 OK : {
1962 1964 class : "btn-danger"
1963 1965 }
1964 1966 }
1965 1967 });
1966 1968
1967 1969 }
1968 1970
1969 1971 // Create the session after the notebook is completely loaded to prevent
1970 1972 // code execution upon loading, which is a security risk.
1971 1973 if (this.session == null) {
1972 1974 this.start_session();
1973 1975 }
1974 1976 // load our checkpoint list
1975 1977 this.list_checkpoints();
1976 1978
1977 1979 // load toolbar state
1978 1980 if (this.metadata.celltoolbar) {
1979 1981 IPython.CellToolbar.global_show();
1980 1982 IPython.CellToolbar.activate_preset(this.metadata.celltoolbar);
1981 1983 }
1982 1984
1983 1985 $([IPython.events]).trigger('notebook_loaded.Notebook');
1984 1986 };
1985 1987
1986 1988 /**
1987 1989 * Failure callback for loading a notebook from the server.
1988 1990 *
1989 1991 * @method load_notebook_error
1990 1992 * @param {jqXHR} xhr jQuery Ajax object
1991 1993 * @param {String} status Description of response status
1992 1994 * @param {String} error HTTP error message
1993 1995 */
1994 1996 Notebook.prototype.load_notebook_error = function (xhr, status, error) {
1995 1997 $([IPython.events]).trigger('notebook_load_failed.Notebook', [xhr, status, error]);
1996 1998 if (xhr.status === 400) {
1997 1999 var msg = error;
1998 2000 } else if (xhr.status === 500) {
1999 2001 var msg = "An unknown error occurred while loading this notebook. " +
2000 2002 "This version can load notebook formats " +
2001 2003 "v" + this.nbformat + " or earlier.";
2002 2004 }
2003 2005 IPython.dialog.modal({
2004 2006 title: "Error loading notebook",
2005 2007 body : msg,
2006 2008 buttons : {
2007 2009 "OK": {}
2008 2010 }
2009 2011 });
2010 2012 }
2011 2013
2012 2014 /********************* checkpoint-related *********************/
2013 2015
2014 2016 /**
2015 2017 * Save the notebook then immediately create a checkpoint.
2016 2018 *
2017 2019 * @method save_checkpoint
2018 2020 */
2019 2021 Notebook.prototype.save_checkpoint = function () {
2020 2022 this._checkpoint_after_save = true;
2021 2023 this.save_notebook();
2022 2024 };
2023 2025
2024 2026 /**
2025 2027 * Add a checkpoint for this notebook.
2026 2028 * for use as a callback from checkpoint creation.
2027 2029 *
2028 2030 * @method add_checkpoint
2029 2031 */
2030 2032 Notebook.prototype.add_checkpoint = function (checkpoint) {
2031 2033 var found = false;
2032 2034 for (var i = 0; i < this.checkpoints.length; i++) {
2033 2035 var existing = this.checkpoints[i];
2034 2036 if (existing.id == checkpoint.id) {
2035 2037 found = true;
2036 2038 this.checkpoints[i] = checkpoint;
2037 2039 break;
2038 2040 }
2039 2041 }
2040 2042 if (!found) {
2041 2043 this.checkpoints.push(checkpoint);
2042 2044 }
2043 2045 this.last_checkpoint = this.checkpoints[this.checkpoints.length - 1];
2044 2046 };
2045 2047
2046 2048 /**
2047 2049 * List checkpoints for this notebook.
2048 2050 *
2049 2051 * @method list_checkpoints
2050 2052 */
2051 2053 Notebook.prototype.list_checkpoints = function () {
2052 2054 var url = utils.url_join_encode(
2053 2055 this._baseProjectUrl,
2054 2056 'api/notebooks',
2055 2057 this.notebook_path,
2056 2058 this.notebook_name,
2057 2059 'checkpoints'
2058 2060 );
2059 2061 $.get(url).done(
2060 2062 $.proxy(this.list_checkpoints_success, this)
2061 2063 ).fail(
2062 2064 $.proxy(this.list_checkpoints_error, this)
2063 2065 );
2064 2066 };
2065 2067
2066 2068 /**
2067 2069 * Success callback for listing checkpoints.
2068 2070 *
2069 2071 * @method list_checkpoint_success
2070 2072 * @param {Object} data JSON representation of a checkpoint
2071 2073 * @param {String} status Description of response status
2072 2074 * @param {jqXHR} xhr jQuery Ajax object
2073 2075 */
2074 2076 Notebook.prototype.list_checkpoints_success = function (data, status, xhr) {
2075 2077 var data = $.parseJSON(data);
2076 2078 this.checkpoints = data;
2077 2079 if (data.length) {
2078 2080 this.last_checkpoint = data[data.length - 1];
2079 2081 } else {
2080 2082 this.last_checkpoint = null;
2081 2083 }
2082 2084 $([IPython.events]).trigger('checkpoints_listed.Notebook', [data]);
2083 2085 };
2084 2086
2085 2087 /**
2086 2088 * Failure callback for listing a checkpoint.
2087 2089 *
2088 2090 * @method list_checkpoint_error
2089 2091 * @param {jqXHR} xhr jQuery Ajax object
2090 2092 * @param {String} status Description of response status
2091 2093 * @param {String} error_msg HTTP error message
2092 2094 */
2093 2095 Notebook.prototype.list_checkpoints_error = function (xhr, status, error_msg) {
2094 2096 $([IPython.events]).trigger('list_checkpoints_failed.Notebook');
2095 2097 };
2096 2098
2097 2099 /**
2098 2100 * Create a checkpoint of this notebook on the server from the most recent save.
2099 2101 *
2100 2102 * @method create_checkpoint
2101 2103 */
2102 2104 Notebook.prototype.create_checkpoint = function () {
2103 2105 var url = utils.url_join_encode(
2104 2106 this._baseProjectUrl,
2105 2107 'api/notebooks',
2106 2108 this.notebookPath(),
2107 2109 this.notebook_name,
2108 2110 'checkpoints'
2109 2111 );
2110 2112 $.post(url).done(
2111 2113 $.proxy(this.create_checkpoint_success, this)
2112 2114 ).fail(
2113 2115 $.proxy(this.create_checkpoint_error, this)
2114 2116 );
2115 2117 };
2116 2118
2117 2119 /**
2118 2120 * Success callback for creating a checkpoint.
2119 2121 *
2120 2122 * @method create_checkpoint_success
2121 2123 * @param {Object} data JSON representation of a checkpoint
2122 2124 * @param {String} status Description of response status
2123 2125 * @param {jqXHR} xhr jQuery Ajax object
2124 2126 */
2125 2127 Notebook.prototype.create_checkpoint_success = function (data, status, xhr) {
2126 2128 var data = $.parseJSON(data);
2127 2129 this.add_checkpoint(data);
2128 2130 $([IPython.events]).trigger('checkpoint_created.Notebook', data);
2129 2131 };
2130 2132
2131 2133 /**
2132 2134 * Failure callback for creating a checkpoint.
2133 2135 *
2134 2136 * @method create_checkpoint_error
2135 2137 * @param {jqXHR} xhr jQuery Ajax object
2136 2138 * @param {String} status Description of response status
2137 2139 * @param {String} error_msg HTTP error message
2138 2140 */
2139 2141 Notebook.prototype.create_checkpoint_error = function (xhr, status, error_msg) {
2140 2142 $([IPython.events]).trigger('checkpoint_failed.Notebook');
2141 2143 };
2142 2144
2143 2145 Notebook.prototype.restore_checkpoint_dialog = function (checkpoint) {
2144 2146 var that = this;
2145 2147 var checkpoint = checkpoint || this.last_checkpoint;
2146 2148 if ( ! checkpoint ) {
2147 2149 console.log("restore dialog, but no checkpoint to restore to!");
2148 2150 return;
2149 2151 }
2150 2152 var body = $('<div/>').append(
2151 2153 $('<p/>').addClass("p-space").text(
2152 2154 "Are you sure you want to revert the notebook to " +
2153 2155 "the latest checkpoint?"
2154 2156 ).append(
2155 2157 $("<strong/>").text(
2156 2158 " This cannot be undone."
2157 2159 )
2158 2160 )
2159 2161 ).append(
2160 2162 $('<p/>').addClass("p-space").text("The checkpoint was last updated at:")
2161 2163 ).append(
2162 2164 $('<p/>').addClass("p-space").text(
2163 2165 Date(checkpoint.last_modified)
2164 2166 ).css("text-align", "center")
2165 2167 );
2166 2168
2167 2169 IPython.dialog.modal({
2168 2170 title : "Revert notebook to checkpoint",
2169 2171 body : body,
2170 2172 buttons : {
2171 2173 Revert : {
2172 2174 class : "btn-danger",
2173 2175 click : function () {
2174 2176 that.restore_checkpoint(checkpoint.id);
2175 2177 }
2176 2178 },
2177 2179 Cancel : {}
2178 2180 }
2179 2181 });
2180 2182 }
2181 2183
2182 2184 /**
2183 2185 * Restore the notebook to a checkpoint state.
2184 2186 *
2185 2187 * @method restore_checkpoint
2186 2188 * @param {String} checkpoint ID
2187 2189 */
2188 2190 Notebook.prototype.restore_checkpoint = function (checkpoint) {
2189 2191 $([IPython.events]).trigger('notebook_restoring.Notebook', checkpoint);
2190 2192 var url = utils.url_join_encode(
2191 2193 this._baseProjectUrl,
2192 2194 'api/notebooks',
2193 2195 this.notebookPath(),
2194 2196 this.notebook_name,
2195 2197 'checkpoints',
2196 2198 checkpoint
2197 2199 );
2198 2200 $.post(url).done(
2199 2201 $.proxy(this.restore_checkpoint_success, this)
2200 2202 ).fail(
2201 2203 $.proxy(this.restore_checkpoint_error, this)
2202 2204 );
2203 2205 };
2204 2206
2205 2207 /**
2206 2208 * Success callback for restoring a notebook to a checkpoint.
2207 2209 *
2208 2210 * @method restore_checkpoint_success
2209 2211 * @param {Object} data (ignored, should be empty)
2210 2212 * @param {String} status Description of response status
2211 2213 * @param {jqXHR} xhr jQuery Ajax object
2212 2214 */
2213 2215 Notebook.prototype.restore_checkpoint_success = function (data, status, xhr) {
2214 2216 $([IPython.events]).trigger('checkpoint_restored.Notebook');
2215 2217 this.load_notebook(this.notebook_name, this.notebook_path);
2216 2218 };
2217 2219
2218 2220 /**
2219 2221 * Failure callback for restoring a notebook to a checkpoint.
2220 2222 *
2221 2223 * @method restore_checkpoint_error
2222 2224 * @param {jqXHR} xhr jQuery Ajax object
2223 2225 * @param {String} status Description of response status
2224 2226 * @param {String} error_msg HTTP error message
2225 2227 */
2226 2228 Notebook.prototype.restore_checkpoint_error = function (xhr, status, error_msg) {
2227 2229 $([IPython.events]).trigger('checkpoint_restore_failed.Notebook');
2228 2230 };
2229 2231
2230 2232 /**
2231 2233 * Delete a notebook checkpoint.
2232 2234 *
2233 2235 * @method delete_checkpoint
2234 2236 * @param {String} checkpoint ID
2235 2237 */
2236 2238 Notebook.prototype.delete_checkpoint = function (checkpoint) {
2237 2239 $([IPython.events]).trigger('notebook_restoring.Notebook', checkpoint);
2238 2240 var url = utils.url_join_encode(
2239 2241 this._baseProjectUrl,
2240 2242 'api/notebooks',
2241 2243 this.notebookPath(),
2242 2244 this.notebook_name,
2243 2245 'checkpoints',
2244 2246 checkpoint
2245 2247 );
2246 2248 $.ajax(url, {
2247 2249 type: 'DELETE',
2248 2250 success: $.proxy(this.delete_checkpoint_success, this),
2249 2251 error: $.proxy(this.delete_notebook_error,this)
2250 2252 });
2251 2253 };
2252 2254
2253 2255 /**
2254 2256 * Success callback for deleting a notebook checkpoint
2255 2257 *
2256 2258 * @method delete_checkpoint_success
2257 2259 * @param {Object} data (ignored, should be empty)
2258 2260 * @param {String} status Description of response status
2259 2261 * @param {jqXHR} xhr jQuery Ajax object
2260 2262 */
2261 2263 Notebook.prototype.delete_checkpoint_success = function (data, status, xhr) {
2262 2264 $([IPython.events]).trigger('checkpoint_deleted.Notebook', data);
2263 2265 this.load_notebook(this.notebook_name, this.notebook_path);
2264 2266 };
2265 2267
2266 2268 /**
2267 2269 * Failure callback for deleting a notebook checkpoint.
2268 2270 *
2269 2271 * @method delete_checkpoint_error
2270 2272 * @param {jqXHR} xhr jQuery Ajax object
2271 2273 * @param {String} status Description of response status
2272 2274 * @param {String} error_msg HTTP error message
2273 2275 */
2274 2276 Notebook.prototype.delete_checkpoint_error = function (xhr, status, error_msg) {
2275 2277 $([IPython.events]).trigger('checkpoint_delete_failed.Notebook');
2276 2278 };
2277 2279
2278 2280
2279 2281 IPython.Notebook = Notebook;
2280 2282
2281 2283
2282 2284 return IPython;
2283 2285
2284 2286 }(IPython));
General Comments 0
You need to be logged in to leave comments. Login now