Button1->Enabled = SomeCondition;
Button2->Enabled = SomeConsition;
...
ButtonXXX->Enabled = SomeConsition;

TDisabler Disabler;

// можно задизаблить так:
Disabler << Button1 << Button2 << Label1 << Memo1 << ListView1;

// можно заэнаблить так
Disabler >> Button1 >> Button2 >> Label1 >> Memo1 >> ListView1;


// Можно просто менять состояние в зависимости от условия

// если true - то будет включать компоненты, false - выключать
Disabler.SetEnabled(SomeCondition); 
Disabler << Button1 << Button2 << Label1 << Memo1 << ListView1;

//---------------------------------------------------------------------------
#ifndef EnablerHelperH
#define EnablerHelperH
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <TypInfo.hpp>
//---------------------------------------------------------------------------
class TDisabler
{
private:

void SetComponentState(TComponent* Component)
 {
 if(Component)
   {
    PPropInfo PropInfo = GetPropInfo((PTypeInfo)Component->ClassInfo(), "Enabled");
    if (PropInfo)
      SetOrdProp(static_cast<TObject *>(Component), PropInfo, (int)FEnabled);
   }
 }
bool FEnabled;

public:

   void SetEnabled(bool Enabled) {FEnabled = Enabled;}

   TDisabler() : FEnabled(false) {}
  ~TDisabler() {}

   TDisabler& operator<<(TComponent* Component)
    {
      if(Component)
       {
        SetComponentState(Component);
       }
     return *this;
    }

   TDisabler& operator>>(TComponent* Component)
    {
      if(Component)
       {
        bool Temp = FEnabled;
        FEnabled = true;
        SetComponentState(Component);
        FEnabled = Temp;
       }
     return *this;
    }

};
//---------------------------------------------------------------------------
#endif

Button1->>Enabled = SomeCondition;
Button2->>Enabled = SomeConsition;
F>...
ButtonXXX->>Enabled = SomeConsition;
F>

// для меню
void set_enabled(bool value, TMenuItem *item1, ...)
{
  va_list pointer;
  TMenuItem *item;

  item1->Enabled = value;
  va_start(pointer, item1);
  for ( ; ; )
  {
    item = va_arg(pointer, TMenuItem*);
    if (item == NULL) break;
    item->Enabled = value;
  }
  va_end(pointer);
}

// для контролов
void set_enabled(bool value, TControl *control1, ...)
{
  va_list pointer;
  TControl *control;

  control1->Enabled = value;
  va_start(pointer, control1);
  for ( ; ; )
  {
    control = va_arg(pointer, TControl*);
    if (control == NULL) break;
    control->Enabled = value;
  }
  va_end(pointer);
}

  set_enabled(false, Label1, Button2, Button1, NULL); 
  set_enabled(true, Label2, Label3, NULL);

TBooleanManager Manager;

// запрещаем всплывающие подсказки...
Manager << "ShowHint" << false << Button1 << ComboBox1 << Memo1 << ListView1;


// разрешаем всплывающие подсказки
Manager << "ShowHint" << true << Button1 << ComboBox1 << Memo1 << ListView1;

// Выключаем контролы
Manager << "Enabled" << false << Button1 << ComboBox1 << Memo1 << ListView1;

//---------------------------------------------------------------------------
#ifndef BooleanManagerH
#define BooleanManagerH
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <TypInfo.hpp>
//---------------------------------------------------------------------------
class TBooleanManager
{
private:

void SetComponentState(TComponent* Component)
 {
 if(Component && !FPropertyName.IsEmpty())
   {
    PPropInfo PropInfo = GetPropInfo((PTypeInfo)Component->ClassInfo(), FPropertyName);
    if (PropInfo)
      SetOrdProp(static_cast<TObject *>(Component), PropInfo, (int)FTrue);
   }
 }
bool FTrue;
String FPropertyName;

public:


   TBooleanManager() : FTrue(false),FPropertyName("Enabled") {}
  ~TBooleanManager() {}


    TBooleanManager& operator<<(char* PropName)
    {
     FPropertyName = PropName;
     return *this;
    }

    TBooleanManager& operator<<(bool IsTrue)
    {
     FTrue = IsTrue;
     return *this;
    }

   TBooleanManager& operator<<(TComponent* Component)
    {
      if(Component)
       {
        SetComponentState(Component);
       }
     return *this;
    }
    
};
//---------------------------------------------------------------------------
#endif

void __fastcall TfrmFindingAid::actSomeActionUpdate(TObject *Sender)
{
  TAction* pAction = dynamic_cast<TAction*>(Sender);
  Assert(pAction != NULL);

  pAction->Enabled = AllowSomeAction();
}
//---------------------------------------------------------------------------

PropertySetter<char* prop, bool value> : public PropertyChangeTool;
BoolPropertyInvertor<char* prop> : public PropertyChangeTool;

(или даже так: PropertySetter<char* prop, T value> или PropertySetter<char* prop, typename T, T value>)

и потом

PropertySetter<"Enabled",true> << Control1 << Control2;
BoolPropertyInvertor<"Enabled"> << Control1 << Control2;

void __fastcall TForm1::Button3Click(TObject *Sender)
{
TBooleanManager Manager;

// Выключаем все дочерние контролы Panel1
Manager << "Enabled" << false << roRecursion << Panel1;

}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button4Click(TObject *Sender)
{
TBooleanManager Manager;

// Включаем все дочерние контролы Panel1
Manager << "Enabled" << true << roRecursion << Panel1;

}
//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
#ifndef BooleanManagerH
#define BooleanManagerH
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <TypInfo.hpp>
//---------------------------------------------------------------------------
typedef enum
{
  roNoRecursion = 100,
  roRecursion
  
} TRecursionOptions;
//---------------------------------------------------------------------------
class TBooleanManager
{
private:

void SetComponentState(TComponent* Component)
 {
 if(Component && !FPropertyName.IsEmpty())
   {
    PPropInfo PropInfo = GetPropInfo((PTypeInfo)Component->ClassInfo(), FPropertyName);
    if (PropInfo)
      SetOrdProp(static_cast<TObject *>(Component), PropInfo, (int)FTrue);

      if(FOptions == roRecursion)
      {
      TWinControl* wc = dynamic_cast<TWinControl*>(Component);
          if(wc)
            for(int i=0;i<wc->ControlCount;i++)
            {
               SetComponentState(wc->Controls[i]);
            }
      }

   }
 }
bool FTrue;
String FPropertyName;
TRecursionOptions FOptions;

public:



   TBooleanManager() : FTrue(false),FPropertyName("Enabled") {}


   TBooleanManager(const char* PropName) : FPropertyName(PropName),
        FTrue(false),FOptions(roNoRecursion) {}

   TBooleanManager(const String& PropName) : FPropertyName(PropName),
        FTrue(false),FOptions(roNoRecursion) {}

   TBooleanManager(const char* PropName, bool IsTrue) : FPropertyName(PropName),
        FTrue(IsTrue),FOptions(roNoRecursion) {}

   TBooleanManager(const String& PropName, bool IsTrue) : FPropertyName(PropName),
        FTrue(IsTrue),FOptions(roNoRecursion) {}



  ~TBooleanManager() {}

    TBooleanManager& operator<<(const String& PropName)
    {
     FPropertyName = PropName;
     return *this;
    }

    TBooleanManager& operator<<(char* PropName)
    {
     FPropertyName = PropName;
     return *this;
    }

    TBooleanManager& operator<<(TRecursionOptions Options)
    {
     FOptions = Options;
     return *this;
    }

    TBooleanManager& operator<<(bool IsTrue)
    {
     FTrue = IsTrue;
     return *this;
    }

   TBooleanManager& operator<<(TComponent* Component)
    {
      if(Component)
       {
        SetComponentState(Component);
       }
     return *this;
    }



    
};
//---------------------------------------------------------------------------
#endif

BBI>Было бы просто супер, если бы был вариант и для Delphi

procedure SetState(PropName: string; IsTrue: Integer; Components: array of const);
var
  i: Integer;
begin
  for i := Low(Components) to High(Components) do
    with TVarRec(Components[i]) do
      SetOrdProp(VObject, PropName, IsTrue);
end;