src/klftools/klfsearchbar.h

Go to the documentation of this file.

/***************************************************************************
 *   file klfsearchbar.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 KLFSEARCHBAR_H
#define KLFSEARCHBAR_H

#include <QObject>
#include <QWidget>
#include <QFrame>
#include <QMovie>
#include <QLabel>
#include <QTime>

#include <klfdefs.h>

#include <klfutil.h>

class QLineEdit;
class KLFWaitAnimationOverlay;

class KLFSearchBar;
class KLFSearchableProxy;
namespace Ui { class KLFSearchBar; }




class KLF_EXPORT KLFPosSearchable : public KLFTarget
{
public:

  struct Pos {
    struct PosData {
      PosData() : r(0) { }
      virtual ~PosData() { }

      virtual bool equals(PosData *other) const = 0;

      virtual QString toDebug() { return QLatin1String("<PosData>"); }

      int ref() { return ++r; }
      int deref() { return --r; }

      virtual bool wantAutoDelete() { return true; }
    private:
      int r;
    };

    Pos() : posdata()
    {
    }

    Pos(const Pos& other) : posdata(other.posdata)
    {
    }

    ~Pos()
    {
      if (posdata != NULL)
        posdata.setAutoDelete(posdata->wantAutoDelete());
    }

    Pos& operator=(const Pos& other)
    {
      KLF_DEBUG_BLOCK(KLF_FUNC_NAME) ;
      posdata = other.posdata;
      return *this;
    }

    bool valid() const {
      KLF_DEBUG_BLOCK(KLF_FUNC_NAME) ;
      klfDbg("posdata="<<posdata) ;
      return  (posdata != NULL) ;
    };
    bool equals(const Pos& other) const {
      if (valid() && other.valid())
        return posdata->equals(other.data<PosData>());
      // if both are invalid, they are equal. If one only is valid, they are not equal.
      return (valid() == other.valid());
    }


    KLFRefPtr<PosData> posdata;

    template<class TT>
    inline TT * data() const
    {
      TT *ptr = posdata.dyn_cast<TT*>();
      KLF_ASSERT_NOT_NULL(ptr, "accessing a posdata that is NULL or of incompatible type!", return NULL;) ;
      return ptr;
    }
  };

  virtual Pos searchStartFrom(bool forward);

  virtual Pos searchFind(const QString& queryString, const Pos& fromPos, bool forward) = 0;

  virtual void searchMoveToPos(const Pos& pos)  { Q_UNUSED(pos);  }

  virtual void searchPerformed(const QString& queryString, bool found, const Pos& pos)
  {  Q_UNUSED(queryString); Q_UNUSED(found); Q_UNUSED(pos);  }

  virtual void searchAborted() = 0;

  virtual void searchReinitialized() { }


  virtual QString searchQueryString() const { klfDbg("pQString="<<pQString) ; return pQString; }

  virtual void setSearchQueryString(const QString& s) { klfDbg("pQString="<<pQString<<"; setting to "<<s) ; pQString = s; }

  virtual bool searchHasInterruptRequested() { return pInterruptRequested; }

  virtual void setSearchInterruptRequested(bool on);

private:
  QString pQString;
  bool pInterruptRequested;
};

KLF_EXPORT QDebug& operator<<(QDebug& str, const KLFPosSearchable::Pos& pos);


class KLF_EXPORT KLFPosSearchableProxy : public KLFPosSearchable, public KLFTargeter
{
public:
  KLFPosSearchableProxy() { }
  virtual ~KLFPosSearchableProxy();

  virtual Pos searchStartFrom(bool forward);
  virtual Pos searchFind(const QString& queryString, const Pos& fromPos, bool forward);
  virtual void searchMoveToPos(const Pos& pos);
  virtual void searchPerformed(const QString& queryString, bool found, const Pos& pos);
  virtual void searchAborted();
  virtual void searchReinitialized();
  virtual QString searchQueryString() const;
  virtual void setSearchQueryString(const QString& s);
  virtual bool searchHasInterruptRequested();
  virtual void setSearchInterruptRequested(bool on);

  virtual void setSearchTarget(KLFPosSearchable *t) { setTarget(t); }

protected:
  virtual KLFPosSearchable *target() { return dynamic_cast<KLFPosSearchable*>(pTarget); }
  virtual const KLFPosSearchable *target() const { return dynamic_cast<KLFPosSearchable*>(pTarget); }
};





class KLF_EXPORT KLFSearchable : public KLFPosSearchable
{
public:
  KLFSearchable();
  virtual ~KLFSearchable();


  virtual bool searchFind(const QString& queryString, bool forward) = 0;


  inline bool searchFind(const QString& queryString) { return searchFind(queryString, true); }


  virtual bool searchFindNext(bool forward) = 0;


  virtual void searchAbort() = 0;


  virtual Pos searchFind(const QString& queryString, const Pos& fromPos, bool forward);
  virtual void searchMoveToPos(const Pos& pos)
  {  Q_UNUSED(pos);  }
  virtual void searchPerformed(const QString& queryString, bool found, const Pos& pos)
  {  Q_UNUSED(queryString); Q_UNUSED(found); Q_UNUSED(pos);  }
  virtual void searchAborted() { searchAbort(); }
};



class KLF_EXPORT KLFSearchableProxy : public KLFSearchable, public KLFTargeter
{
public:
  KLFSearchableProxy() : KLFTargeter() { }
  virtual ~KLFSearchableProxy();
  
  void setSearchTarget(KLFPosSearchable *target) { setTarget(target); }
  virtual void setTarget(KLFTarget *target);

  virtual bool searchFind(const QString& queryString, bool forward);
  virtual bool searchFindNext(bool forward);
  virtual void searchAbort();

protected:
  virtual KLFSearchable *target() { return dynamic_cast<KLFSearchable*>(pTarget); }
};




struct KLFSearchBarPrivate;


class KLF_EXPORT KLFSearchBar : public QFrame, public KLFTargeter
{
  Q_OBJECT

  Q_PROPERTY(QString currentSearchText READ currentSearchText) ;
  Q_PROPERTY(bool autoHide READ autoHide WRITE setAutoHide) ;
  Q_PROPERTY(bool showOverlayMode READ showOverlayMode WRITE setShowOverlayMode) ;
  Q_PROPERTY(QRect showOverlayRelativeGeometry READ showOverlayRelativeGeometry
             WRITE setShowOverlayRelativeGeometry ) ;
  Q_PROPERTY(QString focusOutText READ focusOutText WRITE setFocusOutText) ;
  Q_PROPERTY(QColor colorFound READ colorFound WRITE setColorFound) ;
  Q_PROPERTY(QColor colorNotFound READ colorNotFound WRITE setColorNotFound) ;
  Q_PROPERTY(bool showHideButton READ hideButtonShown WRITE setShowHideButton) ;
  Q_PROPERTY(bool showSearchLabel READ showSearchLabel WRITE setShowSearchLabel) ;
  Q_PROPERTY(bool emacsStyleBackspace READ emacsStyleBackspace WRITE setEmacsStyleBackspace) ;
  Q_PROPERTY(int resetTimeout READ resetTimeout WRITE setResetTimeout) ;
public:

  enum SearchState { Default, FocusOut, Found, NotFound, Aborted };

  KLFSearchBar(QWidget *parent = NULL);
  virtual ~KLFSearchBar();
  virtual void registerShortcuts(QWidget *parent);

  virtual void setSearchTarget(KLFPosSearchable *target) { setTarget(target); }
  virtual void setTarget(KLFTarget *target);

  QString currentSearchText() const;
  bool autoHide() const;
  bool showOverlayMode() const;
  QRect showOverlayRelativeGeometry() const;
  QString focusOutText() const;
  QColor colorFound() const;
  QColor colorNotFound() const;
  bool hideButtonShown() const;
  bool showSearchLabel() const;
  bool emacsStyleBackspace() const;
  int resetTimeout() const;

  KLFPosSearchable::Pos currentSearchPos() const;

  SearchState currentState() const;

  void setAutoHide(bool autohide);

  void setShowOverlayMode(bool showOverlayMode);
  void setShowOverlayRelativeGeometry(const QRect& relativeGeometryPercent);
  void setShowOverlayRelativeGeometry(int widthPercent, int heightPercent,
                                      int positionXPercent, int positionYPercent);
  void setColorFound(const QColor& color);
  void setColorNotFound(const QColor& color);
  void setShowHideButton(bool showHideButton);
  void setShowSearchLabel(bool show);
  void setEmacsStyleBackspace(bool on);
  void setResetTimeout(int ms);

  virtual bool eventFilter(QObject *obj, QEvent *ev);

  QLineEdit * editor();

signals:
  void stateChanged(SearchState state);
  void searchPerformed(bool found);
  void searchPerformed(const QString& queryString, bool found);
  void found();
  void found(const QString& queryString, bool forward);
  void found(const QString& queryString, bool forward, const KLFPosSearchable::Pos& pos);
  void didNotFind();
  void didNotFind(const QString& queryString, bool forward);
  void searchAborted();
  void escapePressed();
  void searchReinitialized();


  void hasMatch(bool hasmatch);

  void visibilityChanged(bool isShown);

public slots:
  void clear();
  void focusOrNext(bool forward = true);
  void focusOrPrev() { focusOrNext(false); }
  void find(const QString& string);
  void find(const QString& string, bool forward);
  void findNext(bool forward = true);
  void findPrev() { findNext(false); }
  void abortSearch();

  void focus();

  virtual void setSearchText(const QString& text);
  void setFocusOutText(const QString& focusOutText);

protected:
  Ui::KLFSearchBar *u;

  bool searchBarHasFocus();

  virtual bool event(QEvent *event);


  bool _isInQtDesigner;
  friend class KLFSearchBarDesPlugin;

protected slots:

  virtual void slotSearchFocusIn();
  virtual void slotSearchFocusOut();
  virtual void slotSearchReset();
  virtual void updateSearchFound(bool found);

  void promptEmptySearch();

  virtual void displayState(SearchState state);

  void setCurrentState(SearchState state);

  void emitFoundSignals(const KLFPosSearchable::Pos& pos, const QString& searchstring, bool forward);

  void showSearchBarText(const QString& text);

private:

  inline KLFPosSearchable *target() { return dynamic_cast<KLFPosSearchable*>(pTarget); }

  KLFSearchBarPrivate *d;

  void adjustOverlayGeometry();

  QString palettePropName(SearchState state) const;
  QString statePropValue(SearchState state) const;

  // Needed so that KLFSearchable's can ensure \ref pTarget is valid, and set it to NULL
  // when appropriate
  friend class KLFSearchable;

  void performFind(bool forward, bool isFindNext = false);

  KLF_DEBUG_DECLARE_ASSIGNABLE_REF_INSTANCE()
};




#endif