├── .gitignore
├── MANIFEST.in
├── lc_multi_outputs
    ├── _version.py
    ├── nbextension
    │   ├── icon.png
    │   ├── demo-diff-dialog.gif
    │   ├── demo-pin-button.gif
    │   ├── lc-multi-outputs.yml
    │   ├── README.md
    │   ├── main.css
    │   └── main.js
    └── __init__.py
├── Dockerfile
├── setup.py
├── LICENSE.txt
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | *.pyc
2 | *.egg-info
3 | /build
4 | /dist
5 | /lc_multi_outputs/nbextension/lib/*
6 | 


--------------------------------------------------------------------------------
/MANIFEST.in:
--------------------------------------------------------------------------------
1 | include lc_multi_outputs/nbextension/*
2 | include lc_multi_outputs/nbextension/lib/*
3 | 


--------------------------------------------------------------------------------
/lc_multi_outputs/_version.py:
--------------------------------------------------------------------------------
1 | version_info = (2, 1, 0)
2 | __version__ = '.'.join(map(str, version_info))
3 | 


--------------------------------------------------------------------------------
/lc_multi_outputs/nbextension/icon.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NII-cloud-operation/Jupyter-multi_outputs/master/lc_multi_outputs/nbextension/icon.png


--------------------------------------------------------------------------------
/lc_multi_outputs/nbextension/demo-diff-dialog.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NII-cloud-operation/Jupyter-multi_outputs/master/lc_multi_outputs/nbextension/demo-diff-dialog.gif


--------------------------------------------------------------------------------
/lc_multi_outputs/nbextension/demo-pin-button.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/NII-cloud-operation/Jupyter-multi_outputs/master/lc_multi_outputs/nbextension/demo-pin-button.gif


--------------------------------------------------------------------------------
/lc_multi_outputs/__init__.py:
--------------------------------------------------------------------------------
1 | # nbextension
2 | def _jupyter_nbextension_paths():
3 |     return [dict(
4 |         section="notebook",
5 |         src="nbextension",
6 |         dest="multi_outputs",
7 |         require="multi_outputs/main")]
8 | 
9 | 


--------------------------------------------------------------------------------
/lc_multi_outputs/nbextension/lc-multi-outputs.yml:
--------------------------------------------------------------------------------
 1 | Type: Jupyter Notebook Extension
 2 | Name: LC multi outputs
 3 | Section: notebook
 4 | Description: "Multi outputs extension for Literate Computing"
 5 | Link: README.md
 6 | Icon: icon.png
 7 | Main: main.js
 8 | # 1.x means nbclassic - leave 6.x in place just in case.
 9 | Compatibility: 1.x 4.x 5.x 6.x
10 | Parameters:
11 | - name: MultiOutputs.max_num_of_pinned_outputs
12 |   description: |
13 |     Maximum number of pinned output tabs
14 |   input_type: number
15 |   default: 5
16 |   step: 1
17 |   min: 1
18 | 


--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
 1 | FROM jupyter/scipy-notebook:latest
 2 | 
 3 | USER root
 4 | 
 5 | ### extensions for jupyter
 6 | COPY . /tmp/multi_outputs
 7 | RUN pip --no-cache-dir install jupyter_nbextensions_configurator \
 8 |     /tmp/multi_outputs
 9 | 
10 | RUN jupyter nbclassic-extension install --py jupyter_nbextensions_configurator --sys-prefix && \
11 |     jupyter nbclassic-extension enable --py jupyter_nbextensions_configurator --sys-prefix && \
12 |     jupyter nbclassic-serverextension enable --py jupyter_nbextensions_configurator --sys-prefix && \
13 |     jupyter nbclassic-extension install --py lc_multi_outputs --sys-prefix && \
14 |     jupyter nbclassic-extension enable --py lc_multi_outputs --sys-prefix && \
15 |     fix-permissions /home/$NB_USER
16 | 
17 | # Make classic notebook the default
18 | ENV DOCKER_STACKS_JUPYTER_CMD=nbclassic
19 | 
20 | USER $NB_USER
21 | 


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env python
 2 | 
 3 | from setuptools import setup
 4 | import os
 5 | import sys
 6 | try:
 7 |     from urllib.request import urlopen
 8 | except ImportError:
 9 |     from urllib import urlopen
10 | 
11 | HERE = os.path.abspath(os.path.dirname(__file__))
12 | VERSION_NS = {}
13 | with open(os.path.join(HERE, 'lc_multi_outputs', '_version.py')) as f:
14 |     exec(f.read(), {}, VERSION_NS)
15 | 
16 | LIB = os.path.join(HERE, 'lc_multi_outputs', 'nbextension', 'lib')
17 | if not os.path.exists(LIB):
18 |     os.mkdir(LIB)
19 | 
20 | with open(os.path.join(LIB, 'diff_match_patch.js'), 'wb') as f:
21 |     f.write(urlopen('https://github.com/google/diff-match-patch/raw/master/javascript/diff_match_patch.js').read())
22 | 
23 | setup_args = dict (name='lc-multi-outputs',
24 |       version=VERSION_NS['__version__'],
25 |       description='LC multi outputs extension for Jupyter Notebook',
26 |       packages=['lc_multi_outputs'],
27 |       include_package_data=True,
28 |       platforms=['Jupyter Notebook 4.2.x', 'Jupyter Notebook 5.x'],
29 |       zip_safe=False,
30 |       install_requires=[
31 |           'notebook>=4.2.0',
32 |       ]
33 | )
34 | 
35 | if __name__ == '__main__':
36 |     setup(**setup_args)
37 | 
38 | 


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | Copyright (c) 2016-2017,  National Institute of Informatics.
 2 | All rights reserved.
 3 | 
 4 | Redistribution and use in source and binary forms, with or without
 5 | modification, are permitted provided that the following conditions are met:
 6 | 
 7 | * Redistributions of source code must retain the above copyright notice, this
 8 |   list of conditions and the following disclaimer.
 9 | 
10 | * Redistributions in binary form must reproduce the above copyright notice,
11 |   this list of conditions and the following disclaimer in the documentation
12 |   and/or other materials provided with the distribution.
13 | 
14 | * Neither the name of National Institute of Informatics nor the names of its
15 |   contributors may be used to endorse or promote products derived from
16 |   this software without specific prior written permission.
17 | 
18 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
19 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
20 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
22 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
23 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
24 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
25 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
26 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
27 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 | 


--------------------------------------------------------------------------------
/lc_multi_outputs/nbextension/README.md:
--------------------------------------------------------------------------------
 1 | # Introduction
 2 | 
 3 | This extension enables to keep multiple results as tabs in output_area.
 4 | You can also save/load tabbed outputs as far as this extension is enabled
 5 | As default behavior the "output_area" under a code cell is cleared and over written in each execution.
 6 | 
 7 | # Feature
 8 | 
 9 | * Pin button for saving outputs
10 | * Visualization of each code cell's executing status with colors
11 | * Diff dialog for comparing pinned outputs with current outputs
12 | * Search feature in the diff dialog
13 | 
14 | # Usage
15 | 
16 | ## Save current outputs
17 | 
18 | 1. Execute a code cell
19 | 2. Select the current output (leftmost) tab (if output tabs exist)
20 | 3. Click the pin button in the output prompt area
21 | 
22 | ![pin button demo](./demo-pin-button.gif)
23 | 
24 | ## Execution status color of code cell
25 | 
26 | The prompt area of code cell displays execution status with colors.
27 | The colors mean as follows:
28 | 
29 | - White: Not Executed
30 | - Light cyan: Awaiting Execution
31 | - Green: Successfully Executed
32 | - Pink: Failed
33 | 
34 | ## Diff dialog
35 | 
36 | You can compare pinned output with current output.
37 | 
38 | 1. Select the pinned output tab you want to compare with current output
39 | 2. Click the diff button in the output prompt area
40 | 
41 | You can search keyword from the outputs compared in the diff dialog.
42 | To search, input keyword to the search field and press the Enter key.
43 | 
44 | ![diff dialog demo](./demo-diff-dialog.gif)
45 | 
46 | # Internals
47 | 
48 | The pinned outputs are saved as cell metadata.
49 | 
50 | This is an example of a code cell
51 | ```
52 | {
53 |  "cell_type": "code",
54 |  "execution_count": 2,
55 |  "metadata": {
56 |   "pinned_outputs": [
57 |    {
58 |     "execution_count": 1,
59 |     "outputs": [
60 |      {
61 |       "data": {
62 |        "text/plain": "'2017/10/12 13:36:42'"
63 |       },
64 |       "execution_count": 1,
65 |       "metadata": {},
66 |       "output_type": "execute_result"
67 |      }
68 |     ]
69 |    }
70 |   ]
71 |  },
72 |  "outputs": [
73 |   {
74 |    "data": {
75 |     "text/plain": [
76 |      "'2017/10/12 13:36:49'"
77 |     ]
78 |    },
79 |    "execution_count": 2,
80 |    "metadata": {},
81 |    "output_type": "execute_result"
82 |   }
83 |  ],
84 |  "source": [
85 |   "from datetime import datetime\n",
86 |   "datetime.now().strftime('%Y/%m/%d %H:%M:%S')"
87 |  ]
88 | }
89 | ```
90 | 
91 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Introduction
  2 | 
  3 | This extension enables to keep multiple results as tabs in output_area.
  4 | You can also save/load tabbed outputs as far as this extension is enabled
  5 | As default behavior the "output_area" under a code cell is cleared and over written in each execution.  
  6 | 
  7 | # Feature
  8 | 
  9 | * Pin button for saving outputs
 10 | * Visualization of each code cell's executing status with colors
 11 | * Diff dialog for comparing pinned outputs with current outputs
 12 | * Search feature in the diff dialog
 13 | 
 14 | # How to install
 15 | 
 16 | To install the multi_outputs extension, the following steps are required.
 17 | 
 18 | ## Install the python package
 19 | 
 20 | Install the `lc_multi_outputs` python package.
 21 | 
 22 | ```
 23 | pip install git+https://github.com/NII-cloud-operation/Jupyter-multi_outputs
 24 | ```
 25 | 
 26 | ## Install extension files
 27 | 
 28 | Copy the nbextension files into the jupyter server's search directory.
 29 | 
 30 | ```
 31 | jupyter nbextension install --py lc_multi_outputs --user
 32 | ```
 33 | 
 34 | About details of `jupyter nbextension` subcommand, execute this command with `--help` option, and see the results.
 35 | 
 36 | ```
 37 | jupyter nbextension --help
 38 | ```
 39 | 
 40 | ## Enabling extension
 41 | 
 42 | To use the multi_outputs extension, you will also need to enable it.
 43 | 
 44 | ```
 45 | jupyter nbextension enable --py lc_multi_outputs --user
 46 | ```
 47 | 
 48 | # Usage
 49 | 
 50 | ## Save current outputs
 51 | 
 52 | 1. Execute a code cell
 53 | 2. Select the current output (leftmost) tab (if output tabs exist)
 54 | 3. Click the pin button in the output prompt area
 55 | 
 56 | ![pin button demo](./lc_multi_outputs/nbextension/demo-pin-button.gif)
 57 | 
 58 | ## Execution status color of code cell
 59 | 
 60 | The prompt area of code cell displays execution status with colors.
 61 | The colors mean as follows:
 62 | 
 63 | - White: Not Executed
 64 | - Light cyan: Awaiting Execution
 65 | - Green: Successfully Executed
 66 | - Pink: Failed
 67 | 
 68 | ## Diff dialog
 69 | 
 70 | You can compare pinned output with current output.
 71 | 
 72 | 1. Select the pinned output tab you want to compare with current output
 73 | 2. Click the diff button in the output prompt area
 74 | 
 75 | You can search keyword from the outputs compared in the diff dialog.
 76 | To search, input keyword to the search field and press the Enter key.
 77 | 
 78 | ![diff dialog demo](./lc_multi_outputs/nbextension/demo-diff-dialog.gif)
 79 | 
 80 | # Internals
 81 | 
 82 | The pinned outputs are saved as cell metadata.
 83 | 
 84 | This is an example of a code cell
 85 | ```
 86 | {
 87 |  "cell_type": "code",
 88 |  "execution_count": 2,
 89 |  "metadata": {
 90 |   "pinned_outputs": [
 91 |    {
 92 |     "execution_count": 1,
 93 |     "outputs": [
 94 |      {
 95 |       "data": {
 96 |        "text/plain": "'2017/10/12 13:36:42'"
 97 |       },
 98 |       "execution_count": 1,
 99 |       "metadata": {},
100 |       "output_type": "execute_result"
101 |      }
102 |     ]
103 |    }
104 |   ]
105 |  },
106 |  "outputs": [
107 |   {
108 |    "data": {
109 |     "text/plain": [
110 |      "'2017/10/12 13:36:49'"
111 |     ]
112 |    },
113 |    "execution_count": 2,
114 |    "metadata": {},
115 |    "output_type": "execute_result"
116 |   }
117 |  ],
118 |  "source": [
119 |   "from datetime import datetime\n",
120 |   "datetime.now().strftime('%Y/%m/%d %H:%M:%S')"
121 |  ]
122 | }
123 | ```
124 | 
125 | # License
126 | 
127 | This project is licensed under the terms of the Modified BSD License (also known as New or Revised or 3-Clause BSD), see LICENSE.txt.
128 | 


--------------------------------------------------------------------------------
/lc_multi_outputs/nbextension/main.css:
--------------------------------------------------------------------------------
  1 | .output_wrapper .out_prompt_bg {
  2 |     padding: 0px 0.4em;
  3 |     position: absolute;
  4 |     border-radius: 2px;
  5 |     z-index: -1;
  6 | }
  7 | 
  8 | .multi-output-tabs ul.nav-tabs {
  9 |     overflow-x: auto;
 10 |     overflow-y: hidden;
 11 |     padding: 0.4em 0.4em 0px 0.4em;
 12 |     -webkit-box-flex: 1;
 13 |     -moz-box-flex: 1;
 14 |     box-flex: 1;
 15 |     flex: 1;
 16 | }
 17 | 
 18 | .multi-outputs-ui,.multi-outputs-diff-ui {
 19 |     text-align: left;
 20 |     padding-top: 2px;
 21 |     display: block;
 22 | }
 23 | 
 24 | .multi-outputs-ui .buttons,.multi-outputs-diff-ui .buttons {
 25 |     display: inline-block;
 26 | }
 27 | 
 28 | .multi-outputs-ui .btn,.multi-outputs-diff-ui .btn {
 29 |     padding: 0px;
 30 |     font-size: 90%;
 31 | }
 32 | 
 33 | .multi-outputs-ui .btn-default,.multi-outputs-diff-ui .btn-default {
 34 |     background-color: transparent;
 35 |     border-color: transparent;
 36 | }
 37 | 
 38 | .multi-outputs-ui .btn-default:hover,.multi-outputs-diff-ui .btn-default:hover {
 39 |     background-color: #e6e6e6;
 40 |     border-color: #adadad;
 41 | }
 42 | 
 43 | .multi-output-container .output_subarea {
 44 |     font-size: 14px;
 45 | }
 46 | 
 47 | .multi-output-container .prompt {
 48 |     font-size: 14px;
 49 | }
 50 | 
 51 | .cell-status-success .input_prompt {
 52 |     background-color: #bcffbc;
 53 |     height: 100%;
 54 | }
 55 | 
 56 | .cell-status-success .multi-output-tabs .out_prompt_bg {
 57 |     background-color: #bcffbc;
 58 | }
 59 | 
 60 | .cell-status-success .output_wrapper .out_prompt_bg {
 61 |     background-color: #bcffbc;
 62 |     height: 100%;
 63 | }
 64 | 
 65 | .cell-status-error .input_prompt {
 66 |     background-color: #ffc0cb;
 67 |     height: 100%;
 68 | }
 69 | 
 70 | .cell-status-error .multi-output-tabs .out_prompt_bg {
 71 |     background-color: #ffc0cb;
 72 | }
 73 | 
 74 | .cell-status-error .output_wrapper .out_prompt_bg {
 75 |     background-color: #ffc0cb;
 76 |     height: 100%;
 77 | }
 78 | 
 79 | .cell-status-inqueue .input_prompt {
 80 |     background-color: #e0ffff;
 81 |     height: 100%;
 82 | }
 83 | 
 84 | .cell-status-inqueue .multi-output-tabs .out_prompt_bg {
 85 |     background-color: #e0ffff;
 86 | }
 87 | 
 88 | .cell-status-inqueue .output_wrapper .out_prompt_bg {
 89 |     background-color: #e0ffff;
 90 |     height: 100%;
 91 | }
 92 | 
 93 | .multi-output-container.ui-tabs {
 94 |     border: none;
 95 |     padding: 0px;
 96 | }
 97 | 
 98 | .multi-output-container .ui-tabs-panel {
 99 |     padding: 0px;
100 | }
101 | 
102 | .multi-output-tabs .ui-tabs-anchor {
103 |     font-size: 0.6em;
104 | }
105 | 
106 | .multi-output-tabs .ui-tabs-nav {
107 |     border-top: none;
108 |     border-left: none;
109 |     border-right: none;
110 |     border-bottom-left-radius: 0px;
111 |     border-bottom-right-radius: 0px;
112 |     background: transparent;
113 | }
114 | 
115 | .multi-output-tabs .ui-tabs-nav button.ui-button-icon-only {
116 |     border: none;
117 |     background: transparent;
118 | }
119 | 
120 | .multi-output-tabs li.ui-state-default {
121 |     background: #EEE !important;
122 | }
123 | 
124 | .multi-output-tabs li.ui-state-default a {
125 |     color: #AAA;
126 | }
127 | 
128 | .multi-output-tabs li.ui-state-active {
129 |     background: white !important;
130 | }
131 | 
132 | .multi-output-tabs li.ui-state-active a {
133 |     color: black;
134 | }
135 | 
136 | .multi-outputs-diff.ui-dialog-content {
137 |     overflow: hidden;
138 | }
139 | 
140 | .multi-outputs-diff .multi-outputs-search-bar {
141 |     margin: 1px;
142 |     padding: 1px;
143 |     width: 100%;
144 | }
145 | 
146 | .multi-outputs-diff .multi-outputs-search-bar .label {
147 |     color: black;
148 |     font-weight: bold;
149 |     font-size: 10px;
150 | }
151 | 
152 | .multi-outputs-diff .multi-outputs-search-bar input {
153 |     font-size: 10px;
154 |     width: 250px;
155 | }
156 | 
157 | .multi-outputs-diff .search-highlight {
158 |     background-color: #fe3;
159 | }
160 | 
161 | .ui-widget-header {
162 |     background: #e7e7e7;
163 | }
164 | 
165 | div.cell div.multi-output-container {
166 |     background: unset;
167 | }
168 | 
169 | .fa-pin-output:before {
170 |     content: "\f08d";
171 | }
172 | 
173 | .fa-pin-output:after {
174 |     content: "+";
175 | }
176 | 
177 | .fa-pin-remove-leaving-one:before {
178 |     content: "\f08d";
179 | }
180 | 
181 | .fa-pin-remove-leaving-one:after {
182 |     content: "1";
183 | }
184 | 


--------------------------------------------------------------------------------
/lc_multi_outputs/nbextension/main.js:
--------------------------------------------------------------------------------
  1 | require.config({
  2 |     map: {
  3 |         '*': {
  4 |             "diff_match_patch": "nbextensions/multi_outputs/lib/diff_match_patch"
  5 |         },
  6 |     },
  7 | });
  8 | 
  9 | define([
 10 |     'base/js/namespace',
 11 |     'jquery',
 12 |     'require',
 13 |     'base/js/events',
 14 |     'base/js/dialog',
 15 |     'services/config',
 16 |     'base/js/utils',
 17 |     'notebook/js/codecell',
 18 |     'notebook/js/outputarea',
 19 |     'codemirror/lib/codemirror',
 20 |     'codemirror/addon/merge/merge',
 21 |     'codemirror/addon/search/searchcursor',
 22 |     'codemirror/addon/scroll/annotatescrollbar',
 23 |     'codemirror/addon/search/matchesonscrollbar'
 24 | ], function(Jupyter, $, require, events, jsdialog, configmod, utils, codecell, outputarea, codemirror,
 25 |     merge, searchcursor, annotatescrollbar, matchesonscrollbar) {
 26 |     "use strict";
 27 | 
 28 |     var mod_name = 'MultiOutputs';
 29 |     var log_prefix = '[' + mod_name + ']';
 30 | 
 31 |     // defaults, overridden by server's config
 32 |     var options = {
 33 |         max_num_of_pinned_outputs: 5
 34 |     };
 35 | 
 36 |     function changeColor(first, cell, msg){
 37 |         var outback = cell.output_area.wrapper.find('.out_prompt_bg');
 38 |         var inback = $(cell.input[0].firstChild);
 39 | 
 40 |         cell.element.removeClass('cell-status-success');
 41 |         cell.element.removeClass('cell-status-error');
 42 |         cell.element.removeClass('cell-status-inqueue');
 43 | 
 44 |         if(first == true) {
 45 |             cell.element.addClass('cell-status-inqueue');
 46 |         } else {
 47 |             if (msg.content.status != "ok" && msg.content.status != "aborted") {
 48 |                 cell.element.addClass('cell-status-error');
 49 |             } else if (msg.content.status != "aborted") {
 50 |                 cell.element.addClass('cell-status-success');
 51 |             }
 52 |         }
 53 |     }
 54 | 
 55 |     function init_events() {
 56 |         events.on('create.Cell', function (e, data) {
 57 |             if (data.cell instanceof codecell.CodeCell) {
 58 |                 setTimeout(function() {
 59 |                     extend_cell(data.cell);
 60 |                 }, 0);
 61 |             }
 62 |         });
 63 |     }
 64 | 
 65 |     function extend_cell(cell) {
 66 |         var pinned_outputs = cell.metadata.pinned_outputs;
 67 |         if(pinned_outputs === undefined) {
 68 |             pinned_outputs = [];
 69 |         }
 70 |         if(cell.pinned_outputs === undefined) {
 71 |             cell.pinned_outputs = [];
 72 |         }
 73 | 
 74 |         if(pinned_outputs.length > 0) {
 75 |             create_multi_output_tabs(cell)
 76 |             for(var i=0; i<pinned_outputs.length; ++i) {
 77 |                 add_tab_outputarea(cell, pinned_outputs[i]);
 78 |             }
 79 |         }
 80 | 
 81 |         extend_prompt(cell, cell.output_area);
 82 |         create_pin_button(cell, cell.output_area);
 83 |         update_pin_button_status(cell.output_area);
 84 |     }
 85 | 
 86 |     function create_multi_output_tabs(cell)
 87 |     {
 88 |         var container = $('<div/>')
 89 |             .addClass('multi-output-container');
 90 |         var tabbar = $('<div/>')
 91 |             .addClass('multi-output-tabs')
 92 |             .addClass('output_area')
 93 |             .append($('<div/>')
 94 |                     .addClass('out_prompt_bg').addClass('prompt'))
 95 |             .appendTo(container);
 96 |         var tabs = $('<ul/>')
 97 |             .addClass('nav')
 98 |             .addClass('nav-tabs')
 99 |             .appendTo(tabbar);
100 | 
101 |         container.insertAfter(cell.element.find('.input'));
102 | 
103 |         tabs.append(
104 |             $('<li/>')
105 |                 .attr('id', 'tab-output-current')
106 |                 .append(
107 |                     $('<a/>').attr( { href: '#output-current'}).text('*')))
108 | 
109 |         var tab_output_wrapper = $('<div/>')
110 |             .addClass('multi-output-wrapper')
111 |             .attr('id', 'output-current');
112 | 
113 |         tab_output_wrapper.insertAfter(cell.element.find('div.multi-output-tabs'));
114 |         cell.output_area.wrapper.appendTo(tab_output_wrapper);
115 | 
116 |         container.tabs();
117 |     }
118 | 
119 |     function remove_multi_output_tabs(cell)
120 |     {
121 |         var container = cell.element.find('.multi-output-container');
122 | 
123 |         container.tabs("destroy");
124 |         cell.output_area.wrapper.insertAfter(cell.element.find('.input'));
125 |         container.remove();
126 |     }
127 | 
128 |     function add_tab_outputarea(cell, pinned_output_data)
129 |     {
130 |         var pinned_output_element = $('<div></div>')
131 |         var pinned_outputarea = new outputarea.OutputArea({
132 |             config: cell.config,
133 |             selector: pinned_output_element,
134 |             prompt_area: true,
135 |             events: cell.events,
136 |             keyboard_manager: cell.keyboard_manager,
137 |         });
138 |         var pinned_output = {
139 |             execution_count: pinned_output_data.execution_count,
140 |             outputarea: pinned_outputarea,
141 |         }
142 | 
143 |         var tab_container = cell.element.find('div.multi-output-container');
144 |         var tab_id = 'output-' + Date.now();
145 |         var tab_wrapper = $('<div/>')
146 |             .addClass('multi-output-wrapper')
147 |             .attr('id', tab_id)
148 |             .append(pinned_output_element)
149 |             .appendTo(tab_container);
150 | 
151 |         pinned_outputarea.tab_id = tab_id;
152 |         cell.pinned_outputs.push(pinned_outputarea);
153 | 
154 |         pinned_outputarea.trusted = cell.metadata.trusted || false;
155 |         pinned_outputarea.fromJSON(pinned_output_data.outputs);
156 | 
157 |         extend_prompt(cell, pinned_outputarea);
158 | 
159 |         create_diff_button(cell, pinned_output);
160 | 
161 |         var tab = create_tab(cell, pinned_output, tab_id);
162 |         tab.insertAfter(cell.element.find('div.multi-output-tabs ul.nav-tabs li#tab-output-current'));
163 | 
164 |         setTimeout(function() {
165 |             tab_container.tabs('refresh');
166 |         }, 0);
167 | 
168 |         return tab;
169 |     }
170 | 
171 |     function create_tab(cell, pinned_output, id)
172 |     {
173 |         var title = 'Out [' + pinned_output.execution_count + ']';
174 |         var tab = $('<li/>')
175 |             .attr('id', 'tab-' + id)
176 |             .append($('<button/>')
177 |                     .button({
178 |                         icons: { primary: 'ui-icon-circle-close' },
179 |                         text: null
180 |                     })
181 |                     .on('click', function() {
182 |                         remove_pinned_output(cell, pinned_output.outputarea);
183 |                     })).append($('<a/>').attr( { href: '#' + id }).text(title))
184 |         return tab;
185 |     }
186 | 
187 |     function extend_prompt(cell, output_area)
188 |     {
189 |         $('<div/>')
190 |             .addClass('out_prompt_bg')
191 |             .addClass('prompt')
192 |             .appendTo(output_area.wrapper);
193 |     }
194 | 
195 |     function create_pin_button(cell, output_area)
196 |     {
197 |         var container = $('<div/>')
198 |                     .addClass('multi-outputs-ui')
199 |                     .appendTo(output_area.wrapper.find('.out_prompt_overlay'));
200 | 
201 |         var btn = $('<div/>')
202 |                     .addClass('buttons')
203 |                     .append('<button class="btn btn-default"/>')
204 |                     .appendTo(container);
205 | 
206 |         var clickable = btn.find('button');
207 |         $('<i class="fa fa-fw fa-thumb-tack"/>').appendTo(clickable);
208 |         clickable.on('click', function (event) {
209 |             pin_output(cell);
210 |             return false;
211 |         });
212 |     }
213 | 
214 |     function create_diff_button(cell, pinned_output) {
215 |         var output_area = pinned_output.outputarea;
216 |         var container = $('<div/>')
217 |                     .addClass('multi-outputs-diff-ui')
218 |                     .appendTo(output_area.wrapper.find('.out_prompt_overlay'));
219 | 
220 |         var btn = $('<div/>')
221 |                     .addClass('buttons')
222 |                     .append('<button class="btn btn-default"/>')
223 |                     .appendTo(container);
224 | 
225 |         var clickable = btn.find('button');
226 |         $('<i class="fa fa-fw fa-exchange"/>').appendTo(clickable);
227 |         clickable.on('click', function (event) {
228 |             show_diff_dialog(cell, pinned_output);
229 |             return false;
230 |         });
231 |     }
232 | 
233 |     function update_pin_button_status(output_area) {
234 |         if(output_area.outputs.length == 0) {
235 |             output_area.wrapper.find('.multi-outputs-ui').css('display', 'none');
236 |         } else {
237 |             output_area.wrapper.find('.multi-outputs-ui').css('display', '');
238 |         }
239 |     }
240 | 
241 |     function pin_output(cell) {
242 |         if(cell.output_area.outputs.length == 0) {
243 |             return;
244 |         }
245 | 
246 |         if(cell.input_prompt_number === '*') {
247 |             return;
248 |         }
249 | 
250 |         if(cell.metadata.pinned_outputs === undefined) {
251 |             cell.metadata.pinned_outputs = [];
252 |         }
253 | 
254 |         var outputs_json = cell.output_area.toJSON();
255 |         var pinned_output = {
256 |             'execution_count': cell.input_prompt_number,
257 |             'outputs' : outputs_json
258 |         }
259 |         cell.metadata.pinned_outputs.push(pinned_output);
260 | 
261 |         if(cell.pinned_outputs.length == 0) {
262 |             create_multi_output_tabs(cell);
263 |         }
264 |         var tab = add_tab_outputarea(cell, pinned_output);
265 |         var tab_container = cell.element.find('div.multi-output-container');
266 |         setTimeout(function() {
267 |             tab_container.tabs("option", "active", 1);
268 |         }, 0);
269 | 
270 |         remove_old_pinned_outputs(cell);
271 | 
272 |         update_pin_button_status(cell.output_area);
273 | 
274 |         cell.events.trigger('set_dirty.Notebook', {value: true});
275 |     }
276 | 
277 |     function remove_old_pinned_outputs(cell, rest_num) {
278 |         var pinned_output_areas = cell.pinned_outputs;
279 | 
280 |         if (rest_num === undefined) {
281 |             rest_num = options.max_num_of_pinned_outputs;
282 |         }
283 | 
284 |         var max = Math.max(rest_num, 1);
285 |         while(pinned_output_areas.length > max) {
286 |             remove_pinned_output(cell, pinned_output_areas[0])
287 |         }
288 |     }
289 | 
290 |     function remove_pinned_output(cell, pinned_output_area) {
291 |         var index = cell.pinned_outputs.indexOf(pinned_output_area);
292 |         if (index < 0) {
293 |             return;
294 |         }
295 |         cell.pinned_outputs.splice(index, 1);
296 |         cell.metadata.pinned_outputs.splice(index, 1);
297 | 
298 |         var tab_id = pinned_output_area.tab_id;
299 |         cell.element.find('ul > li#tab-' + tab_id).remove();
300 |         cell.element.find('div#' + tab_id ).remove();
301 |         cell.element.find('div.multi-output-container').tabs('refresh');
302 | 
303 |         if(cell.pinned_outputs.length == 0) {
304 |             remove_multi_output_tabs(cell);
305 |         }
306 | 
307 |         cell.events.trigger('set_dirty.Notebook', {value: true});
308 |     }
309 | 
310 |     function get_cell_level(cell) {
311 |         var level = 7;
312 |         if (cell === undefined) {
313 |             return level;
314 |         }
315 |         if ((typeof(cell) === 'object')  && (cell.cell_type === 'markdown')) {
316 |             level = cell.get_text().match(/^#*/)[0].length || level;
317 |         }
318 |         return Math.min(level, 7);
319 |     }
320 | 
321 |     function is_heading(cell) {
322 |         return get_cell_level(cell) < 7;
323 |     }
324 | 
325 |     function get_section_cells(heading_cell)
326 |     {
327 |         var top_level = get_cell_level(heading_cell);
328 |         var cells = Jupyter.notebook.get_cells();
329 | 
330 |         var index = Jupyter.notebook.find_cell_index(heading_cell);
331 |         var section_cells = new Array();
332 |         for (var i=index+1; i<cells.length; ++i) {
333 |             var cell = cells[i];
334 |             var level = get_cell_level(cell);
335 |             if (level > top_level) {
336 |                 section_cells.push(cell);
337 |             } else if(level <= top_level) {
338 |                 break;
339 |             }
340 |         }
341 |         return section_cells;
342 |     }
343 | 
344 |     function find_heading_cell(cell) {
345 |         if (is_heading(cell)) {
346 |             return cell;
347 |         }
348 | 
349 |         var cells = cell.notebook.get_cells();
350 |         var index = cell.notebook.find_cell_index(cell);
351 |         if (index == 0) {
352 |             return null;
353 |         }
354 |         for (var i=index-1; i>=0; --i) {
355 |             if (is_heading(cells[i])) {
356 |                 return cells[i];
357 |             }
358 |         }
359 |         return null;
360 |     }
361 | 
362 |     function get_bellow_all_cells()
363 |     {
364 |         var index = Jupyter.notebook.get_selected_index();
365 |         var cells = [].concat(Jupyter.notebook.get_cells());
366 |         cells.splice(0, index);
367 |         return cells;
368 |     }
369 | 
370 |     function get_below_in_section_cells() {
371 |         var index = Jupyter.notebook.get_selected_index();
372 |         var cells = Jupyter.notebook.get_cells();
373 | 
374 |         var heading_cell = find_heading_cell(cells[index]);
375 |         var section;
376 |         if (heading_cell) {
377 |             section = get_section_cells(heading_cell);
378 |             section.splice(0, 0, heading_cell);
379 |         } else {
380 |             section = [];
381 |             var level = ch.get_cell_level(cells[index]);
382 |             for (var i=index; i<cells.length; ++i) {
383 |                 if (ch.get_cell_level(cells[i]) !== level) {
384 |                     break;
385 |                 }
386 |                 section.push(cells[i]);
387 |             }
388 |         }
389 | 
390 |         var section_cells = new Array();
391 |         var index_in_section = $.inArray(cells[index], section);
392 |         for (var i=index_in_section; i<section.length; ++i) {
393 |             section_cells.push(section[i]);
394 |         }
395 | 
396 |         return section_cells;
397 |     }
398 | 
399 |     function pin_output_cells(cells) {
400 |         for (var i = 0; i < cells.length; i++) {
401 |             if (cells[i] instanceof codecell.CodeCell) {
402 |                 pin_output(cells[i]);
403 |             }
404 |         }
405 |     }
406 | 
407 |     function pin_output_selected() {
408 |         var cells = Jupyter.notebook.get_selected_cells();
409 |         pin_output_cells(cells);
410 |     }
411 | 
412 |     function pin_output_below_in_section() {
413 |         var cells = get_below_in_section_cells();
414 |         pin_output_cells(cells);
415 |     }
416 | 
417 |     function pin_output_below_all() {
418 |         var cells = get_bellow_all_cells();
419 |         pin_output_cells(cells);
420 |     }
421 | 
422 |     function remove_pinned_outputs_leaving_one(cells) {
423 |         for (var i = 0; i < cells.length; i++) {
424 |             if (cells[i] instanceof codecell.CodeCell) {
425 |                 remove_old_pinned_outputs(cells[i], 1);
426 |             }
427 |         }
428 |     }
429 | 
430 |     function remove_pinned_outputs_leaving_one_selected() {
431 |         var cells = Jupyter.notebook.get_selected_cells();
432 |         remove_pinned_outputs_leaving_one(cells);
433 |     }
434 | 
435 |     function remove_pinned_outputs_leaving_one_below_in_section() {
436 |         var cells = get_below_in_section_cells();
437 |         remove_pinned_outputs_leaving_one(cells);
438 |     }
439 | 
440 |     function remove_pinned_outputs_leaving_one_below_all() {
441 |         var cells = get_bellow_all_cells();
442 |         remove_pinned_outputs_leaving_one(cells);
443 |     }
444 | 
445 |     function get_output_text(output_area) {
446 |         var outputs = output_area.outputs;
447 |         var texts = new Array();
448 |         for(var i=0; i < outputs.length; ++i) {
449 |             if (outputs[i].data && outputs[i].data['text/plain']) {
450 |                 texts.push(outputs[i].data['text/plain']);
451 |             } else if (outputs[i].output_type == 'stream') {
452 |                 texts.push(outputs[i].text);
453 |             } else if (outputs[i].output_type == 'error') {
454 |                 texts.push(outputs[i].traceback.join('\n'));
455 |             }
456 |         }
457 |         return texts.join('\n');
458 |     }
459 | 
460 |     function mark_text(editor, query, searchCursor)
461 |     {
462 |         var searchCursor = editor.getSearchCursor(query, 0, false);
463 | 
464 |         var marks = editor.getAllMarks();
465 |         for (var i=0; i<marks.length; ++i) {
466 |             marks[i].clear();
467 |         }
468 |         if(editor.scrollBarAnnotation) {
469 |             editor.scrollBarAnnotation.clear();
470 |         }
471 | 
472 |         var options = {className: 'search-highlight'};
473 |         while(searchCursor.findNext()) {
474 |             editor.markText(
475 |                 searchCursor.from(), searchCursor.to(),
476 |                 options);
477 |         }
478 |         editor.scrollBarAnnotation = editor.showMatchesOnScrollbar(query, false, options);
479 |     }
480 | 
481 |     function show_diff_dialog(cell, pinned_output) {
482 |         var value = get_output_text(cell.output_area);
483 |         var orig = get_output_text(pinned_output.outputarea);
484 |         if(value === "" && orig === "") {
485 |             return;
486 |         }
487 | 
488 |         var number = cell.input_prompt_number;
489 |         var orig_number = pinned_output.execution_count;
490 | 
491 |         var dv;
492 |         var content = $('<div/>').addClass('multi-outputs-diff');
493 |         var searchbar = $('<div/>').addClass('multi-outputs-search-bar');
494 |         $('<span/>').addClass('label').text('Search').appendTo(searchbar);
495 |         var input = $('<input/>').attr('type', 'text').appendTo(searchbar);
496 |         input.keydown(function(event, ui) {
497 |             event.stopPropagation();
498 |             return true;
499 |         });
500 |         input.change(function(event, ui) {
501 |             var text = input.val();
502 |             mark_text(dv.edit, text);
503 |             mark_text(dv.right.orig, text);
504 |         });
505 | 
506 |         var dialogResized = function (event, ui) {
507 |             content.css('width', '');
508 |             var dialog = content.parent();
509 |             var titlebar = dialog.find('.ui-dialog-titlebar');
510 |             var height = dialog.height() - titlebar.outerHeight();
511 |             content.css('height', height + 'px');
512 |             var merge = content.find('.CodeMirror-merge');
513 |             var mergeHeight = content.height() - searchbar.outerHeight();
514 |             merge.css('height', mergeHeight + 'px');
515 |             dv.edit.setSize(null, merge.height() + 'px');
516 |             dv.right.orig.setSize(null, merge.height() + 'px');
517 |             dv.right.forceUpdate();
518 |         }
519 | 
520 |         content.dialog({
521 |             open: function(event, ui) {
522 |                 dv = codemirror.MergeView(content.get(0), {
523 |                     value: value,
524 |                     orig: orig,
525 |                     lineNumbers: true,
526 |                     mode: "text/plain",
527 |                     highlightDifferences: true,
528 |                     revertButtons: false,
529 |                     lineWrapping: true
530 |                 });
531 |                 searchbar.appendTo(content);
532 |                 dialogResized();
533 |             },
534 |             close: function(event, ui) {
535 |                 content.dialog("destroy");
536 |             },
537 |             resize: dialogResized,
538 |             resizeStop: dialogResized,
539 |             title: "Diff: Out[" + number + "] <- Out[" + orig_number + "]",
540 |             minWidth: 500,
541 |             minHeight: 400,
542 |             width: 500,
543 |             height: 400,
544 |         });
545 |     }
546 | 
547 |     /* Load additional CSS */
548 |     var load_css = function (name) {
549 |         var link = document.createElement("link");
550 |         link.type = "text/css";
551 |         link.rel = "stylesheet";
552 |         link.href = require.toUrl(name, 'css');
553 |         document.getElementsByTagName("head")[0].appendChild(link);
554 |     };
555 | 
556 |     var load_extension = function() {
557 |         load_css('./main.css');
558 |         load_css('codemirror/addon/merge/merge.css');
559 |         load_css('codemirror/addon/search/matchesonscrollbar.css');
560 |     };
561 | 
562 |     function patch_CodeCell_get_callbacks() {
563 |         console.log('[multi_outputs] patching CodeCell.prototype.get_callbacks');
564 |         var previous_get_callbacks = codecell.CodeCell.prototype.get_callbacks;
565 |         codecell.CodeCell.prototype.get_callbacks = function() {
566 |             var that = this;
567 |             var callbacks = previous_get_callbacks.apply(this, arguments);
568 |             var prev_iopub_output_callback = callbacks.iopub.output;
569 |             callbacks.iopub.output = function(msg) {
570 |                 prev_iopub_output_callback(msg);
571 |                 update_pin_button_status(that.output_area);
572 |             }
573 |             var prev_iopub_clear_output_callback = callbacks.iopub.clear_output;
574 |             callbacks.iopub.clear_output = function(msg) {
575 |                 prev_iopub_clear_output_callback(msg);
576 |                 update_pin_button_status(that.output_area);
577 |             }
578 |             return callbacks;
579 |         };
580 |     }
581 | 
582 |     function patch_CodeCell_clear_output() {
583 |         console.log('[multi_outputs] patching CodeCell.prototype.clear_output');
584 |         var previous_clear_output = codecell.CodeCell.prototype.clear_output;
585 |         codecell.CodeCell.prototype.clear_output = function(wait) {
586 |             previous_clear_output.apply(this, arguments);
587 |             update_pin_button_status(this.output_area);
588 |         }
589 |     }
590 | 
591 |     function patch_CodeCell_handle_execute_reply() {
592 |         console.log('[multi_outputs] patching CodeCell.prototype._handle_execute_reply');
593 |         var previous_handle_execute_reply = codecell.CodeCell.prototype._handle_execute_reply;
594 |         codecell.CodeCell.prototype._handle_execute_reply = function (msg) {
595 |             changeColor(false, this, msg);
596 |             previous_handle_execute_reply.apply(this, arguments);
597 |         };
598 |     }
599 | 
600 |     function register_toolbar_buttons() {
601 |         var buttons = [];
602 | 
603 |         buttons.push(Jupyter.keyboard_manager.actions.register({
604 |             help : 'pin selected cells\' output',
605 |             icon : 'fa-pin-output',
606 |             handler : pin_output_selected,
607 |         }, 'pin_output', mod_name));
608 |         Jupyter.keyboard_manager.actions.register({
609 |             help : 'pin outputs below in section',
610 |             handler : pin_output_below_in_section,
611 |         }, 'pin_output_below_in_section', mod_name);
612 |         Jupyter.keyboard_manager.actions.register({
613 |             help : 'pin outputs below all',
614 |             handler : pin_output_below_all,
615 |         }, 'pin_output_below_all', mod_name);
616 | 
617 |         buttons.push(Jupyter.keyboard_manager.actions.register({
618 |             help : 'remove pinned outputs of selected cells leaving the leftmost one',
619 |             icon : 'fa-pin-remove-leaving-one',
620 |             handler : remove_pinned_outputs_leaving_one_selected,
621 |         }, 'pin_remove_leaving_one', mod_name));
622 |         Jupyter.keyboard_manager.actions.register({
623 |             help : 'remove pinned outputs leaving the leftmost one (cells below in the section)',
624 |             handler : remove_pinned_outputs_leaving_one_below_in_section,
625 |         }, 'pin_remove_leaving_one_below_in_section', mod_name);
626 |         Jupyter.keyboard_manager.actions.register({
627 |             help : 'remove pinned outputs leaving the leftmost one (cells below all)',
628 |             handler : remove_pinned_outputs_leaving_one_below_all,
629 |         }, 'pin_remove_leaving_one_below_all', mod_name);
630 | 
631 |         Jupyter.toolbar.add_buttons_group(buttons);
632 |     }
633 | 
634 |     var multi_outputs = function() {
635 |         load_extension();
636 |         register_toolbar_buttons();
637 |         patch_CodeCell_get_callbacks();
638 |         patch_CodeCell_clear_output();
639 |         patch_CodeCell_handle_execute_reply();
640 | 
641 |         var original_codecell_execute = codecell.CodeCell.prototype.execute;
642 |         codecell.CodeCell.prototype.execute = function (stop_on_error) {
643 |             // For Freeze extension
644 |             if (!(this.metadata.run_through_control === undefined) && this.metadata.run_through_control.frozen) {
645 |                 console.log("Can't execute cell since cell is frozen.");
646 |                 return;
647 |             }
648 | 
649 |             if (!this.kernel) {
650 |                 console.log("Can't execute cell since kernel is not set.");
651 |                 return;
652 |             }
653 | 
654 |             if (stop_on_error === undefined) {
655 |                 stop_on_error = true;
656 |             }
657 | 
658 |             this.clear_output(false, true);
659 |             var old_msg_id = this.last_msg_id;
660 |             if (old_msg_id) {
661 |                 this.kernel.clear_callbacks_for_msg(old_msg_id);
662 |                 delete codecell.CodeCell.msg_cells[old_msg_id];
663 |                 this.last_msg_id = null;
664 |             }
665 |             if (this.get_text().trim().length === 0) {
666 |                 // nothing to do
667 |                 this.set_input_prompt(null);
668 |                 return;
669 |             }
670 | 
671 |             var output_json = this.output_area.outputs[this.output_area.outputs.length-1];
672 |             this.set_input_prompt('*');
673 |             this.element.addClass("running");
674 | 
675 |             changeColor(true, this);
676 | 
677 |             this.element.find('div.multi-output-container').tabs("option", "active", 0);
678 | 
679 |             var callbacks = this.get_callbacks();
680 | 
681 |             var options = {silent: false, store_history: true, stop_on_error : stop_on_error};
682 |             var data = {
683 |                 "lc_cell_data" : {
684 |                     "lc_cell_meme" : this.metadata.lc_cell_meme
685 |                 },
686 |                 "lc_notebook_data" : {
687 |                     "lc_notebook_meme": this.notebook.metadata.lc_notebook_meme,
688 |                     "notebook_path": this.notebook.notebook_path
689 |                 }
690 |             };
691 |             $.extend(true, options, data);
692 | 
693 |             this.last_msg_id = this.kernel.execute(this.get_text(), callbacks, options);
694 |             codecell.CodeCell.msg_cells[this.last_msg_id] = this;
695 |             this.render();
696 |             this.events.trigger('execute.CodeCell', {cell: this});
697 |         };
698 | 
699 |         /**
700 |         * execute this extension on load
701 |         */
702 |         var on_notebook_loaded = function() {
703 |             Jupyter.notebook.get_cells().forEach( function(cell, index, array) {
704 |                 if (cell instanceof codecell.CodeCell) {
705 |                     extend_cell(cell);
706 |                 }
707 |             });
708 |             init_events();
709 |         };
710 | 
711 |         Jupyter.notebook.config.loaded.then(function on_config_loaded () {
712 |             $.extend(true, options, Jupyter.notebook.config.data[mod_name]);
713 |         }, function on_config_load_error (reason) {
714 |             console.warn(log_prefix, 'Using defaults after error loading config:', reason);
715 |         }).then(function do_stuff_with_config () {
716 |             events.on("notebook_loaded.Notebook", on_notebook_loaded);
717 |             if (Jupyter.notebook !== undefined && Jupyter.notebook._fully_loaded) {
718 |                 on_notebook_loaded();
719 |             }
720 |         }).catch(function on_error (reason) {
721 |             console.error(log_prefix, 'Error:', reason);
722 |         });
723 |     };
724 | 
725 |     return {
726 |         load_ipython_extension : multi_outputs,
727 |         load_jupyter_extension : multi_outputs
728 |     };
729 | });
730 | 


--------------------------------------------------------------------------------