ModuleBase_ModelWidget.h

// Copyright (C) 2014-2025  CEA, EDF
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
 
#ifndef MODULEBASE_MODELWIDGET_H
#define MODULEBASE_MODELWIDGET_H
 
#include <ModuleBase.h>
#include <ModuleBase_ActionType.h>
#include <ModuleBase_Definitions.h>
#include <ModuleBase_OperationFeature.h>
#include <ModuleBase_ActionInfo.h>
#include <ModuleBase_ActionParameter.h>
#include <ModelAPI_Feature.h>
 
#include <SelectMgr_ListOfFilter.hxx>
 
#include <QWidget>
 
#include <memory>
 
#ifdef _MSC_VER
#pragma warning(disable: 4100)
#endif
 
class Config_WidgetAPI;
class Events_InfoMessage;
class ModuleBase_IPropertyPanel;
class ModuleBase_IWorkshop;
class ModuleBase_ViewerPrs;
class ModuleBase_WidgetValidator;
class QKeyEvent;
 
class MODULEBASE_EXPORT ModuleBase_ModelWidget : public QWidget
{
Q_OBJECT
 public:
   enum ValueState { Stored, 
                     ModifiedInPP, 
                     ModifiedInViewer, 
                     Reset }; 
 
   enum EnableState { On,  
                      Off, 
                      DefinedInPreferences };
 
  ModuleBase_ModelWidget(QWidget* theParent, const Config_WidgetAPI* theData);
  virtual ~ModuleBase_ModelWidget();
 
  bool reset();
 
  bool isInitialized(ObjectPtr theObject) const;
 
  virtual void selectionModes(int& theModuleSelectionModes, QIntList& theModes);
 
  virtual void selectionFilters(QIntList& theModuleSelectionFilters,
                                SelectMgr_ListOfFilter& theSelectionFilters);
 
  bool isComputedDefault() const { return myIsComputedDefault; }
 
  std::string getDefaultValue() const { return myDefaultValue; }
 
  bool isInternal() const { return myIsInternal; }
 
  bool isObligatory() const { return myIsObligatory; }
 
  virtual bool isValueEnabled() const;
 
  bool isUseReset() const { return myUseReset; }
 
  std::string isModifiedInEdit() const { return myIsModifiedInEdit; }
 
  ValueState getValueState() const { return myState; }
 
  void processValueState();
 
  Events_InfoMessage getValueStateError() const;
 
  virtual bool isViewerSelector() { return false; }
 
  virtual bool canAcceptFocus() const { return true; };
 
  virtual QString getError(const bool theValueStateChecked = true) const;
 
  virtual bool setSelection(QList<std::shared_ptr<ModuleBase_ViewerPrs>>& theValues,
                            const bool theToValidate)
  {
    return false;
  }
 
  virtual void getHighlighted(QList<std::shared_ptr<ModuleBase_ViewerPrs>>& theValues) {};
 
  virtual bool isValidSelectionCustom(const std::shared_ptr<ModuleBase_ViewerPrs>& theValue)
  { return true; }
 
  ModuleBase_WidgetValidator* widgetValidator() { return myWidgetValidator.get(); }
 
  bool restoreValue();
 
  bool storeValue();
 
  virtual bool focusTo();
 
  virtual void selectContent() {}
 
  void activate();
 
  virtual void deactivate();
 
  virtual void updateAfterDeactivation() {}
  virtual void updateAfterActivation() {}
 
  virtual bool needToBeActivated() { return false; }
 
  virtual QList<QWidget*> getControls() const = 0;
 
  QWidget* getControlAcceptingFocus(const bool isFirst);
 
  virtual bool eventFilter(QObject* theObject, QEvent *theEvent);
 
  virtual void enableFocusProcessing();
 
  virtual void setHighlighted(bool isHighlighted);
 
  std::string attributeID() const
  {
    return myAttributeID;
  }
 
  FeaturePtr feature() const
  {
    return myFeature;
  }
 
  virtual std::string context() const {
    bool isAppendAttr = true;
    std::string aContext = myFeatureId;
    if(!aContext.empty() && !myAttributeID.empty()) {
      // workaround for ModelAPI_Filter's attributes:
      // do not keep attribute name, because it may be changed
      // if the same filter is selected twice or more.
      if (myAttributeID.find(aContext + "__") != std::string::npos)
        isAppendAttr = false;
      else
        aContext += ":";
    }
    if (isAppendAttr)
      aContext += myAttributeID;
 
    return aContext;
  }
 
  virtual void setFeature(const FeaturePtr& theFeature, const bool theToStoreValue = false,
                          const bool isUpdateFlushed = true);
 
  virtual void setEditingMode(bool isEditing) { myIsEditing = isEditing; }
 
  bool isEditingMode() const { return myIsEditing; }
 
  virtual bool canProcessAction(ModuleBase_ActionType theActionType, bool& isActionEnabled);
 
  virtual bool processAction(ModuleBase_ActionType theActionType,
                             const ActionParamPtr& theParam = ActionParamPtr());
 
  virtual QList<ActionInfo> actionsList(ModuleBase_ActionType theActionType) const
  { return QList<ActionInfo>(); }
 
  void updateObject(ObjectPtr theObj);
 
  virtual QString translate(const std::string& theStr) const;
 
  void emitFocusInWidget() { emit focusInWidget(this); }
 
  static ModuleBase_ModelWidget* findModelWidget(ModuleBase_IPropertyPanel* theProp,
                                                 QWidget* theWidget);
 
  virtual bool usesAttribute() const { return true; }
 
  virtual void onFeatureAccepted() {}
 
  virtual bool isInformative() const { return true; }
 
  virtual void showInformativePage() {}
 
  virtual bool isModified() const { return false; }
 
  virtual void setReadOnly(bool isReadOnly) { setEnabled(!isReadOnly); }
 
  virtual bool isReadOnly() const { return !isEnabled(); }
 
  bool canUseExternalParts() const { return myUseExternalParts; }
 
signals:
  void beforeValuesChanged();
  void valuesChanged();
  void valuesModified();
  void afterValuesChanged();
 
  void beforeValuesRestored();
  void afterValuesRestored();
 
  void keyReleased(QObject* theObject, QKeyEvent* theEvent);
 
  void enterClicked(QObject* theObject);
 
  void focusInWidget(ModuleBase_ModelWidget* theWidget);
 
  void focusOutWidget(ModuleBase_ModelWidget* theWidget);
 
  void valueStateChanged(int theState);
 
  void objectUpdated();
 
protected:
  void setDefaultValue(const std::string& theValue);
  void setAttributeID(const std::string& theAttribute)
  {
    myAttributeID = theAttribute;
  }
 
  ValueState setValueState(const ValueState& theState);
 
  bool blockValueState(const bool theBlocked);
 
  virtual void initializeValueByActivate();
 
  virtual bool storeValueCustom() = 0;
 
  virtual bool restoreValueCustom() = 0;
 
  virtual bool resetCustom() { return false; };
 
  virtual void activateCustom() {};
 
  virtual bool processEnter();
 
  virtual bool processEscape();
 
  virtual bool processDelete();
 
  virtual bool processSelection();
 
  protected slots:
  void onWidgetValuesChanged();
 
  void onWidgetValuesModified();
 
 protected:
  std::unique_ptr<ModuleBase_WidgetValidator> myWidgetValidator;
 
  std::string myAttributeID;
 
  FeaturePtr myFeature;
 
  std::string myFeatureId;
 
  bool myIsObligatory;
 
  EnableState myIsValueEnabled;
 
  ValueState myState;
 
private:
  bool myIsEditing;
 
  bool myIsComputedDefault;
 
  std::string myDefaultValue;
 
  bool myIsInternal;
 
  // an XML state, the value is not stored into model if the widget is in edit mode
  std::string myIsModifiedInEdit;
 
  bool myUseReset;
  bool myIsValueStateBlocked;
  bool myFlushUpdateBlocked;
 
  bool myUpdateVisualAttributes;
 
  bool myUseExternalParts;
};
 
#endif