segmentationviewer.java

编辑视频文件

            crossHairPos = xAt(crossHairTime);
        } else {
            if (!panMode) {
                intervalBeginTime = begin - (SCROLL_OFFSET * msPerPixel);
            } else {
                intervalBeginTime = begin;
            }

            if (intervalBeginTime < 0) {
                intervalBeginTime = 0;
            }

            intervalEndTime = intervalBeginTime + (imageWidth * msPerPixel);

            crossHairPos = xAt(crossHairTime);
        }

        paintBuffer();
    }

    /**
     * @see mpi.eudico.client.annotator.AbstractViewer#controllerUpdate(mpi.eudico.client.annotator.ControllerEvent)
     */
    public void controllerUpdate(ControllerEvent event) {
        if (event instanceof TimeEvent || event instanceof StopEvent) {
            crossHairTime = getMediaTime();

            //System.out.println("SV time: " + crossHairTime);
            if ((crossHairTime < intervalBeginTime) ||
                    (crossHairTime >= intervalEndTime)) {
                setIntervalBeginTime(crossHairTime);
            } else if (playerIsPlaying()) {
                long intervalMidTime = (intervalBeginTime + intervalEndTime) / 2;

                if (crossHairTime > (intervalMidTime + (1 * msPerPixel))) {
                    setIntervalBeginTime(intervalBeginTime +
                        (crossHairTime - intervalMidTime));
                } else if (crossHairTime < intervalMidTime) {
                    int oldPos = crossHairPos;
                    crossHairPos = xAt(crossHairTime);

                    if (crossHairPos >= oldPos) {
                        repaint(oldPos - 2, 0, crossHairPos - oldPos + 4,
                            getHeight());
                    } else {
                        repaint(crossHairPos - 2, 0, oldPos - crossHairPos + 4,
                            getHeight());
                    }
                } else {
                    repaint();
                }
            } else {
                int oldPos = crossHairPos;
                crossHairPos = xAt(crossHairTime);

                if (crossHairPos >= oldPos) {
                    repaint(oldPos - 2, 0, crossHairPos - oldPos + 4,
                        getHeight());
                } else {
                    repaint(crossHairPos - 2, 0, oldPos - crossHairPos + 4,
                        getHeight());
                }
            }
        }
    }

    /**
     * Stub.
     *
     * @see mpi.eudico.client.annotator.AbstractViewer#updateSelection()
     */
    public void updateSelection() {
    }

    /**
     * Stub.
     *
     * @see mpi.eudico.client.annotator.AbstractViewer#updateActiveAnnotation()
     */
    public void updateActiveAnnotation() {
    }

    /**
     * Stub.
     *
     * @see mpi.eudico.client.annotator.AbstractViewer#updateLocale()
     */
    public void updateLocale() {
    }

    /**
     * Sets the tier for this viewer.
     *
     * @param tier the tier
     *
     * @see mpi.eudico.client.annotator.SingleTierViewer#setTier(mpi.eudico.server.corpora.clom.Tier)
     */
    public void setTier(Tier tier) {
        if (tier instanceof TierImpl) {
            this.tier = (TierImpl) tier;
            segments = new ArrayList();
        } else {
            this.tier = null;
        }

        createTier2D(this.tier);

        paintBuffer();
    }

    /**
     * @see mpi.eudico.client.annotator.SingleTierViewer#getTier()
     */
    public Tier getTier() {
        return tier;
    }

    /**
     * Adds a segment to the list of segmentations.
     *
     * @param ti the new time interval / segment
     */
    public void addSegment(TimeInterval ti) {
        if ((ti == null) || (ti.getDuration() <= 0)) {
            return;
        }

        Tag2D tag2d = new Tag2D(null);
        int x = timeToPixels(ti.getBeginTime());
        int w = timeToPixels(ti.getEndTime()) - x;
        tag2d.setX(x);
        tag2d.setWidth(w);

        if (segments2d != null) {
            segments2d.insertTag(tag2d);
            paintBuffer();
        }
    }

    /**
     * Creates a Tier2D with 2D tags for all annotations.
     *
     * @param tier the tier
     */
    private void createTier2D(TierImpl tier) {
        if (tier == null) {
            tier2d = null;
            segments2d = null;
        }

        tier2d = new Tier2D(tier);
        segments2d = new Tier2D(tier);

        Tag2D tag2d;
        int xPos;
        int tagWidth;

        Iterator annotIter = tier.getAnnotations().iterator();

        while (annotIter.hasNext()) {
            Annotation a = (Annotation) annotIter.next();

            //System.out.println("Annotation: " + a);
            tag2d = new Tag2D(a);
            xPos = timeToPixels(a.getBeginTimeBoundary());
            tag2d.setX(xPos);
            tagWidth = timeToPixels(a.getEndTimeBoundary()) - xPos;
            tag2d.setWidth(tagWidth);
            tag2d.setTruncatedValue(truncateString(a.getValue(), tagWidth,
                    metrics));
            tier2d.addTag(tag2d);
        }
    }

    /**
     * Returns the x-ccordinate for a specific time. The coordinate is in the
     * component's coordinate system.
     *
     * @param t time
     *
     * @return int the x-coordinate for the specified time
     */
    public int xAt(long t) {
        return (int) ((t - intervalBeginTime) / msPerPixel);
    }

    /**
     * Calculates the x coordinate in virtual image space.<br>
     * This virtual image would be an image of width <br>
     * media duration in ms / ms per pixel. Therefore the return value does
     * not correct for interval begin time and is not necessarily within the
     * bounds of this component.
     *
     * @param theTime the media time
     *
     * @return the x coordinate in the virtual image space
     */
    private int timeToPixels(long theTime) {
        return (int) theTime / msPerPixel;
    }

    /**
     * Returns the time in ms at a given position in the current image. The
     * given x coordinate is in the component's ("this") coordinate system.
     * The interval begin time is included in the calculation of the time at
     * the given coordinate.
     *
     * @param x x-coordinate
     *
     * @return the mediatime corresponding to the specified position
     */
    public long timeAt(int x) {
        return intervalBeginTime + (x * msPerPixel);
    }

    /**
     * @see java.awt.event.MouseListener#mouseClicked(java.awt.event.MouseEvent)
     */
    public void mouseClicked(MouseEvent e) {
        setMediaTime(timeAt(e.getPoint().x));
    }

    /**
     * Stub.
     *
     * @see java.awt.event.MouseListener#mouseEntered(java.awt.event.MouseEvent)
     */
    public void mouseEntered(MouseEvent e) {
    }

    /**
     * Stub.
     *
     * @see java.awt.event.MouseListener#mouseExited(java.awt.event.MouseEvent)
     */
    public void mouseExited(MouseEvent e) {
    }

    /**
     * If the alt key is down the view can be "panned".
     *
     * @see java.awt.event.MouseListener#mousePressed(java.awt.event.MouseEvent)
     */
    public void mousePressed(MouseEvent e) {
        if (e.isAltDown()) {
            if (playerIsPlaying()) {
                stopPlayer();
            }

            dragStartPoint = e.getPoint();
            dragStartTime = timeAt(dragStartPoint.x);

            panMode = true;
            setCursor(Cursor.getPredefinedCursor(Cursor.MOVE_CURSOR));
        }
    }

    /**
     * @see java.awt.event.MouseListener#mouseReleased(java.awt.event.MouseEvent)
     */
    public void mouseReleased(MouseEvent e) {
        if (panMode) {
            panMode = false;
            setCursor(Cursor.getDefaultCursor());
        }
    }

    /**
     * Handles panning when the alt key is down.
     *
     * @see java.awt.event.MouseMotionListener#mouseDragged(java.awt.event.MouseEvent)
     */
    public void mouseDragged(MouseEvent e) {
        //panning
        if (panMode) {
            dragEndPoint = e.getPoint();

            int scrolldiff = dragEndPoint.x - dragStartPoint.x;

            // some other viewer may have a media offset...
            long newTime = intervalBeginTime - (scrolldiff * msPerPixel);

            if ((intervalBeginTime < 0) && (newTime < intervalBeginTime)) {
                newTime = intervalBeginTime;
            }

            setIntervalBeginTime(newTime);
            dragStartPoint = dragEndPoint;
        }
    }

    /**
     * @see java.awt.event.MouseMotionListener#mouseMoved(java.awt.event.MouseEvent)
     */
    public void mouseMoved(MouseEvent e) {
    }

    /**
     * Stub.
     *
     * @see java.awt.event.ComponentListener#componentHidden(java.awt.event.ComponentEvent)
     */
    public void componentHidden(ComponentEvent e) {
    }

    /**
     * Stub.
     *
     * @see java.awt.event.ComponentListener#componentMoved(java.awt.event.ComponentEvent)
     */
    public void componentMoved(ComponentEvent e) {
    }

    /**
     * @see java.awt.event.ComponentListener#componentResized(java.awt.event.ComponentEvent)
     */
    public void componentResized(ComponentEvent e) {
        paintBuffer();
    }

    /**
     * @see java.awt.event.ComponentListener#componentShown(java.awt.event.ComponentEvent)
     */
    public void componentShown(ComponentEvent e) {
        paintBuffer();
    }
}