Ticket #702: mythplugins_702.patch

File mythplugins_702.patch, 21.6 KB (added by DanielSherwood, 14 years ago)
  • svn/trunk/mythplugins/mythgallery/mythgallery/glsingleview.cpp

     
    142142    m_running       = false;
    143143    m_texInfo       = 0;
    144144    m_showInfo      = false;
     145    m_sequence      = 0;
    145146
    146147    // ---------------------------------------------------------------
    147148
     
    149150    connect(m_timer, SIGNAL(timeout()),
    150151            SLOT(slotTimeOut()));
    151152
    152     if (slideShow > 1)
    153         randomFrame();
     153    if (slideShow > 1)
     154    {
     155        m_sequence = new SequenceShuffle(m_itemList.count());
     156        m_pos = 0;
     157    }
     158    else
     159        m_sequence = new SequenceInc(m_itemList.count());
     160    m_pos = m_sequence->index(m_pos);
    154161
    155162    if (slideShow) {
    156163        m_running = true;
     
    161168
    162169GLSingleView::~GLSingleView()
    163170{
    164    
     171    if( m_sequence ) {
     172        delete m_sequence;
     173    }   
    165174}
    166175
    167176void GLSingleView::cleanUp()
     
    392401            m_sy = 0;
    393402            rotate(-90);
    394403        }
    395         else if (action == "PLAY")
     404        else if (action == "DELETE")
    396405        {
     406            ThumbItem *item = m_itemList.at(m_pos);
     407            if (item) {
     408                if( item->Remove() ) {
     409                    m_zoom = 1.0;
     410                    m_sx   = 0;
     411                    m_sy   = 0;
     412                    // Delete thumbnail for this
     413                    if (item->pixmap)
     414                        delete item->pixmap;
     415                    item->pixmap = 0;
     416                    advanceFrame();
     417                    loadImage();
     418                }
     419            }
     420        }
     421        else if (action == "PLAY" || action == "SLIDESHOW" || action == "RANDOMSHOW")
     422        {
    397423            m_sx   = 0;
    398424            m_sy   = 0;
    399425            m_zoom = 1.0;
     
    487513
    488514void GLSingleView::advanceFrame()
    489515{
    490     m_pos++;
    491     if (m_pos >= (int)m_itemList.count())
    492         m_pos = 0;
    493 
    494     m_tex1First = !m_tex1First;
    495     m_curr      = (m_curr == 0) ? 1 : 0;
    496 }
    497 
    498 void GLSingleView::randomFrame()
    499 {
    500     int newframe;
    501     if(m_itemList.count() > 1){
    502         while((newframe = (int)(rand()/(RAND_MAX+1.0) * m_itemList.count())) ==m_pos);
    503         m_pos = newframe;
     516    // Search for next item that hasn't been deleted.  Close viewer in none remain.
     517    ThumbItem *item;
     518    int oldpos = m_pos;
     519    while( 1 ) {
     520        m_pos = m_sequence->next();
     521        item = m_itemList.at(m_pos);
     522        if( item ) {
     523            if( QFile::exists(item->path) ) {
     524                break;
     525            }
     526        }
     527        if( m_pos == oldpos ) {
     528            // No valid items!!!
     529            close();
     530        }
    504531    }
    505532
    506533    m_tex1First = !m_tex1First;
     
    509536
    510537void GLSingleView::retreatFrame()
    511538{
    512     m_pos--;
    513     if (m_pos < 0)
    514         m_pos = m_itemList.count() - 1;
     539    // Search for next item that hasn't been deleted.  Close viewer in none remain.
     540    ThumbItem *item;
     541    int oldpos = m_pos;
     542    while( 1 ) {
     543        m_pos = m_sequence->prev();
     544        item = m_itemList.at(m_pos);
     545        if( item ) {
     546            if( QFile::exists(item->path) ) {
     547                break;
     548            }
     549        }
     550        if( m_pos == oldpos ) {
     551            // No valid items!!!
     552            close();
     553        }
     554    };
    515555
    516556    m_tex1First = !m_tex1First;
    517557    m_curr = (m_curr == 0) ? 1 : 0;
     
    612652    t.cx = (float)sz.width()/(float)screenwidth;
    613653    t.cy = (float)sz.height()/(float)screenheight;
    614654}
     655
    615656void GLSingleView::registerEffects()
    616657{
    617658    m_effectMap.insert("none", &GLSingleView::effectNone);
     
    13981439
    13991440void GLSingleView::slotTimeOut()
    14001441{
     1442    bool wasMovie = false, isMovie = false;
    14011443    if (!m_effectMethod) {
    14021444        std::cerr << "GLSlideShow: No transition method"
    14031445                  << std::endl;
     
    14221464            if (m_effectRandom)
    14231465                m_effectMethod = getRandomEffect();
    14241466
    1425             if (m_slideShow > 1)
    1426                 randomFrame();
    1427             else
    1428                 advanceFrame();
     1467            advanceFrame();
    14291468
    1430             bool wasMovie = m_movieState > 0;
     1469            wasMovie = m_movieState > 0;
    14311470            loadImage();
    1432             bool isMovie = m_movieState > 0;
     1471            isMovie = m_movieState > 0;
    14331472            // If transitioning to/from a movie, don't do an effect,
    14341473            // and shorten timeout
    14351474            if (wasMovie || isMovie)
     
    14471486
    14481487    updateGL();
    14491488    m_timer->start(m_tmout, true);
     1489    // If transitioning to/from a movie, no effect is running so
     1490    // next timeout should trigger proper immage delay.
     1491    if( wasMovie || isMovie ) {
     1492        m_tmout = -1;
     1493    }
    14501494}
    14511495
    14521496void GLSingleView::createTexInfo()
  • svn/trunk/mythplugins/mythgallery/mythgallery/glsingleview.h

     
    2626#include <qmap.h>
    2727
    2828#include "iconview.h"
     29#include "sequence.h"
    2930
    3031class QImage;
    3132class QTimer;
     
    110111    EffectMethod                m_effectMethod;
    111112    QMap<QString,EffectMethod>  m_effectMap;
    112113    bool                        m_effectRandom;
     114    SequenceBase               *m_sequence;
    113115
    114116private:
    115117   
    116118    void  advanceFrame();
    117     void  randomFrame();
    118119    void  retreatFrame();
    119120    void  loadImage();
    120121    void  paintTexture();
  • svn/trunk/mythplugins/mythgallery/mythgallery/singleview.cpp

     
    114114    m_i = 0;
    115115    m_effectPix = 0;
    116116    m_painter = 0;
     117    m_sequence = 0;
    117118    mIntArray = 0;
    118119
    119120    m_timer = new QTimer(this);
     
    122123    // --------------------------------------------------------------------
    123124
    124125    if(slideShow > 1)
    125         randomFrame();
     126    {
     127        m_sequence = new SequenceShuffle(m_itemList.count());
     128        m_pos = 0;
     129    }
     130    else
     131        m_sequence = new SequenceInc(m_itemList.count());
     132    m_pos = m_sequence->index(m_pos);
    126133    loadImage();
    127134    if (slideShow) {
    128135        m_running = true;
     
    139146        delete m_painter;
    140147    }
    141148
     149    if (m_sequence)
     150        delete m_sequence;
     151
    142152    if (m_pixmap)
    143153        delete m_pixmap;
    144154
     
    392402            m_sy = 0;
    393403            rotate(-90);
    394404        }
    395         else if (action == "PLAY")
     405        else if (action == "DELETE")
    396406        {
     407            ThumbItem *item = m_itemList.at(m_pos);
     408            if (item) {
     409                if( item->Remove() ) {
     410                    m_zoom = 1.0;
     411                    m_sx   = 0;
     412                    m_sy   = 0;
     413                    // Delete thumbnail for this
     414                    if (item->pixmap)
     415                        delete item->pixmap;
     416                    item->pixmap = 0;
     417                    advanceFrame();
     418                    loadImage();
     419                }
     420            }
     421        }
     422        else if (action == "PLAY" || action == "SLIDESHOW" || action == "RANDOMSHOW")
     423        {
    397424            m_sx   = 0;
    398425            m_sy   = 0;
    399426            m_zoom = 1.0;
     
    423450
    424451void SingleView::advanceFrame()
    425452{
    426     m_pos++;
    427     if (m_pos >= (int)m_itemList.count())
    428         m_pos = 0;
    429 }
    430 
    431 void SingleView::randomFrame()
    432 {
    433     int newframe;
    434     if(m_itemList.count() > 1){
    435         while((newframe = (int)(rand()/(RAND_MAX+1.0) * m_itemList.count())) == m_pos);
    436         m_pos = newframe;
     453    // Search for next item that hasn't been deleted.  Close viewer in none remain.
     454    ThumbItem *item;
     455    int oldpos = m_pos;
     456    while( 1 ) {
     457        m_pos = m_sequence->next();
     458        item = m_itemList.at(m_pos);
     459        if( item ) {
     460            if( QFile::exists(item->path) ) {
     461                break;
     462            }
     463        }
     464        if( m_pos == oldpos ) {
     465            // No valid items!!!
     466            reject();
     467        }
    437468    }
    438469}
    439470
    440471void SingleView::retreatFrame()
    441472{
    442     m_pos--;
    443     if (m_pos < 0)
    444         m_pos = m_itemList.count()-1;
     473    // Search for next item that hasn't been deleted.  Close viewer in none remain.
     474    ThumbItem *item;
     475    int oldpos = m_pos;
     476    while( 1 ) {
     477        m_pos = m_sequence->prev();
     478        item = m_itemList.at(m_pos);
     479        if( item ) {
     480            if( QFile::exists(item->path) ) {
     481                break;
     482            }
     483        }
     484        if( m_pos == oldpos ) {
     485            // No valid items!!!
     486            reject();
     487        }
     488    }
    445489}
    446490
    447491void SingleView::loadImage()
     
    11671211
    11681212void SingleView::slotTimeOut()
    11691213{
     1214    bool wasMovie = false, isMovie = false;
    11701215    if (!m_effectMethod) {
    11711216        std::cerr << "SingleView: No transition method"
    11721217                  << std::endl;
     
    11891234            if (m_effectRandom)
    11901235                m_effectMethod = getRandomEffect();
    11911236
    1192              if (m_slideShow > 1)
    1193                  randomFrame();
    1194              else
    1195                  advanceFrame();
     1237            advanceFrame();
    11961238
    1197             bool wasMovie = m_movieState > 0;
     1239            wasMovie = m_movieState > 0;
    11981240            loadImage();
    1199             bool isMovie = m_movieState > 0;
     1241            isMovie = m_movieState > 0;
    12001242            // If transitioning to/from a movie, don't do an effect,
    12011243            // and shorten timeout
    12021244            if (wasMovie || isMovie)
     
    12141256
    12151257    update();
    12161258    m_timer->start(m_tmout, true);
     1259    // If transitioning to/from a movie, no effect is running so
     1260    // next timeout should trigger proper immage delay.
     1261    if( wasMovie || isMovie ) {
     1262        m_tmout = -1;
     1263    }
    12171264}
  • svn/trunk/mythplugins/mythgallery/mythgallery/sequence.h

     
     1/* ============================================================
     2 * File  : sequence.h
     3 * Description :
     4 *   A set of classes providing a sequence of numbers within a
     5 *   specified range allowing navigation in the sequence.
     6 *     SequenceBase       - Base for all Sequence classes.
     7 *     SequenceInc        - An incrementing sequence.
     8 *     SequenceDec        - A decrementing sequence.
     9 *     SequenceRandomBase - Base for all 'random' Sequence classes.
     10 *     SequenceRandom     - A random sequence (can have duplicates).
     11 *     SequenceShuffle    - A random sequence (no duplicates).
     12 *
     13
     14 * This program is free software; you can redistribute it
     15 * and/or modify it under the terms of the GNU General
     16 * Public License as published bythe Free Software Foundation;
     17 * either version 2, or (at your option)
     18 * any later version.
     19 *
     20 * This program is distributed in the hope that it will be useful,
     21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
     22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     23 * GNU General Public License for more details.
     24 *
     25 * ============================================================ */
     26
     27#ifndef SEQUENCE_H
     28#define SEQUENCE_H
     29
     30#include <stdlib.h>
     31
     32class SequenceBase 
     33{
     34public:
     35        SequenceBase(int _len, bool _reset = true)
     36        : len(_len), idx(0) {
     37                if(_reset) { reset(_len); }
     38        };
     39
     40        virtual ~SequenceBase() {
     41        };
     42
     43        virtual void reset(int _len) {
     44                len = _len;
     45        idx = 0;
     46        };
     47
     48        virtual void extend(int _len) {
     49                len = _len;
     50        };
     51
     52        int index(int _idx) { idx = _idx; return index(); };
     53        int next(void)      { idx++; return index(); };
     54        int prev(void)      { idx--; return index(); };
     55       
     56       
     57protected:
     58        int index(void)     {
     59        if( idx < 0 ) {
     60            idx += len;
     61        }
     62        idx %= len;
     63        int retval = get();
     64        return retval;
     65    };
     66
     67        virtual int get(void) = 0;
     68
     69        int  len;
     70        int  idx;
     71};
     72
     73class SequenceInc : public SequenceBase
     74{
     75public:
     76        SequenceInc(int _len)
     77        : SequenceBase(_len) {
     78        };
     79
     80protected:
     81        virtual int get(void) { return idx; };
     82};
     83
     84class SequenceDec : public SequenceBase
     85{
     86public:
     87        SequenceDec(int _len)
     88        : SequenceBase(_len) {
     89        };
     90
     91protected:
     92        virtual int get(void) {
     93                return len - idx - 1;
     94        };
     95};
     96
     97class SequenceRandomBase : public SequenceBase
     98{
     99public:
     100        SequenceRandomBase(int _len, bool _reset = true)
     101        : SequenceBase(_len, _reset), seq(0) {
     102                if( _reset ) { reset(_len); }
     103        };
     104
     105        virtual ~SequenceRandomBase() {
     106                if( seq ) {
     107                        delete seq;
     108                }
     109        };
     110
     111        virtual void reset(int _len) {
     112                SequenceBase::reset(_len);
     113                if( seq ) {
     114                        delete seq;
     115                }
     116                seq = new(int[len]);
     117                for( int i = 0 ; i < len ; i++ ) {
     118                        seq[i] = -1;
     119                }
     120        };
     121
     122protected:
     123        virtual int get(void) {
     124                if( seq[idx] == -1 ) {
     125                        seq[idx] = create();
     126                }
     127                return seq[idx];
     128        };
     129
     130        virtual int create(void) = 0;
     131
     132        int *seq;
     133};
     134
     135class SequenceRandom : public SequenceRandomBase
     136{
     137public:
     138        SequenceRandom(int _len)
     139        : SequenceRandomBase(_len) {};
     140
     141protected:
     142        virtual int create(void) {
     143                return (int)(((double)rand()) * len / RAND_MAX);
     144        };
     145};
     146
     147#define MAP_IDX(idx)     map[((idx) / sizeof(int))]
     148#define MAP_MSK(idx)     (1 << ((idx) % sizeof(int)))
     149#define MAP_SET(map,idx) MAP_IDX(idx) |= MAP_MSK(idx)
     150#define MAP_CLR(map,idx) MAP_IDX(idx) &= ~MAP_MSK(idx)
     151#define MAP(map,idx)     (MAP_IDX(idx) & MAP_MSK(idx))
     152
     153class SequenceShuffle : public SequenceRandomBase
     154{
     155public:
     156        SequenceShuffle(int _len)
     157        : SequenceRandomBase(_len, false), map(0) {
     158                reset(_len);
     159        };
     160
     161        virtual ~SequenceShuffle() {
     162                if( map ) {
     163                        delete map;
     164                }
     165        };
     166
     167        virtual void reset(int _len) {
     168                SequenceRandomBase::reset(_len);
     169                if( map ) {
     170                   delete map;
     171                }
     172                map = new(int[(len / sizeof(int)) + 1]);
     173                for( int i = 0 ; i < len ; i++ ) {
     174                   MAP_CLR(map,i);
     175                }
     176        };
     177
     178protected:
     179        virtual int create(void) {
     180                while(1) {
     181                        int i = (int)(((double)rand()) * len / RAND_MAX);
     182                        if( !MAP(map,i) ) {
     183                                MAP_SET(map,i);
     184                                return i;
     185                        }
     186                }
     187        };
     188
     189        int *map;
     190        int used;
     191};
     192
     193#endif // ndef SEQUENCE_H
  • svn/trunk/mythplugins/mythgallery/mythgallery/singleview.h

    Property changes on: svn/trunk/mythplugins/mythgallery/mythgallery/sequence.h
    ___________________________________________________________________
    Name: svn:executable
       + *
    
     
    2222#include <qimage.h>
    2323
    2424#include "iconview.h"
     25#include "sequence.h"
    2526
    2627class QTimer;
    2728
     
    7778    EffectMethod                m_effectMethod;
    7879    QMap<QString,EffectMethod>  m_effectMap;
    7980    bool                        m_effectRandom;
     81    SequenceBase               *m_sequence;
    8082
    8183private:
    8284
    8385    void  advanceFrame();
    84     void  randomFrame();
    8586    void  retreatFrame();
    8687    void  loadImage();
    8788    void  rotate(int angle);
  • svn/trunk/mythplugins/mythgallery/mythgallery/iconview.cpp

     
    7272    query.exec();
    7373}
    7474
     75bool ThumbItem::Remove(void)
     76{
     77    if( QFile::remove(path) ) {
     78            MSqlQuery query(MSqlQuery::InitCon());
     79            query.prepare("DELETE FROM gallerymetadata WHERE image = :PATH ;");
     80            query.bindValue(":PATH", path.utf8());
     81            query.exec();
     82        return true;
     83    }
     84    return false;
     85}
     86
    7587IconView::IconView(const QString& galleryDir, MythMainWindow* parent,
    7688                   const char* name )
    7789    : MythDialog(parent, name)
     
    322334            m_topRow  = QMAX(m_currRow-(m_nRows-1),0);
    323335            handled = true;
    324336        }
    325         else if (action == "SELECT" || action == "PLAY")
     337        else if (action == "ROTRIGHT")
    326338        {
    327             if (m_inMenu) {
     339            actionRotateCW();
     340            handled = true;
     341        }
     342        else if (action == "ROTLEFT")
     343        {
     344            actionRotateCCW();
     345            handled = true;
     346        }
     347        else if (action == "DELETE")
     348        {
     349            actionDelete();
     350            handled = true;
     351        }
     352        else if (action == "SELECT" || action == "PLAY" || action == "SLIDESHOW" || action == "RANDOMSHOW" )
     353        {
     354            if (m_inMenu && (action == "SELECT" || action == "PLAY") ) {
    328355                pressMenu();
    329356                menuHandled = true;
    330357            }
     
    337364                }
    338365       
    339366                QFileInfo fi(item->path);
    340                 if (item->isDir) {
     367                if (item->isDir && (action == "SELECT" || action == "PLAY") ) {
    341368                    loadDirectory(item->path);
    342369                    handled = true;
    343370                }
     
    345372         
    346373                    handled = true;
    347374                   
    348                     int slideShow = (action == "PLAY")?1:0;
     375                    int slideShow = 0;
     376                    if( action == "PLAY" || action == "SLIDESHOW" ) {
     377                        slideShow = 1;
     378                    } else if( action == "RANDOMSHOW" ) {
     379                        slideShow = 2;
     380                    }
    349381#ifdef OPENGL_SUPPORT
    350382                    int useOpenGL = gContext->GetNumSetting("SlideshowUseOpenGL");
    351383                    if (useOpenGL) {
     
    512544    item->setData(new Action(&IconView::actionRotateCW));
    513545    item = new UIListBtnTypeItem(m_menuType, tr("Rotate CCW"));
    514546    item->setData(new Action(&IconView::actionRotateCCW));
     547    item = new UIListBtnTypeItem(m_menuType, tr("Delete"));
     548    item->setData(new Action(&IconView::actionDelete));
    515549    item = new UIListBtnTypeItem(m_menuType, tr("Import"));
    516550    item->setData(new Action(&IconView::actionImport));
    517551    item = new UIListBtnTypeItem(m_menuType, tr("Settings"));
     
    580614    }
    581615}
    582616
    583 void IconView::loadDirectory(const QString& dir)
     617void IconView::loadDirectory(const QString& dir, bool topleft)
    584618{
    585619    QDir d(dir);
    586620    if (!d.exists())
     
    590624    m_itemList.clear();
    591625    m_itemDict.clear();
    592626
    593     m_currRow = 0;
    594     m_currCol = 0;
     627    if( topleft ) {
     628        m_currRow = 0;
     629        m_currCol = 0;
     630        m_topRow  = 0;
     631    }
    595632    m_lastRow = 0;
    596633    m_lastCol = 0;
    597     m_topRow  = 0;
    598634
    599635    m_isGallery = GalleryUtil::loadDirectory(m_itemList, dir, false, &m_itemDict, m_thumbGen);;
    600636    m_lastRow = QMAX((int)ceilf((float)m_itemList.count()/(float)m_nCols)-1,0);
    601637    m_lastCol = QMAX(m_itemList.count()-m_lastRow*m_nCols-1,0);
     638
     639    if( !topleft ) {
     640        if( (unsigned int)(m_currRow * m_nCols + m_currCol) > (m_itemList.count()-1) ) {
     641            m_currRow = (m_itemList.count()-1) / m_nCols;
     642            m_currCol = (m_itemList.count()-1) % m_nCols;
     643            if( m_topRow > m_currRow ) {
     644                m_topRow = m_currRow;
     645            }
     646        }
     647    }
    602648}
    603649
    604650void IconView::loadThumbnail(ThumbItem *item)
     
    773819    }
    774820}
    775821
     822void IconView::actionDelete()
     823{
     824    ThumbItem* item = m_itemList.at(m_currRow * m_nCols +
     825                                    m_currCol);
     826    if (!item || item->isDir)
     827        return;
     828
     829    if( item->Remove() ) {
     830        loadDirectory(m_currDir, false);
     831    }
     832}
     833
    776834void IconView::actionSlideShow()
    777835{
    778836    ThumbItem* item = m_itemList.at(m_currRow * m_nCols +
  • svn/trunk/mythplugins/mythgallery/mythgallery/main.cpp

     
    4747            "Home");
    4848    REG_KEY("Gallery", "END", "Go to the last image in thumbnail view", "End");
    4949    REG_KEY("Gallery", "MENU", "Toggle activating menu in thumbnail view", "M");
     50    REG_KEY("Gallery", "SLIDESHOW", "Start Slideshow in thumbnail view", "S");
     51    REG_KEY("Gallery", "RANDOMSHOW", "Start Random Slideshow in thumbnail view", "R");
    5052
    5153    REG_KEY("Gallery", "ROTRIGHT", "Rotate image right 90 degrees", "],3");
    5254    REG_KEY("Gallery", "ROTLEFT", "Rotate image left 90 degrees", "[,1");
     
    6365    REG_KEY("Gallery", "LOWRIGHT", "Go to the lower-right corner of the image",
    6466            "PgDown");
    6567    REG_KEY("Gallery", "INFO", "Toggle Showing Information about Image", "I");
     68    REG_KEY("Gallery", "DELETE", "Delete current image", "D");
    6669}
    6770
    6871int mythplugin_init(const char *libversion)
  • svn/trunk/mythplugins/mythgallery/mythgallery/iconview.h

     
    5050
    5151    int GetRotationAngle();
    5252    void SetRotationAngle(int angle);
     53    bool Remove();
    5354
    5455    QPixmap *pixmap;
    5556    QString  name;
     
    7980private:
    8081
    8182    void loadTheme();
    82     void loadDirectory(const QString& dir);
     83    void loadDirectory(const QString& dir, bool topleft = true);
    8384
    8485    void updateMenu();
    8586    void updateText();
     
    9293
    9394    void actionRotateCW();
    9495    void actionRotateCCW();
     96    void actionDelete();
    9597    void actionSlideShow();
    9698    void actionRandomShow();
    9799    void actionSettings();