Widget.h

Go to the documentation of this file.

/********************************************************************
**                Image Component Library (ICL)                    **
**                                                                 **
** Copyright (C) 2006-2013 CITEC, University of Bielefeld          **
**                         Neuroinformatics Group                  **
** Website: www.iclcv.org and                                      **
**          http://opensource.cit-ec.de/projects/icl               **
**                                                                 **
** File   : ICLQt/src/ICLQt/Widget.h                               **
** Module : ICLQt                                                  **
** Authors: Christof Elbrechter                                    **
**                                                                 **
**                                                                 **
** GNU LESSER GENERAL PUBLIC LICENSE                               **
** This file may be used under the terms of the GNU Lesser General **
** Public License version 3.0 as published by the                  **
**                                                                 **
** Free Software Foundation and appearing in the file LICENSE.LGPL **
** included in the packaging of this file.  Please review the      **
** following information to ensure the license requirements will   **
** be met: http://www.gnu.org/licenses/lgpl-3.0.txt                **
**                                                                 **
** The development of this software was supported by the           **
** Excellence Cluster EXC 277 Cognitive Interaction Technology.    **
** The Excellence Cluster EXC 277 is a grant of the Deutsche       **
** Forschungsgemeinschaft (DFG) in the context of the German       **
** Excellence Initiative.                                          **
**                                                                 **
********************************************************************/

#pragma once

#include <ICLUtils/CompatMacros.h>
#include <ICLCore/ImgBase.h>
#include <QtOpenGL/QGLWidget>
#include <ICLCore/Types.h>
#include <ICLQt/ImageStatistics.h>
#include <ICLQt/MouseHandler.h>
#include <ICLQt/WidgetCaptureMode.h>
#include <ICLQt/GUI.h>
#include <ICLUtils/Function.h>
#include <ICLCore/Color.h>

namespace icl{
  namespace qt{

    class PaintEngine;
    class OSDGLButton;

    class ICLQt_API ICLWidget : public QGLWidget{
      Q_OBJECT
      public:
      friend class OSDGLButton;

      class Data;
      class OutputBufferCapturer;

      enum fitmode{
        fmNoScale=0,  
        fmHoldAR=1,   
        fmFit=2,      
        fmZoom=3      
      };

      enum rangemode {
        rmOn = 1 ,  
        rmOff = 2 , 
        rmAuto      
      };

      ICLWidget(QWidget *parent = 0);

      virtual ~ICLWidget();

      virtual void initializeGL();

      virtual void resizeGL(int w, int h);

      virtual void paintGL();

      virtual void paintEvent(QPaintEvent *e);

      virtual void customPaintEvent(PaintEngine *e);

      virtual void setVisible(bool visible);

      void setFitMode(fitmode fm);

      void setRangeMode(rangemode rm);

      void setBCI(int brightness, int contrast, int intensity);


      utils::Size getSize() { return utils::Size(width(),height()); }

      utils::Size getImageSize(bool fromGUIThread = false);

      utils::Rect getImageRect(bool fromGUIThread = false);

      fitmode getFitMode();

      rangemode getRangeMode();

      std::vector<std::string> getImageInfo();



      void install(MouseHandler *h);


      void uninstall(MouseHandler *h);


      void registerCallback(const GUI::Callback &cb, const std::string &eventList = "drag,press");

      void removeCallbacks();


      void render();

      virtual bool event(QEvent *event);

      const ImageStatistics &getImageStatistics();

      void setMenuEnabled(bool enabled);

      void setImageInfoIndicatorEnabled(bool enabled);

      void setShowNoImageWarnings(bool showWarnings);


      void setViewPort(const utils::Size &size);



      void setFullScreenMode(bool on, int screen=-1);



      void addSpecialToggleButton(const std::string &id,
                                  const core::ImgBase* untoggledIcon = 0,
                                  const core::ImgBase *toggledIcon = 0,
                                  bool initiallyToggled = 0,
                                  const utils::Function<void,bool> &cb=(utils::FunctionImpl<void,bool>*)0,//Function<void,bool>(), fix for clang
                                  const std::string &toolTipText="");


      void addSpecialButton(const std::string &id,
                            const core::ImgBase* icon = 0,
                            const utils::Function<void> &cb=(utils::FunctionImpl<void>*)0,//Function<void>(), fix for clang
                            const std::string &toolTipText="");


      void setInfoText(const std::string &text);

      void removeSpecialButton(const std::string &id);


      void setAutoRenderOnSetImage(bool on);

      public Q_SLOTS:
      void setImage(const core::ImgBase *image);

      private Q_SLOTS:
      void reEmbed();

      Q_SIGNALS:
      void mouseEvent(const MouseEvent &event);

      void specialButtonClicked(const std::string &id);

      void specialButtonToggled(const std::string &id, bool down);

      public:
      typedef utils::Function<core::Color> BGColorSource;


      void setBackgroundColorSource(BGColorSource src);


      void startRecording(const std::string &outputDevice,
                          const std::string &outputInfo,
                          bool framebuffer=true, int frameskip=0,
                          bool setParamsOnlyButDoNotStartRecording=false);


      void registerRecordingCallback(utils::Function<void,const core::ImgBase*> cb,
                                     const std::string &handle="default");

      void unregisterRecordingCallback(const std::string &handle="default");

      protected:

        void showInfoDialog();


      virtual void swapQueues(){}

      public:
      virtual void mousePressEvent(QMouseEvent *e);
      virtual void mouseReleaseEvent(QMouseEvent *e);
      virtual void mouseMoveEvent(QMouseEvent *e);
      virtual void enterEvent(QEvent *e);
      virtual void leaveEvent(QEvent *e);
      virtual void resizeEvent(QResizeEvent *e);
      virtual void wheelEvent(QWheelEvent *e);
      virtual void hideEvent(QHideEvent *e);
      virtual void keyPressEvent(QKeyEvent *event);

      public Q_SLOTS:
      void showHideMenu();
      void setMenuEmbedded(bool embedded);

      void bciModeChanged(int modeIdx);
      void brightnessChanged(int val);
      void contrastChanged(int val);
      void intensityChanged(int val);

      void scaleModeChanged(int modeIdx);
      void currentChannelChanged(int modeIdx);

      void captureCurrentImage();
      void captureCurrentFrameBuffer();

      void recordButtonToggled(bool checked);
      void pauseButtonToggled(bool checked);
      void stopButtonClicked();
      void skipFramesChanged(int frameSkip);
      void menuTabChanged(int index);
      void histoPanelParamChanged();

      void setEmbeddedZoomModeEnabled(bool enabled);

      void setLinInterpolationEnabled(bool enabled);

      void setShowPixelGridEnabled(bool enabled);

      void setRangeModeNormalOrScaled(bool enabled);

      void showBackgroundColorDialog();
      void showGridColorDialog();
      void setGridAlpha(int alpha);
      void setBackgroundBlack();
      void setBackgroundWhite();
      void setBackgroundGray();
      void setGridBlack();
      void setGridWhite();
      void setGridGray();

      private:
      const core::Img8u &grabFrameBufferICL();

      std::string getImageCaptureFileName();

      void updateInfoTab();

      void rebufferImageInternal();

      Data *m_data;

      const MouseEvent &createMouseEvent(MouseEventType type);
    };
  } // namespace qt
}