oxjs/source/Ox.UI/js/Video/Ox.VideoEditor.js

// vim: et:ts=4:sw=4:sts=4:ft=javascript

/*@
Ox.VideoEditor <f:Ox.Element> VideoEditor Object
    () ->              <f> VideoEditor Object
    (options) ->       <f> VideoEditor Object
    (options, self) -> <f> VideoEditor Object
    options <o> Options object
    self    <o> shared private variable
@*/

// fixme: should be VideoAnnotationEditor

Ox.VideoEditor = function(options, self) {

    self = self || {};
    var that = Ox.Element({}, self)
            .defaults({
                annotationsSize: 0,
                censored: [],
                cuts: [],
                duration: 0,
                find: '',
                fps: 25,
                getFrameURL: null,
                getLargeTimelineImageURL: null,
                getSmallTimelineImageURL: null,
                'in': 0,
				height: 0,
                layers: [],
                out: 0,
                position: 0,
                posterFrame: 0,
                showAnnotations: false,
                showLargeTimeline: true,
                subtitles: [],
                tooltips: false,
                videoRatio: 16/9,
                videoSize: 'small',
                video: '',
                width: 0
            })
            .options(options || {})
            .mousedown(function() {
                that.gainFocus();
            })
            .bindEvent({
                key_0: toggleMuted,
                key_shift_0: function() {
                    movePositionBy(-self.options.position);
                },
                key_alt_left: function() {
                },
                key_alt_right: function() {
                },
                key_alt_shift_left: function() {
                },
                key_alt_shift_right: function() {
                },
                key_backslash: function() {
                    select('subtitle');
                },
                key_closebracket: function() {
                    movePositionTo('subtitle', 1);
                },
                key_comma: function() {
                    movePositionTo('cut', -1);
                },
                key_dot: function() {
                    movePositionTo('cut', 1);
                },
                key_down: function() {
                    movePositionBy(self.sizes.timeline[0].width);
                },
                key_f: function() {
                    setTimeout(function() {
                        self.$findInput.focusInput();
                    });
                },
                key_g: function() {
                    self.results.length && setPosition(getNextPosition('result', 1));
                },
                key_i: function() {
                    setPoint('in', self.options.position);
                },
                key_left: function() {
                    movePositionBy(-0.04);
                },
                key_o: function() {
                    setPoint('out', self.options.position);
                },
                key_openbracket: function() {
                    movePositionTo('subtitle', -1);
                },
                key_p: playInToOut,
                key_right: function() {
                    movePositionBy(0.04);
                },
                key_s: function() {
                    // toggleSize
                },
                key_shift_comma: function() {
                    movePositionTo('match', -1);
                },
                key_shift_dot: function() {
                    movePositionTo('match', 1);
                },
                key_shift_down: function() {
                    movePositionBy(self.options.duration);
                },
                key_shift_g: function() {
                    self.results.length && setPosition(getNextPosition('result', -1));
                },
                key_shift_left: function() {
                    movePositionBy(-1);
                },
                key_shift_i: function() {
                    goToPoint('in');
                },
                key_shift_o: function() {
                    goToPoint('out');
                },
                key_shift_p: function() {
                    // go to poster frame
                },
                key_shift_right: function() {
                    movePositionBy(1);
                },
                key_shift_up: function() {
                    movePositionBy(-self.options.position);
                },
                key_slash: function() {
                    select('cut');
                },
                key_space: togglePaused,
                key_up: function() {
                    movePositionBy(-self.sizes.timeline[0].width);
                }
            });

    Ox.extend(self, {
        $player: [],
        $timeline: [],
        controlsHeight: 16,
        margin: 8,
    });

    self.words = [];
    Ox.forEach(Ox.count(Ox.words(self.options.subtitles.map(function(subtitle) {
        return subtitle.text;
    }).join(' '))), function(count, word) {
        self.words.push({count: count, word: word});
    });
    self.words = self.words.sort(function(a, b) {
        return b.count - a.count;
    }).map(function(obj) {
        return obj.word;
    });

    self.$editor = Ox.Element()
        .addClass('OxVideoEditor')
        .click(function(e) {
            var $target = $(e.target);
            !$target.is('.OxPosition') && !$target.is('input') && that.gainFocus();
        });

    self.sizes = getSizes();

    ['play', 'in', 'out'].forEach(function(type, i) {
        self.$player[i] = Ox.VideoPlayer({
                censored: self.options.censored,
                controlsBottom: type == 'play' ?
                    ['play', 'playInToOut', 'volume', 'size', 'space', 'position'] :
                    ['goto', 'set', 'space', 'position'],
                duration: self.options.duration,
                enableMouse: true,
                externalControls: true,
                find: self.options.find,
                height: self.sizes.player[i].height,
                id: 'player' + Ox.toTitleCase(type),
                'in': self.options['in'],
                out: self.options.out,
                paused: true,
                position: type == 'play' ? self.options.position : self.options[type],
                posterFrame: self.options.posterFrame,
                showMarkers: true,
                showMilliseconds: 3,
                sizeIsLarge: self.options.videoSize == 'large',
                subtitles: self.options.subtitles,
                type: type,
                video: type == 'play' ? self.options.video : self.options.getFrameURL,
                width: self.sizes.player[i].width
            })
            .css({
                left: self.sizes.player[i].left + 'px',
                top: self.sizes.player[i].top + 'px'
            })
            .bindEvent(type == 'play' ? {
                position: changePlayer,
                size: toggleSize
            } : {
                gotopoint: function() {
                    goToPoint(type);
                },
                position: function(data) {
                    setPoint(type, data.position);
                },
                setpoint: function() {
                    setPoint(type, self.options.position);
                }
            })
            .appendTo(self.$editor);
    });

    self.$timeline[0] = Ox.LargeVideoTimeline({
            cuts: self.options.cuts,
            duration: self.options.duration,
            find: self.options.find,
            getImageURL: self.options.getLargeTimelineImageURL,
            id: 'timelineLarge',
            'in': self.options['in'],
            //matches: self.options.matches,
            out: self.options.out,
            position: self.options.position,
            subtitles: self.options.subtitles,
            type: 'editor',
            width: self.sizes.timeline[0].width
        })
        .css({
            left: self.sizes.timeline[0].left + 'px',
            top: self.sizes.timeline[0].top + 'px'
        })
        .bindEvent({
            position: changeTimelineLarge
        })
        .appendTo(self.$editor);

    self.$timeline[1] = Ox.BlockVideoTimeline({
            cuts: self.options.cuts,
            duration: self.options.duration,
            find: self.options.find,
            getImageURL: self.options.getSmallTimelineImageURL,
            id: 'timelineSmall',
            'in': self.options['in'],
            out: self.options.out,
            position: self.options.position,
            results: find(self.options.find),
            showPointMarkers: true,
            showSubtitles: true,
            subtitles: self.options.subtitles,
            videoId: self.options.videoId,
            width: self.sizes.timeline[1].width
        })
        .css({
            left: self.sizes.timeline[1].left + 'px',
            top: self.sizes.timeline[1].top + 'px',
        })
        .bindEvent({
            position: changeTimelineSmall
        })
        .appendTo(self.$editor);

    self.$annotations = Ox.Element()
        .css({
            overflowY: 'auto'
        });
    self.$annotationPanel = [];

    self.options.layers.forEach(function(layer, i) {
        self.$annotationPanel[i] = Ox.AnnotationPanel(
                Ox.extend({
                    width: self.options.annotationsSize - Ox.UI.SCROLLBAR_SIZE
                }, layer)
            )
            .bindEvent({
                add: function(data) {
                    data.layer = layer.id; 
                    data['in'] = self.options['in'];
                    data.out = self.options.out;
                    that.triggerEvent('addannotation', data);
                },
                remove: function(data) {
                    data = {
                        ids: [data],
                        layer: layer.id
                    };
                    that.triggerEvent('removeannotations', data);
                },
                select: function(data) {
                    self.options.layers.forEach(function(l, j) { // fixme: l? j?
                        if(l.id != layer.id) {
                            self.$annotationPanel[j].deselectItems();
                        }
                    });
                    selectAnnotation(data);
                },
                submit: updateAnnotation
            });
        self.$annotationPanel[i]
            .appendTo(self.$annotations);
    });

    self.$videobar = Ox.Bar({
        size: 16
    }).addClass('OxVideoPlayer');

    self.resolutions = [];
    Ox.forEach(self.options.video, function(url, resolution) {
        Ox.print(url, resolution)
        self.resolutions.push(
            {id: resolution + '', title: resolution + 'p'}
        );
    });

    self.$keyboardShortcuts = $('<div>');
    [
        {key: Ox.UI.symbols.space, action: 'Play/Pause'},
        {key: 'P', action: 'Play In to Out'},
        {key: '0', action: 'Mute/Unmute'},
        {key: '-', action: 'Turn Volume Down'},
        {key: '+', action: 'Turn Volume Up'},
        {key: Ox.UI.symbols.arrow_left, action: 'Go One Frame Back'},
        {key: Ox.UI.symbols.arrow_right, action: 'Go One Frame Forward'},
        {key: Ox.UI.symbols.shift + Ox.UI.symbols.arrow_left, action: 'Go One Second Back'},
        {key: Ox.UI.symbols.shift + Ox.UI.symbols.arrow_right, action: 'Go One Second Forward'},
        {key: Ox.UI.symbols.arrow_up, action: 'Go One Line Up'},
        {key: Ox.UI.symbols.arrow_down, action: 'Go One Line Down'},
        {key: Ox.UI.symbols.shift + Ox.UI.symbols.arrow_up, action: 'Go to First Frame'},
        {key: Ox.UI.symbols.shift + Ox.UI.symbols.arrow_down, action: 'Go to Last Frame'},
        {key: 'I', action: 'Set In Point'},
        {key: 'O', action: 'Set Out Point'},
        {key: Ox.UI.symbols.shift + 'I', action: 'Go to Out Point'},
        {key: Ox.UI.symbols.shift + 'O', action: 'Go to Out Point'},
        {key: '[', action: 'Go to Previous Annotation'},
        {key: ']', action: 'Go to Next Annotation'},
        {key: '\\', action: 'Select Current Annotation'},
        {key: '<', action: 'Go to Previous Cut'},
        {key: '>', action: 'Go to Next Cut'},
        {key: '/', action: 'Select Current Cut'},
        {key: 'F', action: 'Find'},
        {key: Ox.UI.symbols.shift + 'G', action: 'Go to Previous Result'},
        {key: 'G', action: 'Go to Next Result'},
        {key: 'S', action: 'Select Current Annotation'},
        {key: 'E', action: 'Edit Selected Annotation'},
        {key: Ox.UI.symbols['return'], action: 'Submit'},
        {key: Ox.UI.symbols.escape, action: 'Cancel'},
    ].forEach(function(shortcut) {
        self.$keyboardShortcuts.append(
            $('<div>').css({display: 'table-row'})
                .append(
                    $('<div>').css({
                        display: 'table-cell',
                        height: '16px',
                        paddingRight: '16px',
                        //fontWeight: 'bold',
                        textAlign: 'right'
                    })
                    .html(shortcut.key)
                )
                .append(
                    $('<div>').css({display: 'table-cell'})
                        .html(shortcut.action)
                )
        );
    });

    self.$videoMenuButton = Ox.Select({
            items: Ox.merge(
                [
                    {id: 'toggleSize', title: 'Large Player', selected: self.options.playerSize == 'large', keyboard: 'shift +'},
                    {}
                ],
                self.resolutions,
                [
                    {},
                    {id: 'largeTimeline', title: 'Hide Large Timeline'},
                    {id: 'subtitlesTimeline', title: 'Hide Subtitles on Large Timeline'},
                    {},
                    {id: 'linkSelection', title: 'Link to Selection...'},
                    {id: 'embed', title: 'Embed Selection...'},
                    {id: 'downloadSelection', title: 'Download Selection...'},
                    {},
                    {id: 'keyboard', title: 'Keyboard Shortcuts...', keyboard: 'h'}
                ]
            ),
            selectable: false,
            title: $('<img>').attr({
                src: Ox.UI.getImageURL('symbolSet')
            }),
            tooltip: 'Actions and Settings',
            type: 'image'
        })
        .css({float: 'left'})
        .bindEvent({
            click: function(data) {
                var id = data.id;
                if (id == 'toggleSize') {
                    toggleSize();
                } else if (id == 'keyboard') {
                    var dialog = Ox.Dialog({
                        buttons: [
                            Ox.Button({id: 'close', title: 'Close'})
                                .bindEvent({click: function() { dialog.close(); }})
                        ],
                        content: self.$keyboardShortcuts,
                        height: 384,
                        keys: {enter: 'close', escape: 'close'},
                        title: 'Keyboard Shortcuts',
                        width: 256
                    }).open();
                }
            }
        })
        .appendTo(self.$videobar);
    self.$videoMenuButton.find('input').attr({
        src: Ox.UI.getImageURL('symbolSet')
    });

    self.$selectButton = Ox.Button({
            style: 'symbol',
            title: 'select',
            type: 'image'
        })
        .css({float: 'left'})
        .bindEvent({
            click: function() {
                self.$menuButton.find('input').trigger('click')
            }
        });
        //.appendTo(self.$videobar);


    self.$resolutionSelect = Ox.Select({
            items: [{id: '96', title: '96p'},{id: '240', title: '240p'}],//self.resolutions,
            width: 48
        })
        .css({float: 'left'})
        .bindEvent({
            change: function() {

            }
        });
        //.appendTo(self.$videobar);
    

    //$('<div>').css({float: 'left', width: '8px', height: '1px'}).appendTo(self.$videobar.$element);

    self.$goToPosterButton = Ox.Button({
            style: 'symbol',
            title: 'goToPoster',
            tooltip: 'Go to Poster Frame',
            type: 'image'
        })
        .css({float: 'left'})
        .bindEvent({
            click: function() {
                setPosition(self.options.posterFrame);
            }
        })
        .appendTo(self.$videobar);

    self.$setPosterButton = Ox.Button({
            disabled: true,
            style: 'symbol',
            title: 'setPoster',
            tooltip: 'Set Poster Frame',
            type: 'image'
        })
        .css({float: 'left'})
        .bindEvent({
            click: function() {
                self.$goToPosterButton.toggleDisabled();
                self.$setPosterButton.toggleDisabled();
                self.$unlockPosterButton.toggleTitle();
            }
        })
        .appendTo(self.$videobar);

    self.$unlockPosterButton = Ox.Button({
            style: 'symbol',
            title: [
                {id: 'lock', title: 'lock'},
                {id: 'unlock', title: 'unlock', selected: true}
            ],
            tooltip: ['Lock Poster Frame', 'Unlock Poster Frame'],
            type: 'image'
        })
        .css({float: 'left'})
        .bindEvent({
            click: function() {
                self.$setPosterButton.toggleDisabled();
            }
        })
        .appendTo(self.$videobar);

    self.$clearButton = Ox.Button({
            disabled: self.options.find === '',
            style: 'symbol',
            title: 'close',
            tooltip: 'Clear',
            type: 'image'
        })
        .css({float: 'right'})
        .bindEvent({
            click: function() {
                self.$findInput.clearInput();
                submitFindInput('');
            }
        })
        .appendTo(self.$videobar);

    self.$findInput = Ox.Input({
            autocomplete: self.words,
            autocompleteReplace: true,
            autocompleteSelect: true,
            autocompleteSelectHighlight: true,
            autocompleteSelectMax: 10,
            autocompleteSelectSubmit: true,
            changeOnKeypress: true,
            placeholder: 'Find...',
            value: self.options.find,
            width: 96
        })
        .css({float: 'right', background: 'transparent'})
        .bindEvent({
            change: function(data) {
                submitFindInput(data.value, false);
            },
            submit: function(data) {
                submitFindInput(data.value, true);
            }
        })
        .appendTo(self.$videobar);
    self.$findInput.find('input').css({background: 'rgb(48, 48, 48)'});

    self.$findButton = Ox.Button({
            //disabled: true,
            style: 'symbol',
            title: 'find',
            tooltip: 'Find',
            type: 'image'
        })
        .css({float: 'right'})
        .bindEvent({
            click: function() {

            }
        });
        //.appendTo(self.$videobar);

    self.$nextButton = Ox.Button({
            disabled: true,
            style: 'symbol',
            title: 'arrowRight',
            tooltip: 'Next Result',
            type: 'image'
        })
        .css({float: 'right'})
        .bindEvent({
            click: function() {
                setPosition(getNextPosition('result', 1));
            }
        })
        .appendTo(self.$videobar);

    self.$previousButton = Ox.Button({
            disabled: true,
            style: 'symbol',
            title: 'arrowLeft',
            tooltip: 'Previous Result',
            type: 'image'
        })
        .css({float: 'right'})
        .bindEvent({
            click: function() {
                setPosition(getNextPosition('result', -1));
            }
        })
        .appendTo(self.$videobar);

    self.$results = $('<div>')
        .css({float: 'right', width: '36px', padding: '2px 4px 0 0', fontSize: '9px', textAlign: 'right', cursor: 'default', opacity: 0.25})
        .html('0')
        .appendTo(self.$videobar.$element);

    self.$annotationsbar = Ox.Bar({
        size: 16
    }).addClass('OxVideoPlayer');

    self.$annotationsMenuButton = Ox.Select({
            items: [
                {id: 'annotations', title: 'Show Annotations', disabled: true},
                {id: 'showAnnotationsAtPosition', title: 'At Current Position', checked: true},
                {id: 'showAnnotationsInSelection', title: 'In Current Selection'},
                {id: 'showAllAnnotations', title: 'All'},
                {},
                {id: 'textSize', title: 'Font Size', disabled: true},
                {id: 'smallText', title: 'Small', checked: true},
                {id: 'mediumText', title: 'Medium'},
                {id: 'largeText', title: 'Large'}
            
            ],
            max: 2,
            title: $('<img>').attr({
                src: Ox.UI.getImageURL('symbolSet')
            }),
            tooltip: 'Actions and Settings',
            type: 'image'
        })
        .css({float: 'left'})
        .appendTo(self.$annotationsbar);
    self.$annotationsMenuButton.find('input').attr({
        src: Ox.UI.getImageURL('symbolSet')
    });

    that.$element = Ox.SplitPanel({
        elements: [
            {
                element: Ox.SplitPanel({
                    elements: [
                        {
                            element: self.$videobar,
                            size: 16
                        },
                        {
                            element: self.$editor
                        }
                    ],
                    orientation: 'vertical'
                })
            },
            {
                collapsed: !self.options.showAnnotations,
                collapsible: true,
                element: Ox.SplitPanel({
                    elements: [
                        {
                            element: self.$annotationsbar,
                            size: 16
                        },
                        {
                            element: self.$annotations,
                        }
                    ],
                    orientation: 'vertical'
                })
                .bindEvent({
                    resize: resizeAnnotations,
                    toggle: toggleAnnotations
                }),
                resizable: true,
                resize: [192, 256, 320, 384],
                size: self.options.annotationsSize,
                tooltip: self.options.tooltips ? 'annotations' : false
            }
        ],
        orientation: 'horizontal'
    });

    // we need a timeout so that a chained bindEvent
    // actually catches the event
    self.options.find && setTimeout(function() {
        submitFindInput(self.options.find, true);
    }, 0);

    function changePlayer(data) {
        self.options.position = data.position;
        self.$timeline[0].options({
            position: data.position
        });
        self.$timeline[1].options({
            position: data.position
        });
    }

    function changeTimelineLarge(data) {
        self.options.position = data.position;
        self.$player[0].options({
            position: data.position
        });
        self.$timeline[1].options({
            position: data.position
        });
        that.triggerEvent('position', {
            position: self.options.position
        });
    }

    function changeTimelineSmall(data) {
        self.options.position = data.position;
        self.$player[0].options({
            position: data.position
        });
        self.$timeline[0].options({
            position: data.position
        });
        that.triggerEvent('position', {
            position: self.options.position
        });
    }

    function find(query) {
        var results = [];
        if (query.length) {
            query = query.toLowerCase();
            results = Ox.map(self.options.subtitles, function(subtitle) {
                return subtitle.text.toLowerCase().indexOf(query) > -1 ? {
                    'in': subtitle['in'],
                    out: subtitle.out
                } : null;
            });
        }
        return results;
    }

    // fixme: why not goToNextPosition()?
    function getNextPosition(type, direction) {
        var found = false,
            position = 0,
            positions;
        if (type == 'cut') {
            positions = self.options.cuts;
        } else if (type == 'result') {
            positions = self.results.map(function(v) {
                return v['in'];
            });
        } else if (type == 'subtitle') {
            positions = self.options.subtitles.map(function(v) {
                return v['in'];
            });
        }
        direction == -1 && positions.reverse();
        Ox.forEach(positions, function(v) {
            if (direction == 1 ? v > self.options.position : v < self.options.position) {
                position = v;
                found = true;
                return false;
            }
        });
        direction == -1 && positions.reverse();
        if (!found) {
            position = positions[direction == 1 ? 0 : positions.length - 1];
        }
        return position;
    }

    function getPoints(type) {
        var found = false,
            points,
            positions = [];
        if (type == 'cut') {
            positions = self.options.cuts;
        } else if (type == 'match') {
            // ...
        } else if (type == 'subtitle') {
            self.options.subtitles.forEach(function(v, i) {
                positions.push(v['in']);
                positions.push(v.out);
            });
        }
        positions.indexOf(0) == -1 && positions.unshift(0);
        positions.indexOf(self.options.duration) == -1 &&
            positions.push(self.options.duration);
        Ox.forEach(positions, function(v, i) {
            if (v > self.options.position) {
                points = [positions[i - 1], positions[i]];
                found = true;
                return false;
            }
        });
        return points;
    }

    function getSizes(scrollbarIsVisible) {
        //Ox.print('getSizes', scrollbarIsVisible)
        var scrollbarWidth = Ox.UI.SCROLLBAR_SIZE,
			contentWidth = self.options.width - 
			    (self.options.showAnnotations * self.options.annotationsSize) - 1 -
			    (scrollbarIsVisible ? scrollbarWidth : 0),
            height,
            lines,
			size = {
                player: [],
                timeline: []
            },
            width, widths;
        if (self.options.videoSize == 'small') {
            width = 0;
            widths = Ox.divideInt(contentWidth - 4 * self.margin, 3);
            [1, 0, 2].forEach(function(v, i) {
                size.player[v] = {
                    left: (i + 0.5) * self.margin + width,
                    top: self.margin / 2,
                    width: widths[i],
                    height: Math.round(widths[1] / self.options.videoRatio)
                };
                width += widths[i];
            });
        } else {
            size.player[0] = {
                left: self.margin / 2,
                top: self.margin / 2,
                width: Math.round((contentWidth - 3 * self.margin + (self.controlsHeight + self.margin) / 2 * self.options.videoRatio) * 2/3),
            };
            size.player[0].height = Math.round(size.player[0].width / self.options.videoRatio);
            size.player[1] = {
                left: size.player[0].left + size.player[0].width + self.margin,
                top: size.player[0].top,
                width: contentWidth - 3 * self.margin - size.player[0].width
            };
            size.player[1].height = Math.ceil(size.player[1].width / self.options.videoRatio);
            size.player[2] = {
                left: size.player[1].left,
                top: size.player[0].top + size.player[1].height + self.controlsHeight + self.margin,
                width: size.player[1].width,
                height: size.player[0].height - size.player[1].height - self.controlsHeight - self.margin
            };
        }
        size.timeline[0] = {
            left: self.margin / 2,
            top: size.player[0].height + self.controlsHeight + 1.5 * self.margin,
            width: contentWidth - 2 * self.margin,
            height: 64
        };
        size.timeline[1] = {
            left: size.timeline[0].left,
            top: size.timeline[0].top + size.timeline[0].height + self.margin,
            width: size.timeline[0].width
        };
        lines = Math.ceil(self.options.duration / size.timeline[1].width);
        height = getHeight();
        self.$editor.css({
            overflowY: (scrollbarIsVisible && height <= self.options.height - 16) ? 'scroll' : 'auto'
        });
        //Ox.print('getSizes', scrollbarIsVisible, height, self.options.height, size)
        return (!scrollbarIsVisible && height > self.options.height - 16) ? getSizes(true) : size;
        function getHeight() {
            return size.player[0].height + self.controlsHeight +
                size.timeline[0].height + lines * 16 +
                (lines + 3) * self.margin;
        }
    }

    function goToPoint(point) {
        setPosition(self.options[point]);
    }

    function movePositionBy(sec) {
        setPosition(Ox.limit(self.options.position + sec, 0, self.options.duration));
    }

    function movePositionTo(type, direction) {
        setPosition(getNextPosition(type, direction));
    }

    function playInToOut() {
        self.$player[0].playInToOut();
    }

    function resizeAnnotations(data) {
        self.options.annotationsSize = data.size;
        setSizes();
    }

    function resizeEditor(data) {
        var width = data.size - 2 * margin + 100;
        resizeVideoPlayers(width);
        $timelineLarge.options({
            width: width
        });
        $timelineSmall.options({
            width: width
        });
    }

    function resizePlayers() {
        self.$player.forEach(function(v, i) {
            v.options({
                width: size[i].width,
                height: size[i].height
            })
            .css({
                left: size[i].left + 'px',
                top: size[i].top + 'px',
            });
        });
    }

    function selectAnnotation(data) {
        setPosition(data['in']);
        setPoint('in', data['in']);
        setPoint('out', data.out);
    }
    function updateAnnotation(data) {
        data['in'] = self.options['in'];
        data.out = self.options.out;
        that.triggerEvent('updateannotation', data);
    }

    function select(type) {
        self.options.points = getPoints(type);
        setPoints();
    }

    function setPoint(point, position) {
        var otherPoint = point == 'in' ? 'out' : 'in';
        self.options[point] = position;
        self.$player.forEach(function($player) {
            $player.options(point, self.options[point]);
        });
        self.$player[point == 'in' ? 1 : 2].options({
            position: self.options[point]
        });
        self.$timeline.forEach(function($timeline) {
            $timeline.options(point, self.options[point]);
        });
        if (self.options['in'] > self.options.out) {
            setPoint(point == 'in' ? 'out' : 'in', position);
        }
        that.triggerEvent('points', {
            'in': self.options['in'],
            out: self.options.out
        });
    }

    function setPosition(position) {
        self.options.position = position;
        self.$player[0].options({
            position: self.options.position
        });
        self.$timeline.forEach(function(v) {
            v.options({
                position: self.options.position
            });
        });
        that.triggerEvent('position', {
            position: self.options.position
        });
    }

    function setSizes() {
        self.sizes = getSizes();
        self.$player.forEach(function($player, i) {
            $player.options({
                height: self.sizes.player[i].height,
                width: self.sizes.player[i].width
            })
            .css({
                left: self.sizes.player[i].left + 'px',
                top: self.sizes.player[i].top + 'px'
            });
        });
        self.$timeline.forEach(function($timeline, i) {
            $timeline.options({
                width: self.sizes.timeline[i].width
            })
            .css({
                left: self.sizes.timeline[i].left + 'px',
                top: self.sizes.timeline[i].top + 'px'
            });
        });
    }

    function submitFindInput(value, hasPressedEnter) {
        self.options.find = value;
        self.results = find(self.options.find);
        self.$results.css({opacity: self.results.length ? 1 : 0.25}).html(self.results.length);
        self.$previousButton.options({
            disabled: self.results.length <= 1
        });
        self.$nextButton.options({
            disabled: self.results.length <= 1
        });
        self.$clearButton.options({
            disabled: !self.options.find
        });
        self.$timeline[0].options({
            find: self.options.find,
        });
        self.$timeline[1].options({
            find: self.options.find,
            results: self.results
        });
        self.$findInput.find('input').css({
            opacity: self.results.length ? 1 : 0.25
        });
        if (hasPressedEnter) {
            that.triggerEvent('find', {find: self.options.find});
            if (self.results.length) {
                setPosition(getNextPosition('result', 1));
            } else {
                self.$findInput.focusInput();
            }
        }
    }

    function toggleAnnotations(data) {
        self.options.showAnnotations = !data.collapsed;
        setSizes();
        that.triggerEvent('toggleannotations', {
            showAnnotations: self.options.showAnnotations
        });
    }

    function toggleMuted() {
        self.$player[0].toggleMuted();
    }

    function togglePaused() {
        self.$player[0].togglePaused();
        /* fixme
        self.$player[0].options('paused') && that.triggerEvent('position', {
            
        });
        */
    }

    function toggleSize() {
        self.options.videoSize = self.options.videoSize == 'small' ? 'large' : 'small';
        setSizes();
        that.triggerEvent('togglesize', {
            size: self.options.videoSize
        });
    }

    self.setOption = function(key, value) {
        if (key == 'width' || key == 'height') {
            Ox.print('XXXX setSizes', key, value, self.options.width, self.options.height)
            setSizes();
        } else if (key == 'position') {
            setPosition(value);
        } else if (key == 'showAnnotations') {
            that.$element.toggle(1);
        }
    };

    /*@
    addAnnotation <f> add annotation
        (layer, item) -> <o> add annotation to layer
        layer <s> layer id
        item <o> annotation to add
    @*/
    that.addAnnotation = function(layer, item) {
        var i = Ox.getPositionById(self.options.layers, layer);
        self.$annotationPanel[i].addItem(item);
    };

    /*@
    removeAnnotations <f> add annotation
        (layer, ids) -> <o> remove annotation from layer
        layer <s> layer id
        ids <a> array of item ids to remove
    @*/
    that.removeAnnotations = function(layer, ids) {
        var i = Ox.getPositionById(self.options.layers, layer);
        self.$annotationPanel[i].removeItems(ids);
    };

    return that;

};