src/channelpalette.h

/***************************************************************************
                          channelPalette.h  -  description
                             -------------------
    begin                : Thur feb  26  12:06:21 EDT 2004
    copyright            : (C) 2003 by Lynn Hazan
    email                : lynn.hazan@myrealbox.com
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/
#ifndef CHANNELPALETTE_H
#define CHANNELPALETTE_H

//QT include files
#include <qvariant.h>
#include <qwidget.h>
#include <qvbox.h> 
#include <qiconview.h>
#include <qdict.h>
#include <qptrlist.h>
#include <qmap.h>
#include <qdragobject.h>
#include <qlabel.h>
#include <qcursor.h>

// application specific includes
#include "channelgroupview.h"
#include "channeliconview.h"

//General C++ include files
#include <iostream>
using namespace std;

// forward declaration
class QIconView;
class QIconViewItem;
class ChannelColors;
class SpaceWidget;

class ChannelPalette : public QScrollView
{
    Q_OBJECT
    
public:

    enum PaletteType {DISPLAY=0,SPIKE=1};
    
    ChannelPalette(PaletteType type,QColor backgroundColor,bool edition,QWidget* parent = 0, const char* name = 0, WFlags fl = 0 );
   /*
   *  Destroys the object and frees any allocated resources.
   */
   ~ChannelPalette();

    void createChannelLists(ChannelColors* channelColors,QMap<int, QValueList<int> >* groupsChannels,QMap<int,int>* channelsGroups);

    void selectChannels(const QValueList<int>& selectedChannels);

    void reset();
    
    const QValueList<int> selectedChannels();

    void changeBackgroundColor(QColor color);

    const QValueList<int> getShowHideChannels(bool showStatus);

    inline const QMap<int,bool>getSkipStatus(){return channelsSkipStatus;};

class ChannelIconItem : public QIconViewItem{

 public:
   inline ChannelIconItem(QIconView* parent,const QString& text,const QPixmap& icon):
     QIconViewItem(parent,text,icon){};

   inline ChannelIconItem(QIconView* parent,QIconViewItem* after,const QString& text,const QPixmap& icon):
     QIconViewItem(parent,after,text,icon){};

   virtual inline int compare(QIconViewItem* item) const{
    if(key().toInt() < item->key().toInt()) return -1;
    else if(key().toInt() == item->key().toInt()) return 0;
    else return 1;
   };
 };

    
public slots:
    virtual void changeColor(QIconViewItem* item,bool single = true);
    void createGroup();
    void setGreyScale(bool grey);
    void deleteEmptyGroups();
    void selectAllChannels();
    void deselectAllChannels();
    void slotChannelsMoved(QString targetGroup,QIconViewItem* after);
    void slotChannelsMoved(const QValueList<int>& channelIds,QString sourceGroup,QIconViewItem* after);
    void trashChannelsMovedAround(const QValueList<int>& channelIds,QString afterId,bool beforeFirst);
    void discardChannels();
    void discardChannels(const QValueList<int>& channelsToDiscard);
    void discardChannels(const QValueList<int>& channelsToDiscard,QString afterId,bool beforeFirst);    
    void discardSpikeChannels();
    void showChannels();
    void hideChannels();
    void hideUnselectAllChannels();
    void updateShowHideStatus(const QValueList<int>&channelIds,bool showStatus);
    void updateSkipStatus(const QMap<int,bool>& skipStatus);
    void updateSkipStatus(const QValueList<int>&channelIds,bool skipStatus);
    void updateColor(const QValueList<int>& channelIds);
    void updateColor(int channelId);
    void updateGroupColor(int channelId);
    void applyGroupColor(PaletteType paletteType);
    void applyCustomColor();
    void setEditMode(bool edition);
    void groupToMove(int sourceId,int targetId,int start, int destination);
    void removeChannelsFromTrash(const QValueList<int>& channelIds);
    void slotMousePressWoModificators(QString sourceGroup);
    inline void selectionTool(){
     emit channelsSelected(selectedChannels());
    };
    
protected slots:
    virtual void slotRightPressed(QIconViewItem* item);
    virtual void slotMousePressed(int button,QIconViewItem* item);
    void slotMousePressed(QString sourceGroupName);
    virtual void slotMidButtonPressed(QString sourceGroupId);   
    virtual void slotClickRedraw();
    virtual void languageChange();
    virtual void createGroup(int id);
    virtual void setChannelLists();
    virtual void resizeEvent(QResizeEvent* event);
    virtual void drawContents(QPainter* painter);
    inline void slotDragLabeltMoved(QPoint position){ensureVisible(position.x(),position.y());};
    
signals:
    void singleChangeColor(int selectedChannel);
    void groupChangeColor(int groupId);
    //void channelsChangeColor(QValueList<int> selectedChannels);
    void updateShownChannels(const QValueList<int>& shownChannels);
    void updateHideChannels(const QValueList<int>& hiddenChannels);
    void paletteResized(int parentWidth,int labelSize);
    void channelsDiscarded(const QValueList<int>& discarded);
    void setDragAndDrop(bool dragAndDrop);
    void groupModified();
    void channelsMovedToTrash(const QValueList<int>&channelIds,QString afterId,bool beforeFirst);
    void channelsMovedAroundInTrash(const QValueList<int>& channelsToDiscard,QString afterId,bool beforeFirst);
    void channelsRemovedFromTrash(const QValueList<int>& channelIds);
    void channelsSelected(const QValueList<int>& selectedChannels);
    
private:    
    ChannelColors* channelColors;

    QColor backgroundColor;

    bool isInSelectItems;

    QVBox* verticalContainer;

    QDict<ChannelIconView> iconviewDict;

    QDict<ChannelGroupView> channelGroupViewDict;

    SpaceWidget* spaceWidget;

    QMap<int,int>* channelsGroups;

    QMap<int, QValueList<int> >* groupsChannels;
 
    int labelSize;
    
    bool greyScale;

    bool isGroupToRemove;

    PaletteType type;

    QMap<int,bool> channelsShowHideStatus;
    
    bool edit;

    QString selected;
    
    QMap<int,bool> channelsSkipStatus;
   
    QMap<QString,bool> selectionStatus;    
    
   //Functions
    
    void updateShowHideStatus(bool showStatus);

    void drawItem(QPainter& painter,QPixmap* pixmap,QColor color,bool show,bool skip);

    void moveTrashesToBottom();

    void moveChannels(const QValueList<int>& channelIds,QString sourceGroup,QIconViewItem* after);

    void moveChannels(const QValueList<int>& channelIds,QString sourceGroup,QString targetGroup);

    void trashChannels(int destinationGroup);

    void moveChannels(int targetGroup);

    int createEmptyGroup();
};

class SpaceWidget : public QWidget{
 Q_OBJECT
  public:
   inline SpaceWidget(QWidget* parent,bool drag):QWidget(parent),drag(drag){
    setAcceptDrops(TRUE); 
   };
   
   inline virtual void dropEvent(QDropEvent* event){
    if(event->source() == 0 || !drag){
        event->ignore();
        return;
    }

    QString information;
    if(QTextDrag::decode(event,information)){
     int groupSource = information.section("-",0,0).toInt();
     int start = information.section("-",1,1).toInt();
     //to inform that the target is the SpaceWidget, put -2 as the target group.
     emit dropLabel(groupSource,-2,start,QWidget::mapToGlobal(event->pos()).y());
    }
   };

   inline virtual void dragEnterEvent(QDragEnterEvent* event){
    if(event->source() == 0 || !drag){
       event->ignore();
       return;
    }
    event->accept(QTextDrag::canDecode(event));
   };

  public slots:
    inline void setDragAndDrop(bool dragDrop){drag = dragDrop;};

  signals:
   void dropLabel(int sourceId,int targetId,int start, int destination);

  private:
   bool drag;
      
};

class GroupLabel : public QLabel{
 Q_OBJECT
  public:
   inline GroupLabel(const QString& text,QWidget* parent,const char* name = 0,WFlags f = 0):
    QLabel(text,parent,name,f){};

  signals:
    void middleClickOnLabel(QString sourceId);
    void leftClickOnLabel(QString sourceId);
     
  protected:
   virtual inline void mousePressEvent(QMouseEvent* e){
    if(e->button() == QMouseEvent::LeftButton){

     QPoint firstClick = QWidget::mapToGlobal(e->pos());
     QString information = parent()->name();
     information.append(QString("-%1").arg(firstClick.y()));
     QDragObject* drag = new QTextDrag(information,this);
     drag->dragMove();       
     
     emit leftClickOnLabel(parent()->name());
    }
    if(e->button() == QMouseEvent::MidButton){
     emit middleClickOnLabel(parent()->name()); 
    }
   };
};

#endif // CHANNELPALETTE_H

---