frame.cc

Linux下比较早的基于命令行的DVD播放器

//
// Copyright (c) 2005 by Istv醤 V醨adi
//
// This file is part of dxr3Player, a DVD player written specifically 
// for the DXR3 (aka Hollywood+) decoder card.

// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

//------------------------------------------------------------------------------

#include "Frame.h"

#include "unichrome/Font.h"
#include "unichrome/MemoryBlock.h"

//------------------------------------------------------------------------------

using output::unichrome::osd::Frame;

using unichrome::Unichrome;
using unichrome::Font;
using unichrome::MemoryBlock;
using unichrome::LogicalWindow;

//------------------------------------------------------------------------------

Frame::Config::Config(Unichrome& videoDevice, Font& titleFont, uint8_t alpha) :
    videoDevice(videoDevice),
    titleFont(titleFont),
    alpha(alpha)
{
}   

//------------------------------------------------------------------------------

Frame::Frame(const Config& config, Window& displayWindow,
             size_t width, size_t height, const char* title,
             uint32_t bgColor) :
    UpdateableWindow(physicalWindow, 0, 0, width, height),
    displayWindow(displayWindow),
    displayX(0),
    displayY(0),
    memoryBlock(config.videoDevice.allocateMemoryBlock(width*height*sizeof(uint32_t))),
    physicalWindow(*memoryBlock, width),
    visible(false),
    config(config),
    innerWindow(0)
{
    fill(0xff000000);

    Field::Config titleFieldConfig(config.videoDevice, config.titleFont,
                                   config.borderColor, title);
   
    size_t titleFieldHeight = titleFieldConfig.getRecommendedHeight();
    
    size_t borderTop = (titleFieldHeight - (config.borderThickness-1))/2;
    size_t innerWindowTop = borderTop + config.cornerRadius;

    innerWindow = 
        new LogicalWindow(*this,
                          0, innerWindowTop,
                          width - 2 * config.cornerRadius,
                          height - innerWindowTop - 2 * config.cornerRadius);

    LogicalWindow borderWindow(*this, 0, borderTop, 
                               width, height - borderTop);

    bgColor &= 0x00ffffff;
    bgColor |= ((uint32_t)config.alpha)<<24;

    borderWindow.disableKeying();
    borderWindow.fill(bgColor);

    drawBorder(borderWindow, config);

    drawTitle(config, titleFieldConfig, title);
}

//------------------------------------------------------------------------------

Frame::~Frame()
{
    delete innerWindow;
    delete memoryBlock;
}

//------------------------------------------------------------------------------

void Frame::setDisplayPosition(size_t x, size_t y)
{
    bool v = visible;

    if (v) hide();

    displayX = x;
    displayY = y;

    if (v) show();
}

//------------------------------------------------------------------------------

void Frame::show()
{
    if (visible) {
        Frame::blitUpdatedInto(displayWindow, displayX, displayY);
    } else {
        Frame::blitInto(displayWindow, displayX, displayY);
    }

    visible = true;
}

//------------------------------------------------------------------------------

void Frame::hide()
{
    if (visible) {
        Frame::fillIn(displayWindow, displayX, displayY, 0xff000000);
    }
    
    visible = false;
}

//------------------------------------------------------------------------------

void Frame::handleTimeout()
{
    if (visible) hide();
    else show();
}

//------------------------------------------------------------------------------

void Frame::drawBorderLine(LogicalWindow& window,
                           const Config& config, bool horizontal, bool leftTop)
{
    size_t x = 
        horizontal ? 
        config.cornerRadius  :
        (leftTop ? 0 : (window.getWidth() - config.borderThickness));

    size_t y = 
        horizontal ?
        (leftTop ? 0 : (window.getHeight() - config.borderThickness)) :
        config.cornerRadius;
    
    size_t width =
        horizontal ? 
        (window.getWidth() - 2 * config.cornerRadius) :
        config.borderThickness;
        
    size_t height =
        horizontal ? 
        config.borderThickness :
        (window.getHeight() - 2 * config.cornerRadius);
        
    window.fillRectangle(x, y, width, height);
}

//------------------------------------------------------------------------------

void Frame::drawCorner(LogicalWindow& window,
                       const Config& config, bool top, bool left)
{
    size_t x = left ? 0 : (window.getWidth() - config.cornerRadius);
    size_t y = top ? 0 : (window.getHeight() - config.cornerRadius);

    ssize_t x0 = left ? config.cornerRadius : x;
    ssize_t y0 = top ? config.cornerRadius : y;

    window.drawArc(x, y,
                   
                   config.cornerRadius, 
                   config.cornerRadius,
                   
                   x0, y0,
                   
                   config.cornerRadius - config.borderThickness, 
                   config.cornerRadius,
                   
                   config.borderColor, 
                   Painter::transparentColor,
                   0xff000000);
}

//------------------------------------------------------------------------------

void Frame::drawBorder(LogicalWindow& window, const Config& config)
{
    window.setForeground(config.borderColor);
    window.disableKeying();

    // Draw the vertical and horizontal lines of the border
    drawBorderLine(window, config, true, true);
    drawBorderLine(window, config, true, false);
    drawBorderLine(window, config, false, true);
    drawBorderLine(window, config, false, false);

    // Draw the corners
    drawCorner(window, config, true, true);
    drawCorner(window, config, true, false);
    drawCorner(window, config, false, true);
    drawCorner(window, config, false, false);
}

//------------------------------------------------------------------------------

void Frame::drawTitle(const Config& config, 
                      const Field::Config& titleFieldConfig,
                      const char* title)
{
    size_t titleWidth, titleHeight;
    ssize_t titleLeft, titleTop;

    config.titleFont.getDimensions(title, 
                                   titleWidth, titleHeight,
                                   titleLeft, titleTop);
    size_t titleFieldWidth = titleWidth + 2 * config.titleMargin;

    size_t titleFieldHeight = titleFieldConfig.getRecommendedHeight();
    
    size_t titleFieldRadius = titleFieldHeight / 2;

    size_t titleStart = config.cornerRadius + titleFieldHeight / 2 + 20;

    disableKeying();
    
    drawArc(titleStart - titleFieldRadius, 0, 
            titleFieldRadius, titleFieldHeight,
            titleStart, titleFieldRadius,
            0, titleFieldRadius,
            config.borderColor);

    drawArc(titleStart + titleFieldWidth, 0, 
            titleFieldRadius, titleFieldHeight,
            titleStart + titleFieldWidth, titleFieldRadius,
            0, titleFieldRadius, 
            config.borderColor);

    Field titleField(titleFieldConfig, *this, 
                     titleStart, 0, 
                     titleFieldWidth, titleFieldHeight,
                     config.titleColor);

    titleField.setValue(title);
}

//------------------------------------------------------------------------------