utils/wpseditor/gui/src/qwpsdrawer.cpp

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  *
   9  *   Copyright (C) 2007 by Rostilav Checkan
  10  *   $Id$
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21
  22 #include <stdarg.h>
  23
  24 #include <QtGui>
  25 #include <QLibrary>
  26
  27 #include "qwpsdrawer.h"
  28 #include "slider.h"
  29 #include "utils.h"
  30 #include "qtrackstate.h"
  31 #include "qwpsstate.h"
  32 #include "api.h"
  33
  34 QPointer<QWpsDrawer> drawer;
  35 QPixmap   *QWpsDrawer::pix = NULL;
  36 QString   QWpsDrawer::mTmpWpsString;
  37 QImage    QWpsDrawer::backdrop;
  38 proxy_api QWpsDrawer::api;
  39
  40 QWpsDrawer::QWpsDrawer( QWpsState *ws,QTrackState *ms, QWidget *parent )
  41         : QWidget(parent),wpsState(ws),trackState(ms),showGrid(false),mCurTarget(qApp->applicationDirPath()+"/libwps_IRIVER_H10_5GB") {
  42
  43     tryResolve();
  44     newTempWps();
  45 }
  46
  47 bool QWpsDrawer::tryResolve() {
  48     QLibrary lib(mCurTarget);
  49     lib_wps_init = (pfwps_init)lib.resolve("wps_init");
  50     lib_wps_display = (pfwps_display)lib.resolve("wps_display");
  51     lib_wps_refresh = (pfwps_refresh)lib.resolve("wps_refresh");
  52     lib_get_model_name = (pfget_model_name)lib.resolve("get_model_name");
  53     mResolved = lib_wps_init && lib_wps_display && lib_wps_refresh && lib_get_model_name;
  54     if (!mResolved)
  55         DEBUGF1(tr("ERR: Failed to resolve funcs!"));
  56     else {
  57         int v = api.verbose;
  58         memset(&api,0,sizeof(struct proxy_api));
  59         api.verbose = v;
  60         api.putsxy =                    &QWpsDrawer::putsxy;
  61         api.transparent_bitmap_part =   &QWpsDrawer::transparent_bitmap_part;
  62         api.bitmap_part =               &QWpsDrawer::bitmap_part;
  63         api.drawpixel =                 &QWpsDrawer::drawpixel;
  64         api.fillrect =                  &QWpsDrawer::fillrect;
  65         api.hline =                     &QWpsDrawer::hline;
  66         api.vline =                     &QWpsDrawer::vline;
  67         api.clear_viewport =            &QWpsDrawer::clear_viewport;
  68         api.load_wps_backdrop =         &QWpsDrawer::load_wps_backdrop;
  69         api.read_bmp_file =             &QWpsDrawer::read_bmp_file;
  70         api.debugf =                    &qlogger;
  71         qDebug()<<(mCurTarget+" resolved");
  72     }
  73     return mResolved;
  74 }
  75 QWpsDrawer::~QWpsDrawer() {
  76     qDebug()<<"QWpsDrawer::~QWpsDrawer()";
  77     cleanTemp();
  78 }
  79
  80 void QWpsDrawer::mouseReleaseEvent ( QMouseEvent * event ) {
  81     Q_UNUSED(event);
  82     /*int x = event->x() - (this->width()-pix->width())/2,
  83             y = event->y() - (this->height()-pix->height())/2;
  84     DEBUGF1("x=%d,y=%d",x,y);*/
  85 }
  86 void QWpsDrawer::newTempWps() {
  87     QTemporaryFile tmpWps;
  88     tmpWps.setAutoRemove(false);
  89     tmpWps.setFileTemplate(QDir::tempPath()+"/XXXXXXXXXX.wps");
  90     if (tmpWps.open()) {
  91         QString tmpDir = tmpWps.fileName().left(tmpWps.fileName().length()-4);
  92         if (QDir::temp().mkpath(tmpDir)) {
  93             mTmpWpsString = tmpDir;
  94             DEBUGF3(QString("Created :"+mTmpWpsString).toAscii());
  95         }
  96     }
  97 }
  98
  99 void QWpsDrawer::WpsInit(QString buffer, bool isFile) {
 100         DEBUGF3("QWpsDrawer::WpsInit");
 101     if (!mResolved)
 102         if (!tryResolve())
 103             return;
 104     if (isFile) {
 105         cleanTemp();
 106         DEBUGF1( tr("Loading %1").arg(buffer));
 107         QFile file(buffer);
 108         if (file.open(QIODevice::ReadOnly | QIODevice::Text))
 109             mWpsString = file.readAll();
 110         newTempWps();
 111     } else
 112         mWpsString = buffer;
 113     {
 114         QFile tfile(mTmpWpsString+".wps");
 115         if (tfile.open(QIODevice::WriteOnly | QIODevice::Text))
 116             tfile.write(mWpsString.toAscii(),mWpsString.length());
 117     }
 118     backdrop.fill(Qt::black);
 119     DEBUGF3("clear backdrop");
 120     if (isFile)
 121         lib_wps_init(buffer.toAscii(), &api, isFile);
 122     else
 123         lib_wps_init(QString(mTmpWpsString+".wps").toAscii(), &api, true);
 124     pix = new QPixmap(api.getwidth(),api.getheight());
 125     pix->fill(Qt::black);
 126
 127     drawBackdrop();
 128
 129     setMinimumWidth(api.getwidth());
 130     setMinimumHeight(api.getheight());
 131     update();
 132 }
 133
 134 void QWpsDrawer::paintEvent(QPaintEvent * event) {
 135     DEBUGF3("QWpsDrawer::paintEvent()");
 136     if (!mResolved)
 137         return;
 138     if (pix==NULL)
 139         return;
 140     QPainter p(this);
 141     QRect rect = event->rect();
 142
 143     drawBackdrop();
 144     lib_wps_refresh();
 145
 146     if (showGrid) {
 147         QPainter g(pix);
 148         viewport_api avp;
 149         api.get_current_vp(&avp);
 150
 151         g.setPen(Qt::green);
 152
 153         for (int i=0;i*avp.fontheight/1.5<avp.width ;i++) {
 154             g.drawLine(int(i*avp.fontheight/1.5), 0, int(i*avp.fontheight/1.5), avp.height);
 155         }
 156         for (int j=0;j*avp.fontheight<avp.height; j++) {
 157             g.drawLine(0,j*avp.fontheight,avp.width,j*avp.fontheight);
 158         }
 159     }
 160
 161     p.drawPixmap((rect.width()-pix->width())/2,(rect.height()-pix->height())/2,*pix);
 162
 163 }
 164
 165 void QWpsDrawer::clear_viewport(int x,int y,int w,int h, int color) {
 166     DEBUGF2("clear_viewport(int x=%d,int y=%d,int w=%d,int h=%d, int color)",x,y,w,h);
 167     QPainter p(pix);
 168     //p.setOpacity(0.1);
 169     //QImage img = backdrop.copy(x,y,w,h);
 170     //p.drawImage(x,y,img);
 171 }
 172
 173 void QWpsDrawer::slotSetVolume() {
 174     Slider *slider = new Slider(this, tr("Volume"),-74,10);
 175     slider->show();
 176     connect(slider, SIGNAL(valueChanged(int)), wpsState, SLOT(setVolume(int)));
 177     connect(this, SIGNAL(destroyed()),slider, SLOT(close()));
 178 }
 179
 180 void QWpsDrawer::slotSetProgress() {
 181     Slider *slider = new Slider(this,tr("Progress"),0,100);
 182     slider->show();
 183     connect(slider, SIGNAL(valueChanged(int)), trackState, SLOT(setElapsed(int)));
 184     connect(this, SIGNAL(destroyed()),slider, SLOT(close()));
 185 }
 186
 187 void QWpsDrawer::slotWpsStateChanged(wpsstate ws_) {
 188     if (api.set_wpsstate)
 189         api.set_wpsstate(ws_);
 190     update();
 191 }
 192
 193 void QWpsDrawer::slotTrackStateChanged(trackstate ms_) {
 194     if (api.set_wpsstate)
 195         api.set_trackstate(ms_);
 196     update();
 197 }
 198
 199 void QWpsDrawer::slotShowGrid(bool show) {
 200     showGrid = show;
 201     update();
 202 }
 203
 204 void QWpsDrawer::drawBackdrop() {
 205     DEBUGF3("QWpsDrawer::drawBackdrop()");
 206     if (backdrop.isNull())
 207         return;
 208     QPainter b(pix);
 209     QImage pink = backdrop.createMaskFromColor(qRgb(255,0,255),Qt::MaskOutColor);
 210     backdrop.setAlphaChannel(pink);
 211     b.drawImage(0,0,backdrop,0,0,pix->width(),pix->height());
 212 }
 213
 214 void QWpsDrawer::slotSetAudioStatus(int status) {
 215     api.set_audio_status(status);
 216     update();
 217 }
 218
 219 void QWpsDrawer::cleanTemp(bool fileToo) {
 220     if (fileToo)
 221         QFile::remove(mTmpWpsString+".wps");
 222     QDirIterator it(mTmpWpsString, QDirIterator::Subdirectories);
 223     while (it.hasNext()) {
 224         QFile::remove(it.next());
 225     }
 226     QDir(mTmpWpsString).rmdir(mTmpWpsString);
 227 }
 228
 229 void QWpsDrawer::closeEvent(QCloseEvent *event) {
 230     qDebug()<<"QWpsDrawer::closeEvent()";
 231     cleanTemp();
 232     event->accept();
 233 }
 234
 235 QString QWpsDrawer::getModelName(QString libraryName) {
 236     QLibrary lib(libraryName);
 237     if ((pfget_model_name)lib.resolve("get_model_name"))
 238         return ((pfget_model_name)lib.resolve("get_model_name"))();
 239     DEBUGF1("ERR: failed to resolve <get_model_name>");
 240     return "unknown";
 241 }
 242
 243 QList<QString> QWpsDrawer::getTargets() {
 244     QList<QString> list ;
 245     QDir d = QDir(qApp->applicationDirPath());
 246     QFileInfoList libs = d.entryInfoList(QStringList("libwps_*"));
 247     qDebug() << libs.size()<<"libs found";
 248     for (int i = 0; i < libs.size(); i++) {
 249         QString modelName = getModelName(libs[i].absoluteFilePath());
 250         qDebug() << libs[i].fileName()<<modelName;
 251         if (modelName == "unknown")
 252             continue;
 253         list.append(modelName);
 254         libs_array[i].target_name = modelName;
 255         libs_array[i].lib = libs[i].absoluteFilePath();
 256     }
 257     return list;
 258 }
 259 bool QWpsDrawer::setTarget(QString target) {
 260     foreach(lib_t cur_lib, libs_array)
 261     {
 262         if(cur_lib.target_name == target)
 263         {
 264             QLibrary lib(cur_lib.lib);
 265             //lib.unload();
 266             if (getModelName(cur_lib.lib) != "unknown")
 267             {
 268                 mCurTarget = cur_lib.lib;
 269                 return tryResolve();
 270             }
 271         }
 272     }
 273     return false;
 274 }