Packman Build Service PMBS

gogglesmm.changes Changed

gogglesmm.spec Changed

gogglesmm-0.12.6.tar.bz2/ChangeLog -> gogglesmm-0.12.7.tar.bz2/ChangeLog Changed

gogglesmm-0.12.6.tar.bz2/build/version -> gogglesmm-0.12.7.tar.bz2/build/version Changed

gogglesmm-0.12.6.tar.bz2/extra/gogglesmm_22.png -> gogglesmm-0.12.7.tar.bz2/extra/gogglesmm_22.png Changed

gogglesmm-0.12.6.tar.bz2/extra/gogglesmm_24.png -> gogglesmm-0.12.7.tar.bz2/extra/gogglesmm_24.png Changed

gogglesmm-0.12.6.tar.bz2/extra/gogglesmm_48.png -> gogglesmm-0.12.7.tar.bz2/extra/gogglesmm_48.png Changed

gogglesmm-0.12.6.tar.bz2/icons/about.png -> gogglesmm-0.12.7.tar.bz2/icons/about.png Changed

gogglesmm-0.12.6.tar.bz2/src/GMAudioScrobbler.cpp -> gogglesmm-0.12.7.tar.bz2/src/GMAudioScrobbler.cpp Changed

@@ -324,11 +324,12 @@
 
 FXbool GMAudioScrobbler::post_request(const FXString & url,const FXString & message,FXString & output) {
   FXTRACE((60,"post_request %s - %s\n",url.text(),message.text()));
-  if (client->basic("POST",url,
+  HttpClient client;
+  if (client.basic("POST",url,
                       "Content-Type: application/x-www-form-urlencoded\r\n"
                       "Connection: close\r\n",
                        message)) {
-    output = client->body();
+    output = client.body();
     return true;
     }
   else {
@@ -340,8 +341,9 @@
 
 FXbool GMAudioScrobbler::get_request(const FXString & url,FXString & output) {
   FXTRACE((60,"get_request\n"));
-  if (client->basic("GET",url,"Connection: close\r\n")) {
-    output = client->body();
+  HttpClient client;
+  if (client.basic("GET",url,"Connection: close\r\n")) {
+    output = client.body();
     return true;
     }
   else {
@@ -372,8 +374,6 @@
   nsubmitted(0),
   nfailed(0) {
 
-  client = new HttpClient();
-
   username=FXApp::instance()->reg().readStringEntry("LastFM","username",NULL);
   password=FXApp::instance()->reg().readStringEntry("LastFM","password",NULL);
 
@@ -421,7 +421,6 @@
 
 GMAudioScrobbler::~GMAudioScrobbler(){
   save_queue();
-  delete client;
   }
 
 
@@ -1103,6 +1102,7 @@
     if (!service.parse(response) || !service.getStatus()) {
       FXTRACE((60,"last.fm service failed with code %d: %s\n",service.getErrorCode(),service.getErrorMessage().text()));
       switch(service.getErrorCode()) {
+        case LASTFM_ERROR_UNKNOWN      :
         case LASTFM_ERROR_OFFLINE      :
         case LASTFM_ERROR_UNAVAILABLE  : set_timeout();           break;
         case LASTFM_ERROR_BADSESSION   : session.clear();         break;
@@ -1307,8 +1307,9 @@
     if (!service.parse(response) || !service.getStatus()) {
       FXTRACE((60,"last.fm service failed with code %d: %s\n",service.getErrorCode(),service.getErrorMessage().text()));
       switch(service.getErrorCode()) {
+        case LASTFM_ERROR_UNKNOWN      :
         case LASTFM_ERROR_OFFLINE      :
-        case LASTFM_ERROR_UNAVAILABLE  : set_timeout(); break;
+        case LASTFM_ERROR_UNAVAILABLE  : set_timeout();           break;
         case LASTFM_ERROR_BADSESSION   : session.clear();         break;
         case LASTFM_ERROR_KEY_INVALID  :
         case LASTFM_ERROR_KEY_SUSPENDED: flags|=FLAG_BANNED;      break;

gogglesmm-0.12.6.tar.bz2/src/GMAudioScrobbler.h -> gogglesmm-0.12.7.tar.bz2/src/GMAudioScrobbler.h Changed

gogglesmm-0.12.7.tar.bz2/src/GMCoverCache.cpp Added

@@ -0,0 +1,425 @@
+/*******************************************************************************
+*                         Goggles Music Manager                                *
+********************************************************************************
+*           Copyright (C) 2006-2010 by Sander Jansen. All Rights Reserved      *
+*                               ---                                            *
+* 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 3 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, see http://www.gnu.org/licenses.           *
+********************************************************************************/
+#include "gmdefs.h"
+#include "gmutils.h"
+#include "GMTaskManager.h"
+//#include "GMTrack.h"
+#include "GMApp.h"
+//#include "GMCover.h"
+#include "GMTag.h"
+#include "GMList.h"
+#include "GMTrackList.h"
+#include "GMSource.h"
+#include "GMTrackView.h"
+#include "GMTrackDatabase.h"
+#include "GMPlayerManager.h"
+#include "GMIconTheme.h"
+#include "GMCoverCache.h"
+
+
+void FXIntMap::save(FXStream & store) const {
+  store << no();
+  for (FXuint i=0;i<size();i++){
+    if (!empty(i)) {
+      store << key(i);
+      store << value(i);
+      }
+    }
+  }
+
+void FXIntMap::load(FXStream & store) {
+  FXint key,value,no;
+  store >> no;
+  for (FXint i=0;i<no;i++){
+    store >> key;
+    store >> value;
+    insert(key,value);
+    }
+  }
+
+
+
+class GMCompressedImage {
+public:
+  FXuchar * buffer;
+  FXuval    len;
+public:
+  GMCompressedImage() : buffer(NULL),len(0){}
+  GMCompressedImage(FXuchar * b,FXuval l) : len(l) {
+    allocElms(buffer,len);
+    memcpy(buffer,b,len);
+    }
+
+  void make(FXImage * img) {
+    FXint ww,hh,dd;
+    FXColor * data=NULL;
+    FXMemoryStream ms(FXStreamLoad,buffer,len,false);
+    fxloadJPG(ms,data,ww,hh,dd);
+    ms.close();
+    FXASSERT(ww==128);
+    FXASSERT(hh==128);
+
+    img->setData(data,IMAGE_OWNED);
+    img->render();
+    }
+
+  ~GMCompressedImage() {
+    freeElms(buffer);
+    }
+
+  void load(FXStream & store) {
+    store >> len;
+    allocElms(buffer,len);
+    store.load(buffer,len);
+    }
+
+  void save(FXStream & store) const {
+    store << len;
+    store.save(buffer,len);
+    }
+
+  };
+
+
+
+
+class CoverLoader: public GMTask {
+protected:
+  FXuchar * compress_buffer;
+  FXuval    compress_buffer_length;
+  FXuval    total_c;
+  FXuval    total_u;
+public:
+  GMAlbumPathList albums;
+  GMCoverCache    cache;
+protected:
+  GMCompressedImage*  compress(FXColor*,FXint,FXint);
+  GMCompressedImage*  compress(FXImage*);
+  GMCompressedImage*  compress_fit(FXImage*);
+  FXint run();
+public:
+  CoverLoader(GMAlbumPathList & l,FXint sz,FXObject *tgt=NULL,FXSelector sel=0);
+  ~CoverLoader();
+  };
+
+
+
+
+CoverLoader::CoverLoader(GMAlbumPathList & list,FXint sz,FXObject * tgt,FXSelector sel)
+  : GMTask(tgt,sel), cache(sz) {
+  albums.adopt(list);
+  compress_buffer=NULL;
+  compress_buffer_length=0;
+  }
+
+CoverLoader::~CoverLoader(){
+  freeElms(compress_buffer);
+  }
+
+
+FXint CoverLoader::run() {
+  FXdouble fraction;
+  GMCover * cover=NULL;
+  for (FXint i=0;i<albums.no() && processing;i++){
+    fraction = (i+1) / ((double)albums.no());
+    taskmanager->setStatus(FXString::value("Loading Covers %d%%",(FXint)(100.0*fraction)));
+    cover = GMCover::fromTag(albumsi.path);
+    if (cover==NULL)
+      cover = GMCover::fromPath(FXPath::directory(albumsi.path));
+    if (cover) {
+      cache.insertCover(albumsi.id,compress(GMCover::toImage(cover,cache.getCoverSize(),1)));
+      }
+    else {
+      cache.insertCover(albumsi.id,NULL);
+      }
+    }
+  if (processing) cache.save();
+  return 0;
+  }
+
+
+GMCompressedImage * CoverLoader::compress_fit(FXImage*img) {
+  FXint size = cache.getCoverSize();
+
+  FXColor * pix=NULL;
+  allocElms(pix,size*size);
+
+
+  memset(pix,255,4*size*size);
+
+  FXuchar * dst = (FXuchar*)pix;
+  FXuchar * src = (FXuchar*)img->getData();
+  FXint sw=img->getWidth()*4;
+  FXint sh=img->getHeight();
+
+
+  if (img->getHeight()<size)
+    dst+=(size*4)*((size-img->getHeight())>>1);
+
+  if (img->getWidth()<cache.getCoverSize())
+    dst+=4*((size-img->getWidth())>>1);
+
+  do {
+    memcpy(dst,src,sw);
+    dst+=size*4;
+    src+=sw;
+    }
+  while(--sh);
+
+  GMCompressedImage * c = compress(pix,size,size);
+  freeElms(pix);
+  return c;
+  }
+
+GMCompressedImage * CoverLoader::compress(FXColor*pix,FXint width,FXint height){
+  FXMemoryStream ms(FXStreamSave,compress_buffer,compress_buffer_length,true);
+  fxsaveJPG(ms,pix,width,height,75);
+  ms.takeBuffer(compress_buffer,compress_buffer_length);
+  ms.close();
+  return new GMCompressedImage(compress_buffer,ms.position());
+  }
+
+
+GMCompressedImage * CoverLoader::compress(FXImage*img) {
+  GMCompressedImage * cimage = NULL;
+  if (img->getWidth()!=cache.getCoverSize() || img->getHeight()!=cache.getCoverSize()) {
+    cimage = compress_fit(img);
+    }
+  else {
+    cimage = compress(img->getData(),cache.getCoverSize(),cache.getCoverSize());
+    }
+  delete img;
+  return cimage;
+  }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+FXDEFMAP(GMCoverCache) GMCoverCacheMap={
+  FXMAPFUNC(SEL_TASK_COMPLETED,GMCoverCache::ID_COVER_LOADER,GMCoverCache::onCmdCoversLoaded),
+  };
+
+FXIMPLEMENT(GMCoverCache,FXObject,GMCoverCacheMap,ARRAYNUMBER(GMCoverCacheMap));
+
+
+
+
+GMCoverCache::GMCoverCache(FXint size) : basesize(size),initialized(false) {
+  }
+
+
+GMCoverCache::~GMCoverCache() {
+  for (FXint i=0;i<covers.no();i++) {
+    delete coversi;
+    }
+  for (FXint i=0;i<buffers.no();i++) {
+    delete buffersi;
+    }
+  }
+
+void GMCoverCache::clear() {
+  for (FXint i=0;i<covers.no();i++) {
+    delete coversi;
+    }
+  }
+
+
+FXString GMCoverCache::getCacheFile() const {
+  return GMApp::getCacheDirectory()+PATHSEPSTRING+"albumcovers.cache";
+  }
+
+void GMCoverCache::adopt(GMCoverCache & src) {
+
+  clear(); /// clear
+  reset(); /// reset buffers
+
+  covers.adopt(src.covers);
+  gm_copy_hash(src.map,map);
+
+  src.covers.clear();
+  src.map.clear();
+  }
+
+
+
+void GMCoverCache::drawCover(FXint id,FXDC & dc,FXint x,FXint y){
+  FXint index = map.find(id);
+  if (index>0) {
+    FXImage * image = getCoverImage(id);
+    dc.drawImage(image,x,y);
+    return;
+    }
+  else {
+    FXIcon * ic = GMIconTheme::instance()->icon_nocover;
+    if (ic->getHeight()<basesize)
+      y+=(basesize-ic->getHeight())>>1;
+    if (ic->getWidth()<basesize)
+      x+=(basesize-ic->getWidth())>>1;
+    dc.drawIcon(ic,x,y);
+    }
+  }
+
+
+void GMCoverCache::insertCover(FXint id,GMCompressedImage * image) {
+  if (image) {
+    covers.append(image);
+    map.insert(id,covers.no());
+    }
+  }
+
+void GMCoverCache::markCover(FXint id) {
+  for (FXint i=0,index;i<buffers.no();i++){
+    index=(FXint)(FXival)buffersi->getUserData();
+    if (index==-id) {
+      buffersi->setUserData((void*)(FXival)id);
+      break;
+      }
+    }
+  }
+
+
+void GMCoverCache::reset() {
+  for (FXint i=0,index;i<buffers.no();i++){
+    index=(FXint)(FXival)buffersi->getUserData();
+    buffersi->setUserData((void*)(FXival)-index);
+    }
+  }
+
+FXImage* GMCoverCache::getCoverImage(FXint id) {
+  FXint i,index;
+  FXImage * image=NULL;
+
+  /// existing
+  for (i=0;i<buffers.no();i++){
+    index=(FXint)(FXival)buffersi->getUserData();
+    if (index==id) return buffersi;
+    }
+
+  /// find empty
+  for (i=0;i<buffers.no();i++){
+    index=(FXint)(FXival)buffersi->getUserData();
+    if (index<0) {
+      buffersi->setUserData((void*)(FXival)id);
+      image=buffersi;
+      break;
+      }
+    }
+
+  /// Create new one
+  if (image==NULL) {
+    image = new FXImage(FXApp::instance(),NULL,0,basesize,basesize);
+    image->setUserData((void*)(FXival)id);
+    image->create();
+    buffers.append(image);
+    }
+
+  index = map.find(id);
+  coversindex-1->make(image);
+  return image;
+  }
+
+
+void GMCoverCache::init(GMTrackDatabase * database){
+  if (!initialized && !load()) {
+    refresh(database);
+    }
+  }
+
+void GMCoverCache::refresh(GMTrackDatabase * database){
+
+  /// Remove the cache file.
+  if (FXStat::exists(getCacheFile()))
+    FXFile::remove(getCacheFile());
+
+  /// Only scan for covers if needed
+  if (initialized) {
+    GMAlbumPathList list;
+    database->listAlbumPaths(list);
+    if (list.no()){
+      CoverLoader * task = new CoverLoader(list,basesize,this,ID_COVER_LOADER);
+      GMPlayerManager::instance()->runTask(task);
+      }
+    }
+  }
+
+#define COVERTHUMBS_CACHE_FILE_VERSION 20110920
+
+void GMCoverCache::save() const {
+  const FXuint version=COVERTHUMBS_CACHE_FILE_VERSION;
+  FXFileStream store;
+  if (store.open(getCacheFile(),FXStreamSave)){
+    store << version;
+    store << basesize;
+    map.save(store);
+    store << (FXint)covers.no();
+    for (FXint i=0;i<covers.no();i++){
+      coversi->save(store);
+      }
+    }
+  }
+
+FXbool GMCoverCache::load() {
+  GM_TICKS_START();
+  initialized=true;
+  FXFileStream store;
+  if (store.open(getCacheFile(),FXStreamLoad)) {
+    FXint no,size;
+    FXuint version;
+
+    store >> version;
+    if (version!=COVERTHUMBS_CACHE_FILE_VERSION)
+      return false;
+
+    store >> size;
+    if (basesize!=size)
+      return false;
+
+    map.load(store);
+    store >> no;
+    for (FXint i=0;i<no;i++) {
+      GMCompressedImage * cover=new GMCompressedImage();
+      cover->load(store);
+      covers.append(cover);
+      }
+    return true;
+    }
+  GM_TICKS_END();
+  return false;
+  }
+
+
+long GMCoverCache::onCmdCoversLoaded(FXObject*,FXSelector,void*ptr){
+  CoverLoader * task = reinterpret_cast<CoverLoader*>(*((void**)ptr));
+  adopt(task->cache);
+  delete task;
+  GMPlayerManager::instance()->getTrackView()->redrawAlbumList();
+  return 1;
+  }
+
+

gogglesmm-0.12.7.tar.bz2/src/GMCoverCache.h Added

@@ -0,0 +1,82 @@
+/*******************************************************************************
+*                         Goggles Music Manager                                *
+********************************************************************************
+*           Copyright (C) 2006-2010 by Sander Jansen. All Rights Reserved      *
+*                               ---                                            *
+* 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 3 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, see http://www.gnu.org/licenses.           *
+********************************************************************************/
+#ifndef GMCOVERTHUMBS_H
+#define GMCOVERTHUMBS_H
+
+class GMImageMap;
+class GMCompressedImage;
+
+class FXIntMap : public FXHash {
+public:
+  FXint insert(FXint name,FXint value) { return (FXint)(FXival)FXHash::insert((void*)(FXival)name,(void*)(FXival)value); }
+  FXint replace(FXint name,FXint value) { return (FXint)(FXival)FXHash::replace((void*)(FXival)name,(void*)(FXival)value); }
+  FXint remove(FXint name) {  return (FXint)(FXival)FXHash::remove((void*)(FXival)name); }
+  FXint find(FXint name) const { return (FXint)(FXival)FXHash::find((void*)(FXival)name); }
+  FXint key(FXuint pos) const { return (FXint)(FXival)tablepos.name; }
+  FXint value(FXuint pos) const { return (FXint)(FXival)tablepos.data; }
+  void load(FXStream & store);
+  void save(FXStream & store) const;
+  };
+
+
+
+class GMCoverCache : FXObject {
+FXDECLARE(GMCoverCache)
+protected:
+  FXPtrListOf<GMCompressedImage> covers;
+  FXPtrListOf<FXImage>           buffers;
+  FXIntMap                       map;
+  FXint                          basesize;
+  FXbool                         initialized;
+protected:
+  FXImage * getCoverImage(FXint id);
+  void adopt(GMCoverCache &);
+  FXbool load();
+  FXString getCacheFile() const;
+public:
+  enum {
+    ID_COVER_LOADER = 1
+    };
+public:
+  long onCmdCoversLoaded(FXObject*,FXSelector,void*ptr);
+public:
+  GMCoverCache(FXint size=128);
+
+  void init(GMTrackDatabase*);
+
+  void refresh(GMTrackDatabase*);
+
+  void drawCover(FXint id,FXDC & dc,FXint x,FXint y);
+
+  void markCover(FXint id);
+
+  void reset();
+
+  void clear();
+
+  FXint getCoverSize() const { return basesize; }
+
+  void insertCover(FXint id,GMCompressedImage*);
+
+  void save() const;
+
+  ~GMCoverCache();
+  };
+
+#endif

gogglesmm-0.12.6.tar.bz2/src/GMFilename.cpp -> gogglesmm-0.12.7.tar.bz2/src/GMFilename.cpp Changed

gogglesmm-0.12.6.tar.bz2/src/GMImportDialog.cpp -> gogglesmm-0.12.7.tar.bz2/src/GMImportDialog.cpp Changed

@@ -28,14 +28,14 @@
 #include "GMImportDialog.h"
 
 
-extern const FXchar gmfilepatterns="All Music (*.mp3,*.ogg,*.oga,*.flac,*.mpc"
+extern const FXchar gmfilepatterns="All Music (*.mp3,*.ogg,*.oga,*.flac,*.mpc,*.wav"
 #if defined(TAGLIB_WITH_MP4) && (TAGLIB_WITH_MP4==1)
 ",*.aac,*.m4a,*.m4p,*.mp4,*.m4b"
 #endif
 #if defined(TAGLIB_WITH_ASF) && (TAGLIB_WITH_ASF==1)
 ",*.wma,*.asf"
 #endif
-")\nFree Lossless Audio Codec (*.flac)\n"
+")\nFree Lossless Audio Codec (*.flac)\nWaveform Audio File Format (*.wav)\n"
 "MPEG-1 Audio Layer 3 (*.mp3)\n"
 #if defined(TAGLIB_WITH_MP4) && (TAGLIB_WITH_MP4==1)
 "MPEG-4 Part 14 (*.mp4,*.m4a,*.m4p,*.aac,*.m4b)\n"
@@ -107,14 +107,6 @@
   dirbox->setAssociations(filedict);
   delete old;
 #endif
-/*
-  getFirst()->hide();
-  FXFrame * frame=(FXFrame*)getFirst()->getNext();
-  frame->setPadLeft(0);
-  frame->setPadRight(0);
-  frame->setPadTop(0);
-  frame->setPadBottom(0);
-*/
   }
 
 GMDirSelector::~GMDirSelector(){
@@ -287,6 +279,7 @@
   "ogg",";Ogg Vorbis",
   "oga",";Ogg Audio",
   "flac",";Free Lossless Audio Codec",
+  "wav",";Waveform Audio File Format",
   "mpc",";Musepack",
 #if defined(TAGLIB_WITH_ASF) && (TAGLIB_WITH_ASF==1)
   "wma",";Windows Media",
@@ -692,6 +685,7 @@
     "ogg",
     "OGG",
     "Ogg",
+    "wav",
 #if defined(TAGLIB_WITH_MP4) && (TAGLIB_WITH_MP4==1)
     "mp4",
     "MP4",

gogglesmm-0.12.6.tar.bz2/src/GMNotifyDaemon.cpp -> gogglesmm-0.12.7.tar.bz2/src/GMNotifyDaemon.cpp Changed

gogglesmm-0.12.6.tar.bz2/src/GMPlayerManager.cpp -> gogglesmm-0.12.7.tar.bz2/src/GMPlayerManager.cpp Changed

@@ -124,15 +124,33 @@
 
       FXuint state=0;
       enum {
-        NETWORK_STATE_UNKNOWN      = 0,
-        NETWORK_STATE_ASLEEP       = 1,
-        NETWORK_STATE_CONNECTING   = 2,
-        NETWORK_STATE_CONNECTED    = 3,
-        NETWORK_STATE_DISCONNECTED = 4
+/*
+        // Network Manager 0.7 / 0.8
+
+        NM7_STATE_UNKNOWN          =  0,
+        NM7_STATE_ASLEEP           =  1,
+        NM7_STATE_CONNECTING       =  2,
+        NM7_STATE_CONNECTED        =  3,
+        NM7_STATE_DISCONNECTED     =  4,
+
+        // Network Manager 0.9
+        NM9_STATE_UNKNOWN          =  0,
+        NM9_STATE_ASLEEP           = 10,
+        NM9_STATE_DISCONNECTED     = 20,
+        NM9_STATE_DISCONNECTING    = 30,
+        NM9_STATE_CONNECTING       = 40,
+        NM9_STATE_CONNECTED_LOCAL  = 50,
+        NM9_STATE_CONNECTED_SITE   = 60,
+        NM9_STATE_CONNECTED_GLOBAL = 70,
+
+*/
+        NM7_STATE_CONNECTED        =  3,
+        NM9_STATE_CONNECTED_GLOBAL = 70,
         };
 
       if (dbus_message_get_args(msg,NULL,DBUS_TYPE_UINT32,&state,DBUS_TYPE_INVALID)) {
-        if (p->getAudioScrobbler() && state==NETWORK_STATE_CONNECTED)
+        if (p->getAudioScrobbler() && (state==NM7_STATE_CONNECTED ||
+                                       state==NM9_STATE_CONNECTED_GLOBAL))
           p->getAudioScrobbler()->nudge();
         }
       return DBUS_HANDLER_RESULT_HANDLED;

gogglesmm-0.12.6.tar.bz2/src/GMSearch.cpp -> gogglesmm-0.12.7.tar.bz2/src/GMSearch.cpp Changed

@@ -332,15 +332,8 @@
       }
     else if (FXStat::isFile(filesi)) {
       ext = FXPath::extension(filesi);
-/*      
-      if (comparecase(ext,"m3u")==0 ||
-          comparecase(ext,"xspf")==0) ||
-          comparecase(ext,"pls")==0) {        
-        playlists.append(filesi);            
-        }    
-*/      
-      
-      if (comparecase(ext,"mp3")==0 || comparecase(ext,"ogg")==0 || comparecase(ext,"oga")==0 || comparecase(ext,"flac")==0 || comparecase(ext,"mpc")==0
+
+      if (comparecase(ext,"mp3")==0 || comparecase(ext,"ogg")==0 || comparecase(ext,"oga")==0 || comparecase(ext,"flac")==0 || comparecase(ext,"mpc")==0 || comparecase(ext,"wav")==0
 #if defined(TAGLIB_WITH_ASF) && (TAGLIB_WITH_ASF==1)
       || comparecase(ext,"wma")==0 || comparecase(ext,"asf")==0
 #endif
@@ -414,7 +407,7 @@
 
   if (!running) return;
 
-  no=FXDir::listFiles(files,dir,"*.(ogg,oga,mp3,mpc,flac"
+  no=FXDir::listFiles(files,dir,"*.(ogg,oga,mp3,mpc,flac,wav"
 #if defined(TAGLIB_WITH_MP4) && (TAGLIB_WITH_MP4==1)
        ",mp4,m4a,aac,m4p,m4b"
 #endif

gogglesmm-0.12.7.tar.bz2/src/GMTaskManager.cpp Added

@@ -0,0 +1,121 @@
+/*******************************************************************************
+*                         Goggles Music Manager                                *
+********************************************************************************
+*           Copyright (C) 2006-2010 by Sander Jansen. All Rights Reserved      *
+*                               ---                                            *
+* 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 3 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, see http://www.gnu.org/licenses.           *
+********************************************************************************/
+#include "gmdefs.h"
+#include "gmutils.h"
+#include "GMApp.h"
+#include "GMTaskManager.h"
+
+
+GMTask::GMTask(FXObject*tgt,FXSelector sel) : taskmanager(NULL),mc(NULL),processing(true),target(tgt),message(sel) {
+  }
+
+GMTask::~GMTask() {
+  }
+
+GMTaskManager::GMTaskManager(FXObject*tgt,FXSelector sel) : processing(false),started(false),active(NULL),target(tgt),message(sel),mc(FXApp::instance())  {
+  }
+
+GMTaskManager::~GMTaskManager() {
+  }
+
+void GMTaskManager::setStatus(const FXString & msg) {
+  if (target) mc.message(target,FXSEL(SEL_TASK_STATUS,message),msg.text(),msg.length()+1);
+  }
+
+void GMTaskManager::run(GMTask* task) {
+  mutex.lock();
+  tasks.append(task);
+  task->mc = &mc;
+  task->taskmanager = this;
+  processing=true;
+  if (!started) {
+    started=true;
+    mutex.unlock();
+    start();
+    }
+  else {
+    condition_task.signal();
+    mutex.unlock();
+    }
+  }
+
+FXbool GMTaskManager::next() {
+  mutex.lock();
+  if (tasks.no()) {
+    active = tasks0;
+    tasks.erase(0);
+    }
+  else {
+    active=NULL;
+    }
+  mutex.unlock();
+  return ((active!=NULL) && processing);
+  }
+
+FXbool GMTaskManager::wait() {
+  if (processing) {
+    if (target) mc.message(target,FXSEL(SEL_TASK_IDLE,message),NULL,0);
+    mutex.lock();
+    condition_task.wait(mutex);
+    mutex.unlock();
+    }
+  return processing;
+  }
+
+FXint GMTaskManager::run() {
+  ap_set_thread_name("gm_taskmanager");
+  do {
+    while(next()) {
+      if (target) mc.message(target,FXSEL(SEL_TASK_RUNNING,message),NULL,0);
+      FXint code = active->run();
+      mutex.lock();
+      if (target) {
+
+        if (code)
+          mc.message(active->target,FXSEL(SEL_TASK_CANCELLED,active->message),&active,sizeof(GMTask*));
+        else
+          mc.message(active->target,FXSEL(SEL_TASK_COMPLETED,active->message),&active,sizeof(GMTask*));
+
+        active=NULL;
+        }
+      else {
+        delete active;
+        active=NULL;
+        }
+      mutex.unlock();
+      }
+    }
+  while(wait());
+  return 0;
+  }
+
+void GMTaskManager::cancelTask() {
+  FXMutexLock lock(mutex);
+  if (active) active->processing=false;
+  }
+
+void GMTaskManager::shutdown() {
+  mutex.lock();
+  if (active) active->processing=false;
+  processing=false;
+  condition_task.signal();
+  mutex.unlock();
+  join();
+  started=false;
+  }

gogglesmm-0.12.7.tar.bz2/src/GMTaskManager.h Added

@@ -0,0 +1,83 @@
+/*******************************************************************************
+*                         Goggles Music Manager                                *
+********************************************************************************
+*           Copyright (C) 2006-2010 by Sander Jansen. All Rights Reserved      *
+*                               ---                                            *
+* 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 3 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, see http://www.gnu.org/licenses.           *
+********************************************************************************/
+#ifndef GMTHREAD_H
+#define GMTHREAD_H
+
+class GMTaskManager;
+
+class GMTask {
+friend class GMTaskManager;
+private:
+  GMTask(const GMTask&);
+  GMTask &operator=(const GMTask&);
+protected:
+  GMTaskManager    * taskmanager;
+  FXMessageChannel * mc;
+  volatile FXbool    processing;
+protected:
+  FXObject * target;
+  FXSelector message;
+public:
+  GMTask(FXObject*tgt=NULL,FXSelector sel=0);
+
+  void setTarget(FXObject * tgt) { target=tgt; }
+
+  void setSelector(FXSelector sel) { message=sel; }
+
+  virtual FXint run() = 0;
+
+  virtual ~GMTask();
+  };
+
+typedef FXArray<GMTask*> GMTaskList;
+
+class GMTaskManager : public FXThread {
+protected:
+  FXMutex           mutex;
+  FXCondition       condition_task;
+  volatile FXbool   processing;
+  FXbool            started;
+protected:
+  FXbool wait();
+  FXbool next();
+protected:
+  GMTask          * active;
+  FXObject*         target;
+  FXSelector        message;
+  FXMessageChannel  mc;
+  GMTaskList        tasks;
+protected:
+  FXint run();
+public:
+  GMTaskManager(FXObject*tgt=NULL,FXSelector sel=0);
+
+  void run(GMTask*);
+  void shutdown();
+  void cancelTask();
+
+  void setStatus(const FXString &);
+
+  virtual ~GMTaskManager();
+  };
+
+
+#endif
+
+
+

gogglesmm-0.12.6.tar.bz2/src/GMTrackView.cpp -> gogglesmm-0.12.7.tar.bz2/src/GMTrackView.cpp Changed

gogglesmm-0.12.6.tar.bz2/src/ap_http.cpp -> gogglesmm-0.12.7.tar.bz2/src/ap_http.cpp Changed

gogglesmm-0.12.6.tar.bz2/src/ap_http.h -> gogglesmm-0.12.7.tar.bz2/src/ap_http.h Changed

gogglesmm-0.12.6.tar.bz2/src/gmutils.cpp -> gogglesmm-0.12.7.tar.bz2/src/gmutils.cpp Changed

Changes of Revision 10