src/klftools/klfguiutil.h

Go to the documentation of this file.

/***************************************************************************
 *   file klfguiutil.h
 *   This file is part of the KLatexFormula Project.
 *   Copyright (C) 2011 by Philippe Faist
 *   philippe.faist at bluewin.ch
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 *   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, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
/* $Id$ */

#ifndef KLFGUIUTIL_H
#define KLFGUIUTIL_H


#include <QString>
#include <QByteArray>
#include <QComboBox>
#include <QWidget>
#include <QDialog>
#include <QProgressDialog>
#include <QMouseEvent>
#include <QPaintEvent>
#include <QTime>
#include <QGridLayout>
#include <QDoubleSpinBox>
#include <QLabel>
#include <QMovie>
#include <QPainter>

#include <klfutil.h>



class KLF_EXPORT KLFProgressReporter : public QObject
{
  Q_OBJECT
public:
  KLFProgressReporter(int min, int max, QObject *parent = NULL);
  virtual ~KLFProgressReporter();

  inline int min() const { return pMin; }
  inline int max() const { return pMax; }

signals:
  void progress(int progressValue);

  void finished();

public slots:
  void doReportProgress(int value);

private:
  int pMin;
  int pMax;
  bool pFinished;
};

class KLF_EXPORT KLFProgressDialog : public QProgressDialog
{
  Q_OBJECT
public:
  KLFProgressDialog(QString labelText = QString(), QWidget *parent = NULL);

  KLFProgressDialog(bool canCancel, QString labelText, QWidget *parent);

  virtual ~KLFProgressDialog();


public slots:

  virtual void setDescriptiveText(const QString& labelText);
  virtual void startReportingProgress(KLFProgressReporter *progressReporter,
                                      const QString& descriptiveText);
  virtual void startReportingProgress(KLFProgressReporter *progressReporter);

  virtual void setValue(int value);

protected:
  void paintEvent(QPaintEvent *event);

private:
  void setup(bool canCancel);
  void init(const QString& labelText);

  KLFProgressReporter *pProgressReporter;

  bool pGotPaintEvent;
};


class KLF_EXPORT KLFPleaseWaitPopup : public QLabel
{
  Q_OBJECT
  Q_PROPERTY(bool disableUi READ willDisableUi WRITE setDisableUi) ;
public:
  KLFPleaseWaitPopup(const QString& text, QWidget *callingWidget = NULL, bool alwaysAbove = false);
  virtual ~KLFPleaseWaitPopup();

  inline bool willDisableUi() const { return pDisableUi; }

  virtual void setDisableUi(bool disableUi);

  virtual bool pleaseWaitShown() const { return pGotPaintEvent; }

  virtual bool wasUserDiscarded() const { return pDiscarded; }

public slots:
  virtual void showPleaseWait();

protected:
  virtual void mousePressEvent(QMouseEvent *event);
  virtual void paintEvent(QPaintEvent *event);

private:
  QWidget *pParentWidget;
  bool pDisableUi;
  bool pGotPaintEvent;
  bool pDiscarded;
};


class KLF_EXPORT KLFDelayedPleaseWaitPopup : public KLFPleaseWaitPopup
{
  Q_OBJECT
public:
  KLFDelayedPleaseWaitPopup(const QString& text, QWidget *callingWidget = NULL);
  virtual ~KLFDelayedPleaseWaitPopup();

  virtual void setDelay(int ms);

public slots:
  virtual void process();

private:
  int pDelay;
  QTime timer;
};


class KLF_EXPORT KLFEnumComboBox : public QComboBox
{
  Q_OBJECT

  Q_PROPERTY(int selectedValue READ selectedValue WRITE setSelectedValue)
public:
  KLFEnumComboBox(QWidget *parent = 0);
  KLFEnumComboBox(const QList<int>& enumValues, const QStringList& enumTitles,
                  QWidget *parent = 0);
  virtual ~KLFEnumComboBox();

  int selectedValue() const;

  QString enumText(int enumValue) const;

signals:
  void selectedValueChanged(int enumValue);

public slots:
  void setSelectedValue(int val);

  void setEnumValues(const QList<int>& enumValues, const QStringList& enumTitles);

private slots:
  void internalCurrentIndexChanged(int index);

private:
  QList<int> pEnumValueList;
  QMap<int,QString> pEnumValues;
  QMap<int,int> pEnumCbxIndexes;
};





class KLF_EXPORT KLFGridFlowLayout : public QGridLayout
{
  Q_OBJECT
public:
  KLFGridFlowLayout(int columns, QWidget *parent);
  virtual ~KLFGridFlowLayout() { }

  virtual int ncolumns() const { return _ncols; }

  virtual void insertGridFlowWidget(QWidget *w, Qt::Alignment align = 0);

  void clearAll();

protected:
  QList<QWidget*> mGridFlowWidgets;
  int _ncols;
  int _currow, _curcol;
};





class KLFWaitAnimationOverlay : public QLabel
{
  Q_OBJECT
  Q_PROPERTY(QString waitMovie READ waitMovieFileName WRITE setWaitMovie) ;
  Q_PROPERTY(int widthPercent READ widthPercent WRITE setWidthPercent) ;
  Q_PROPERTY(int heightPercent READ heightPercent WRITE setHeightPercent) ;
  Q_PROPERTY(int positionXPercent READ positionXPercent WRITE setPositionXPercent) ;
  Q_PROPERTY(int positionYPercent READ positionYPercent WRITE setPositionYPercent) ;
  Q_PROPERTY(QColor backgroundColor READ backgroundColor WRITE setBackgroundColor) ;
public:
  KLFWaitAnimationOverlay(QWidget *parent);
  virtual ~KLFWaitAnimationOverlay();

  inline QString waitMovieFileName() const { return (pAnimMovie!=NULL) ? pAnimMovie->fileName() : QString(); }

  inline int widthPercent() const { return pWidthPercent; }
  inline int heightPercent() const { return pHeightPercent; }
  inline int positionXPercent() const { return pPositionXPercent; }
  inline int positionYPercent() const { return pPositionYPercent; }

  QColor backgroundColor() const;

public slots:
  virtual void setWaitMovie(QMovie *movie);
  virtual void setWaitMovie(const QString& file);


  void setWidthPercent(int widthpercent) { pWidthPercent = widthpercent; }


  void setHeightPercent(int heightpercent) { pHeightPercent = heightpercent; }


  void setPositionXPercent(int xpc) { pPositionXPercent = xpc; }


  void setPositionYPercent(int ypc) { pPositionYPercent = ypc; }


  void setBackgroundColor(const QColor& c);

  virtual void startWait();

  virtual void stopWait();

protected:
  virtual void timerEvent(QTimerEvent *event);

  virtual QRect calcAnimationLabelGeometry();

private:
  bool pIsWaiting;
  QMovie *pAnimMovie;
  int pAnimTimerId;

  int pWidthPercent;
  int pHeightPercent;
  int pPositionXPercent;
  int pPositionYPercent;
};



class KLF_EXPORT KLFDropDataHandler
{
public:
  enum OpenDataError {
    OpenDataOk = 0, 
    OpenDataFailed = 1, 
    OpenDataCantHandle = 2 
  };

  virtual bool canOpenDropData(const QMimeData * data) = 0;
  virtual int openDropData(const QMimeData *data) = 0;
};






KLF_EXPORT void klfDrawGlowedImage(QPainter *painter, const QImage& foreground,
                                   const QColor& glow_color = QColor(128, 255, 128, 8),
                                   int radius = 4, bool also_draw_image = true);



KLF_EXPORT QImage klfImageScaled(const QImage& source, const QSize& newSize);



class KLFWindowGeometryRestorer : public QObject
{
  Q_OBJECT
public:
  KLFWindowGeometryRestorer(QWidget *window);
  virtual ~KLFWindowGeometryRestorer();

  virtual bool eventFilter(QObject *obj, QEvent *event);
private:
  QWidget *pWindow;
};


KLF_EXPORT void klfHideWindows();
KLF_EXPORT void klfRestoreWindows();



#endif