kscoringeditor.h

/*
    kscoringeditor.h
 
    Copyright (c) 2001 Mathias Waack
    Copyright (C) 2005 by Volker Krause <volker.krause@rwth-aachen.de>
 
    Author: Mathias Waack <mathias@atoll-net.de>
 
    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.
    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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, US
*/
 
#ifndef SCOREEDITWIDGET_H
#define SCOREEDITWIDGET_H
 
#include <tqmap.h>
#include <kdialogbase.h>
#include <tqtable.h>
#include <tqframe.h>
 
#include "kwidgetlister.h"
 
#include <tdemacros.h>
 
class KComboBox;
class KLineEdit;
class KIntSpinBox;
class TDEListBox;
class TQFrame;
class TQLabel;
class TQListBoxItem;
class TQPushButton;
class TQCheckBox;
class TQRadioButton;
 
class KScoringRule;
class KScoringExpression;
class KScoringManager;
class ActionBase;
class KScoringEditor;
class ScoreEditWidget;
class KColorCombo;
 
class TDE_EXPORT SingleConditionWidget : public TQFrame
{
  TQ_OBJECT
  
  friend class ConditionEditWidget;
public:
  SingleConditionWidget(KScoringManager *,TQWidget *p =nullptr, const char *n =nullptr);
  ~SingleConditionWidget();
  void setCondition(KScoringExpression*);
  KScoringExpression *createCondition() const;
  void clear();
 
protected slots:
  void toggleRegExpButton( int );
  void showRegExpDialog();
 
private:
  TQCheckBox *neg;
  KComboBox *headers;
  KComboBox *matches;
  KLineEdit *expr;
  TQPushButton *regExpButton;
 
  KScoringManager *manager;
};
 
class ConditionEditWidget: public KWidgetLister
{
  TQ_OBJECT
  
public:
  ConditionEditWidget(KScoringManager *,TQWidget *p =nullptr, const char *n =nullptr);
  ~ConditionEditWidget();
  TQWidget* createWidget(TQWidget*);
  void updateRule(KScoringRule*);
  void clearWidget(TQWidget*);
public slots:
  void slotEditRule(KScoringRule*);
private:
  KScoringManager *manager;
};
 
class SingleActionWidget : public TQWidget
{
  TQ_OBJECT
  
  friend class ActionEditWidget;
public:
  SingleActionWidget(KScoringManager *m,TQWidget *p =nullptr, const char *n =nullptr);
  ~SingleActionWidget();
  void setAction(ActionBase*);
  ActionBase *createAction() const;
  void clear();
private:
  KComboBox *types;
  TQWidgetStack *stack;
  KLineEdit *notifyEditor;
  KIntSpinBox *scoreEditor;
  KColorCombo *colorEditor;
  TQLabel *dummyLabel;
 
  KScoringManager *manager;
};
 
class TDE_EXPORT ActionEditWidget : public KWidgetLister
{
  TQ_OBJECT
  
public:
  ActionEditWidget(KScoringManager *m,TQWidget *p =nullptr, const char *n =nullptr);
  ~ActionEditWidget();
  TQWidget* createWidget(TQWidget *parent);
  void updateRule(KScoringRule*);
  void clearWidget(TQWidget *);
public slots:
  void slotEditRule(KScoringRule *);
private:
  KScoringManager *manager;
};
 
class RuleEditWidget : public TQWidget
{
  TQ_OBJECT
  
public:
  RuleEditWidget(KScoringManager *m,TQWidget *p =nullptr, const char *n =nullptr);
  ~RuleEditWidget();
public slots:
  void setDirty();
  void slotEditRule(const TQString&);
  void updateRule(KScoringRule*);
  void updateRule();
signals:
  void shrink();
protected slots:
  void slotAddGroup();
  void slotShrink();
private slots:
  void slotExpireEditChanged(int value);
private:
  void clearContents();
 
  bool dirty;
  KLineEdit *ruleNameEdit;
  KLineEdit *groupsEdit;
  KComboBox *groupsBox;
  TQCheckBox *expireCheck;
  TQLabel *expireLabel;
  KIntSpinBox *expireEdit;
  TQRadioButton *linkModeOr, *linkModeAnd;
  ActionEditWidget *actionEditor;
  ConditionEditWidget *condEditor;
 
  KScoringManager *manager;
 
  // the old name of the current rule
  TQString oldRuleName;
};
 
class TDE_EXPORT RuleListWidget : public TQWidget
{
  TQ_OBJECT
  
public:
  RuleListWidget(KScoringManager *m, bool =false, TQWidget *p =nullptr, const char *n =nullptr);
  ~RuleListWidget();
  TQString currentRule() const { return ruleList->currentText(); }
protected:
  void updateButton();
 
signals:
  void ruleSelected(const TQString&);
  void ruleEdited(const TQString&);
  void leavingRule();
public slots:
  void slotRuleSelected(const TQString&);
  void slotRuleSelected(TQListBoxItem *);
  void slotRuleSelected(int);
  void updateRuleList();
  void updateRuleList(const KScoringRule*);
  void slotRuleNameChanged(const TQString&,const TQString&);
protected slots:
  void slotGroupFilter(const TQString&);
  void slotEditRule(TQListBoxItem*);
  void slotEditRule(const TQString&);
  void slotEditRule();
  void slotDelRule();
  void slotNewRule();
  void slotCopyRule();
  void slotRuleUp();
  void slotRuleDown();
 
private:
  TDEListBox *ruleList;
  TQString group;
  bool alone;
 
  KScoringManager *manager;
 
  TQPushButton *editRule;
  TQPushButton *newRule;
  TQPushButton *delRule;
  TQPushButton *copyRule;
  TQPushButton *mRuleUp;
  TQPushButton *mRuleDown;
};
 
class TDE_EXPORT KScoringEditor : public KDialogBase
{
  TQ_OBJECT
  
public:
  ~KScoringEditor();
  void setRule(KScoringRule*);
  static KScoringEditor *createEditor(KScoringManager* m, TQWidget *parent=nullptr, const char *name=nullptr);
  static KScoringEditor *editor() { return scoreEditor; }
  void setDirty();
protected:
  KScoringEditor(KScoringManager* m, TQWidget *parent=nullptr, const char *name=nullptr);
private:
  RuleEditWidget* ruleEditor;
  RuleListWidget *ruleLister;
protected slots:
  void slotShrink();
  void slotDoShrink();
  void slotApply();
  void slotOk();
  void slotCancel();
  void slotFinished();
private:
  KScoringManager *manager;
  ScoreEditWidget *edit;
  static KScoringEditor *scoreEditor;
};
 
class KScoringEditorWidgetDialog : public KDialogBase
{
  TQ_OBJECT
  
public:
  KScoringEditorWidgetDialog(KScoringManager *m, const TQString& rName, TQWidget *parent=nullptr, const char *name=nullptr);
protected slots:
  void slotApply();
  void slotOk();
  void slotShrink();
  void slotDoShrink();
private:
  RuleEditWidget *ruleEditor;
  KScoringManager *manager;
  TQString ruleName;
};
 
class TDE_EXPORT KScoringEditorWidget : public TQWidget
{
  TQ_OBJECT
  
public:
  KScoringEditorWidget(KScoringManager *m,TQWidget *p =nullptr, const char *n =nullptr);
  ~KScoringEditorWidget();
protected slots:
  void slotRuleEdited(const TQString&);
private:
  RuleListWidget *ruleLister;
  KScoringManager *manager;
};
 
 
#endif // SCOREEDITWIDGET_H