[LLDB][GUI] Add Process Attach form

[OmarEmaraDev]

Summary

This patch adds a form window to attach a process, either by PID or by
name. This patch also adds support for dynamic field visibility such
that the form delegate can hide or show certain fields based on some
conditions.

[OmarEmaraDev]

I initially created two forms for attach by name and attach by PID, because the options were divided between them. Today I tried to reimplement that such that it is a single form with a choices field at the top that determines if it is by name or PID. The fields are then shown or hidden based on that enum. Additionally, other fields can control the visibility of other fields, for instance, the "Include existing processes" field. I think it works fine and the UX looks good. Here is an example, what do you think?

[clayborg]

lldb/source/Core/IOHandlerCursesGUI.cpp

1921

Do these actually need to be shared pointers? They can probably become std::unique_ptr<T> objects and the FieldDelegateSP would then become FieldDelegateUP after defining it as a unique_ptr

2199

Spelling issue I missed before

2300

I am guessing that the first item in the list is always selected? Might be nice to provide a way for AddChoicesField to select a different item as the default selection with another optional parameter that is the index of the item that is to be selected. Doesn't have to happen in this diff, just thought of it and wanted to mention this.

2301

remove space

2302

I would be nice if we can eventually auto complete the PID by using the platform to get a list of processes. Sometimes we are not attached to a remote platform, but we are always attached to the host platform and should be able to get a list of process IDs. A new form could be popped up with all of the process details and allowing the user to filter processes with a TextField, then a ChoicesField that contains all valid processes the user could attach to with the pid, process name and possibly other details in the text for each choice. This doesn't need to be done now, but it would be a good extra functionality step to complete later if you get everything done on your list.

2303

remove space

2304

If we have a target, it might be nice to auto populate this field with the basename of the target's main executable.

2305

remove space

2306

Might be nice to iterate over all process plug-ins and make this into a ChoicesField where the first entry is "<default>" and the rest are actual plug-in names. The names can easily be retrieved using:

static const char *GetProcessPluginNameAtIndex(uint32_t idx);

from PluginManager.h

2307

remove space

2346

We might want to pop up a dialog here asking the user if they want to kill or detach since we have a GUI. In the "process attach" command we confirm with the user if the terminal is interactive.
A few ways we can do this:

• popup a form asking the user to kill/detach/cancel when the user hits submit on this form
• pop up the dialog before even showing the this form and asking the user to kill or detach, then show this form after that has been handled
• not allow the Process->Attach to happen by disabling the menu item when a process is running.

2367

We should select the target in he debugger here so that all GUI commands work correctly after this call if they ask the debugger for its selected target.

m_debugger.GetTargetList().SetSelectedTarget(...);

2420–2421

You shouldn't need to do this since you already called ProcessAttachInfo::SetContinueOnceAttached(true) on the attach_info. LLDB should take care of this for you already I think.

[OmarEmaraDev]

• Use unique pointers for field delegates.
• Fix typos in Select methods.
• Set the process name to the main executable name by default.
• Turn plugin name into a choice field.
• Update debugger target if a new one was created.
• Remove superfluous continue operation.

[OmarEmaraDev]

Currently working on the detach/kill form.

lldb/source/Core/IOHandlerCursesGUI.cpp

2346

I think the first option is the best, because it delays this decision at the very end giving the user as much time as possible to cancel attaching without altering the debugger state.

2420–2421

In the command code, there is this snippet of code at the end, so I though it might be necessary:

// This supports the use-case scenario of immediately continuing the
// process once attached.
if (m_options.attach_info.GetContinueOnceAttached())
  m_interpreter.HandleCommand("process continue", eLazyBoolNo, result);

[OmarEmaraDev]

• Add kill/detach form.
• Fix forms with no fields.

[OmarEmaraDev]

Updated UI:

Kill/Detach form.

[clayborg]

lldb/source/Core/IOHandlerCursesGUI.cpp

1842

You don't want to return a unique_ptr here, if you do something like:

FieldDelegateUP field_up = form->GetField(1);

You have now given away the one reference to this field to the local variable and it will destruct the item when the local goes out of scope.

Easy solution: just return a pointer, not a unique_ptr. The FormDelegate owns all of its fields, so it is ok to hand out a pointer as others should temporarily use the FieldDelegate. Also we should bounds check "field_index".

1986

2153–2154

2160

2177

2209–2210

2216

No need to use a std::unique_ptr here, and GetField should return a pointer as mentioned above.

2233–2234

2273

2297

When we have interaction, we should allow the user to select kill or detach. The GetShouldDetach is only for when the user doesn't interact. Can we use a ChoicesField for this with the two options? We can even go a step further and add three options: "Detach", "Detach (stopped)", and "Kill". This is easy since lldb_private::Process has this option on detach:

Status Process::Detach(bool keep_stopped);

When you detach with "keep_stopped" set to true the process will not resume. This allows another debugger to be attached, or someone to run another tool on the process in its suspended state.

2323

Does anyone remove the sub window if the user cancels this dialog?

2341–2342

most people when attaching won't ever specify the plug-in names. I wonder if we should include an extra boolean field that enables this? Maybe:

m_show_plugin_field = AddBooleanField("Show advanced settings.", false);

And then show/hide any settings that aren't commonly used like the "Plugin Name" field?

2388–2394

While loop might be easier here?

2417

Is the form for the kill/detach done by the time it reaches this code? If so, what if the user cancels the Kill/Detach dialog? Can we return false here if the user cancels?

[OmarEmaraDev]

• Return raw pointers instead of unique ones.
• Add Show Advance Settings option.
• Allow detaching and killing at the same time.
• Allow detaching while keeping process stopped.
• Handle review comments.

[OmarEmaraDev]

Two actions with an option:

lldb/source/Core/IOHandlerCursesGUI.cpp

1842

I see, I though returning it as a reference wouldn't case such issues.

2297

I think this might be a good place to add two actions with possible parameters, let me know if you think this would be a good idea.

2323

Yes. This is done in WindowDelegateHandleChar of the FormWindowDelegate.

2341–2342

This what I do for the launch and target creation forms. In this case, I didn't think it was worth it because it was just one field. But now that it is a choice field that takes a bit more space, maybe it would be a good idea to do this here as well.

2417

No, the return boolean here essentially denotes that a form for killing/detaching was spawned and that the attach form shouldn't continue executing. Once the user executes an action or cancels, the user will end up in the same attach from, where the user can execute attach again where it will succeed without the kill/detach dialog.

I can't think of a way to make the form block execution of another form until it is done without resorting to complicated trickery.

[clayborg]

I like the new detach/kill dialog as it incorporates many of your features that you added to the forms! Very close, just a few minor issues and this will be good to go.

lldb/source/Core/IOHandlerCursesGUI.cpp

1842

You are correct unless the caller of the function doesn't use a reference. All of the call sites you had in here were using references, so there wasn't an issue. But if someone else comes along and actually wrote code like the snipped I posted above, it would transfer ownership and that would be bad.

2048–2051

2417

Ok, thanks for the explanation. It makes sense.

2421

Should be easy to verify if it is needed or not. If it is, we will need to add it back.

[OmarEmaraDev]

• Manually continue if needed.

lldb/source/Core/IOHandlerCursesGUI.cpp

2421

Looks like it is actually needed. I added it it back.

[clayborg]

Looks good!

lldb/source/Core/IOHandlerCursesGUI.cpp

 //===-- IOHandlerCursesGUI.cpp --------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/IOHandlerCursesGUI.h"
 #include "lldb/Host/Config.h"
 
 #if LLDB_ENABLE_CURSES
 #if CURSES_HAVE_NCURSES_CURSES_H
 #include <ncurses/curses.h>
 #include <ncurses/panel.h>
 #else
 #include <curses.h>
if (m_window && m_delete) {
       m_delete = false;
     }
     if (w) {
       m_window = w;
       m_panel = ::new_panel(m_window);
       m_delete = del;
     }
   }
-  //
+
   // Get the rectangle in our parent window
   Rect GetBounds() const { return Rect(GetParentOrigin(), GetSize()); }
+
+  Rect GetCenteredRect(int width, int height) {
+    Size size = GetSize();
+    width = std::min(size.width, width);
+    height = std::min(size.height, height);
+    int x = (size.width - width) / 2;
+    int y = (size.height - height) / 2;
+    return Rect(Point(x, y), Size(width, height));
+  }
+
   int GetChar() { return ::wgetch(m_window); }
   Point GetParentOrigin() const { return Point(GetParentX(), GetParentY()); }
   int GetParentX() const { return getparx(m_window); }
   int GetParentY() const { return getpary(m_window); }
   void MoveWindow(int x, int y) { MoveWindow(Point(x, y)); }
   void Resize(int w, int h) { ::wresize(m_window, h, w); }
   void Resize(const Size &size) {
     ::wresize(m_window, size.height, size.width);
public:
   // contains a single element.
   virtual bool FieldDelegateOnLastOrOnlyElement() { return true; }
 
   // Select the first element in the field if multiple elements exists.
   virtual void FieldDelegateSelectFirstElement() { return; }
 
   // Select the last element in the field if multiple elements exists.
   virtual void FieldDelegateSelectLastElement() { return; }
+
+  bool FieldDelegateIsVisible() { return m_is_visible; }
+
+  void FieldDelegateHide() { m_is_visible = false; }
+
+  void FieldDelegateShow() { m_is_visible = true; }
+
+protected:
+  bool m_is_visible = true;
 };
 
 typedef std::shared_ptr<FieldDelegate> FieldDelegateSP;
 
 class TextFieldDelegate : public FieldDelegate {
 public:
   TextFieldDelegate(const char *label, const char *content)
       : m_label(label), m_cursor_position(0), m_first_visibile_char(0) {

 };
 
 class FormDelegate {
 public:
   FormDelegate() {}
 
   virtual ~FormDelegate() = default;
 
+  virtual std::string GetName() = 0;
+
+  virtual void UpdateFieldsVisibility() { return; }
+
   FieldDelegateSP &GetField(int field_index) { return m_fields[field_index]; }
 
   FormAction &GetAction(int action_index) { return m_actions[action_index]; }
 
   int GetNumberOfFields() { return m_fields.size(); }
 
   int GetNumberOfActions() { return m_actions.size(); }
 
   bool HasError() { return !m_error.empty(); }
 
   void ClearError() { m_error.clear(); }
 
   const std::string &GetError() { return m_error; }
public:
 
   // Factory methods for adding actions.
 
   void AddAction(const char *label, std::function<void(Window &)> action) {
     m_actions.push_back(FormAction(label, action));
   }
 
 protected:
   std::vector<FieldDelegateSP> m_fields;
   std::vector<FormAction> m_actions;
   // Optional error message. If empty, form is considered to have no error.
   std::string m_error;
 };
 
 typedef std::shared_ptr<FormDelegate> FormDelegateSP;
 
 class FormWindowDelegate : public WindowDelegate {
int GetActionsHeight() {
     return 0;
   }
 
   // Get the total number of needed lines to draw the contents.
   int GetContentHeight() {
     int height = 0;
     height += GetErrorHeight();
     for (int i = 0; i < m_delegate_sp->GetNumberOfFields(); i++) {
+      if (!m_delegate_sp->GetField(i)->FieldDelegateIsVisible())
+        continue;
       height += m_delegate_sp->GetField(i)->FieldDelegateGetHeight();
     }
     height += GetActionsHeight();
     return height;
   }
 
   ScrollContext GetScrollContext() {
     if (m_selection_type == SelectionType::Action)
       return ScrollContext(GetContentHeight() - 1);
 
     FieldDelegateSP &field = m_delegate_sp->GetField(m_selection_index);
     ScrollContext context = field->FieldDelegateGetScrollContext();
 
     int offset = GetErrorHeight();
     for (int i = 0; i < m_selection_index; i++) {
+      if (!m_delegate_sp->GetField(i)->FieldDelegateIsVisible())
+        continue;
       offset += m_delegate_sp->GetField(i)->FieldDelegateGetHeight();
     }
     context.Offset(offset);
 
     // If the context is touching the error, include the error in the context as
     // well.
     if (context.start == GetErrorHeight())
       context.start = 0;
void DrawError(SubPad &surface) {
     surface.HorizontalLine(surface.GetWidth());
   }
 
   void DrawFields(SubPad &surface) {
     int line = 0;
     int width = surface.GetWidth();
     bool a_field_is_selected = m_selection_type == SelectionType::Field;
     for (int i = 0; i < m_delegate_sp->GetNumberOfFields(); i++) {
+      if (!m_delegate_sp->GetField(i)->FieldDelegateIsVisible())
+        continue;
       bool is_field_selected = a_field_is_selected && m_selection_index == i;
       FieldDelegateSP &field = m_delegate_sp->GetField(i);
       int height = field->FieldDelegateGetHeight();
       Rect bounds = Rect(Point(0, line), Size(width, height));
       SubPad field_surface = SubPad(surface, bounds);
       field->FieldDelegateDraw(field_surface, is_field_selected);
       line += height;
     }
   }
 
void DrawContent(DerivedWindow &surface) {
     DrawElements(elements_surface);
 
     int copy_height = std::min(surface.GetHeight(), pad.GetHeight());
     pad.CopyToSurface(surface, Point(0, m_first_visible_line), Point(),
                       Size(width, copy_height));
   }
 
   bool WindowDelegateDraw(Window &window, bool force) override {
+    m_delegate_sp->UpdateFieldsVisibility();
 
     window.Erase();
 
-    window.DrawTitleBox(window.GetName(), "Press Esc to cancel");
+    window.DrawTitleBox(m_delegate_sp->GetName().c_str(),
+                        "Press Esc to cancel");
 
     Rect content_bounds = window.GetFrame();
     content_bounds.Inset(2, 2);
     DerivedWindow content_surface = DerivedWindow(window, content_bounds);
 
     DrawContent(content_surface);
     return true;
   }
 
+  void SkipNextHiddenFields() {
+    while (true) {
+      if (m_delegate_sp->GetField(m_selection_index)->FieldDelegateIsVisible())
+        return;
+
+      if (m_selection_index == m_delegate_sp->GetNumberOfFields() - 1) {
+        m_selection_type = SelectionType::Action;
+        m_selection_index = 0;
+        return;
+      }
+
+      m_selection_index++;
+    }
+  }
+
   HandleCharResult SelecteNext(int key) {
     if (m_selection_type == SelectionType::Action) {
       if (m_selection_index < m_delegate_sp->GetNumberOfActions() - 1) {
         m_selection_index++;
         return eKeyHandled;
       }
 
       m_selection_index = 0;
       m_selection_type = SelectionType::Field;
-      FieldDelegateSP &next_field = m_delegate_sp->GetField(m_selection_index);
+      SkipNextHiddenFields();
+      if (m_selection_type == SelectionType::Field) {
+        FieldDelegateSP &next_field =
+            m_delegate_sp->GetField(m_selection_index);
         next_field->FieldDelegateSelectFirstElement();
+      }
       return eKeyHandled;
     }
 
     FieldDelegateSP &field = m_delegate_sp->GetField(m_selection_index);
     if (!field->FieldDelegateOnLastOrOnlyElement()) {
       return field->FieldDelegateHandleChar(key);
     }
 
     field->FieldDelegateExitCallback();
 
     if (m_selection_index == m_delegate_sp->GetNumberOfFields() - 1) {
       m_selection_type = SelectionType::Action;
       m_selection_index = 0;
       return eKeyHandled;
     }
 
     m_selection_index++;
+    SkipNextHiddenFields();
 
+    if (m_selection_type == SelectionType::Field) {
       FieldDelegateSP &next_field = m_delegate_sp->GetField(m_selection_index);
       next_field->FieldDelegateSelectFirstElement();
+    }
 
     return eKeyHandled;
   }
 
+  void SkipPreviousHiddenFields() {
+    while (true) {
+      if (m_delegate_sp->GetField(m_selection_index)->FieldDelegateIsVisible())
+        return;
+
+      if (m_selection_index == 0) {
+        m_selection_type = SelectionType::Action;
+        m_selection_index = 0;
+        return;
+      }
+
+      m_selection_index--;
+    }
+  }
+
   HandleCharResult SelectePrevious(int key) {
     if (m_selection_type == SelectionType::Action) {
       if (m_selection_index > 0) {
         m_selection_index--;
         return eKeyHandled;
       }
       m_selection_index = m_delegate_sp->GetNumberOfFields() - 1;
       m_selection_type = SelectionType::Field;
+      SkipPreviousHiddenFields();
+      if (m_selection_type == SelectionType::Field) {
         FieldDelegateSP &previous_field =
             m_delegate_sp->GetField(m_selection_index);
         previous_field->FieldDelegateSelectLastElement();
+      }
       return eKeyHandled;
     }
 
     FieldDelegateSP &field = m_delegate_sp->GetField(m_selection_index);
     if (!field->FieldDelegateOnFirstOrOnlyElement()) {
       return field->FieldDelegateHandleChar(key);
     }
 
     field->FieldDelegateExitCallback();
 
     if (m_selection_index == 0) {
       m_selection_type = SelectionType::Action;
       m_selection_index = m_delegate_sp->GetNumberOfActions() - 1;
       return eKeyHandled;
     }
 
     m_selection_index--;
+    SkipPreviousHiddenFields();
 
+    if (m_selection_type == SelectionType::Field) {
       FieldDelegateSP &previous_field =
           m_delegate_sp->GetField(m_selection_index);
       previous_field->FieldDelegateSelectLastElement();
+    }
 
     return eKeyHandled;
   }
 
   void ExecuteAction(Window &window) {
     FormAction &action = m_delegate_sp->GetAction(m_selection_index);
     action.Execute(window);
     m_first_visible_line = 0;
case KEY_ESCAPE:
       return eKeyHandled;
     default:
       break;
     }
 
     // If the key wasn't handled and one of the fields is selected, pass the key
     // to that field.
     if (m_selection_type == SelectionType::Field) {
       FieldDelegateSP &field = m_delegate_sp->GetField(m_selection_index);
       return field->FieldDelegateHandleChar(key);
     }
 
     return eKeyNotHandled;
   }
 
 protected:
   FormDelegateSP m_delegate_sp;
   // The index of the currently selected SelectionType.
   int m_selection_index;
   // See SelectionType class enum.
   SelectionType m_selection_type;
   // The first visible line from the pad.
   int m_first_visible_line;
 };
 
+///////////////////////////
+// Form Delegate Instances
+///////////////////////////
+
+class ProcessAttachFormDelegate : public FormDelegate {
+public:
+  ProcessAttachFormDelegate(Debugger &debugger) : m_debugger(debugger) {
+    std::vector<std::string> types;
+    types.push_back(std::string("Name"));
+    types.push_back(std::string("PID"));
+    m_type_field = AddChoicesField("Attach By", 2, types);
+
+    m_pid_field = AddIntegerField("PID", 0);
+
+    m_name_field = AddTextField("Process Name", "");
+
+    m_plugin_field = AddTextField("Plugin Name", "");
+
+    m_continue_field = AddBooleanField("Continue once attached.", false);
+
+    m_wait_for_field = AddBooleanField("Wait for process to launch.", false);
+    m_include_existing_field =
+        AddBooleanField("Include existing processes.", false);
+
+    AddAction("Attach", [this](Window &window) { Attach(window); });
+  }
+
+  std::string GetName() override { return "Attach Process"; }
+
+  void UpdateFieldsVisibility() override {
+    if (m_type_field->GetChoiceContent() == "Name") {
+      m_pid_field->FieldDelegateHide();
+      m_name_field->FieldDelegateShow();
+      m_wait_for_field->FieldDelegateShow();
+      if (m_wait_for_field->GetBoolean())
+        m_include_existing_field->FieldDelegateShow();
+      else
+        m_include_existing_field->FieldDelegateHide();
+    } else {
+      m_pid_field->FieldDelegateShow();
+      m_name_field->FieldDelegateHide();
+      m_wait_for_field->FieldDelegateHide();
+      m_include_existing_field->FieldDelegateHide();
+    }
+  }
+
+  void StopProcessIfNecessary() {
+    ExecutionContext exe_ctx =
+        m_debugger.GetCommandInterpreter().GetExecutionContext();
+
+    if (!exe_ctx.HasProcessScope())
+      return;
+
+    Process *process = exe_ctx.GetProcessPtr();
+    if (!(process && process->IsAlive()))
+      return;
+
+    if (process->GetShouldDetach()) {
+      Status detach_status(process->Detach(false));
+      if (detach_status.Fail())
+        SetError("Failed to detach from existing process.");
+    } else {
+      Status destroy_status(process->Destroy(false));
+      if (destroy_status.Fail())
+        SetError("Failed to kill exising process.");
+    }
+  }
+
+  Target *GetTarget() {
+    Target *target = m_debugger.GetSelectedTarget().get();
+
+    if (target != nullptr)
+      return target;
+
+    TargetSP new_target_sp;
+    m_debugger.GetTargetList().CreateTarget(
+        m_debugger, "", "", eLoadDependentsNo, nullptr, new_target_sp);
+
+    target = new_target_sp.get();
+
+    if (target == nullptr)
+      SetError("Failed to create target.");
+
+    return target;
+  }
+
+  ProcessAttachInfo GetAttachInfo() {
+    ProcessAttachInfo attach_info;
+    attach_info.SetContinueOnceAttached(m_continue_field->GetBoolean());
+    if (m_type_field->GetChoiceContent() == "Name") {
+      attach_info.GetExecutableFile().SetFile(m_name_field->GetText(),
+                                              FileSpec::Style::native);
+      attach_info.SetWaitForLaunch(m_wait_for_field->GetBoolean());
+      if (m_wait_for_field->GetBoolean())
+        attach_info.SetIgnoreExisting(!m_include_existing_field->GetBoolean());
+    } else {
+      attach_info.SetProcessID(m_pid_field->GetInteger());
+    }
+    if (!m_plugin_field->GetText().empty())
+      attach_info.SetProcessPluginName(m_plugin_field->GetText());
+
+    return attach_info;
+  }
+
+  void Attach(Window &window) {
+    ClearError();
+
+    StopProcessIfNecessary();
+    if (HasError())
+      return;
+
+    Target *target = GetTarget();
+    if (HasError())
+      return;
+
+    StreamString stream;
+    ProcessAttachInfo attach_info = GetAttachInfo();
+    Status status = target->Attach(attach_info, &stream);
+
+    if (status.Fail()) {
+      SetError(status.AsCString());
+      return;
+    }
+
+    ProcessSP process_sp(target->GetProcessSP());
+    if (!process_sp) {
+      SetError("Attached sucessfully but target has no process.");
+      return;
+    }
+
+    if (attach_info.GetContinueOnceAttached())
+      process_sp->Resume();
+
+    window.GetParent()->RemoveSubWindow(&window);
+  }
+
+protected:
+  Debugger &m_debugger;
+
+  ChoicesFieldDelegate *m_type_field;
+  IntegerFieldDelegate *m_pid_field;
+  TextFieldDelegate *m_name_field;
+  TextFieldDelegate *m_plugin_field;
+  BooleanFieldDelegate *m_continue_field;
+  BooleanFieldDelegate *m_wait_for_field;
+  BooleanFieldDelegate *m_include_existing_field;
+};
+
 class MenuDelegate {
 public:
   virtual ~MenuDelegate() = default;
 
   virtual MenuActionResult MenuDelegateAction(Menu &menu) = 0;
 };
 
 class Menu : public WindowDelegate {
case eMenuID_ThreadStepOver: {
         Process *process = exe_ctx.GetProcessPtr();
         if (process && process->IsAlive() &&
             StateIsStoppedState(process->GetState(), true))
           exe_ctx.GetThreadRef().StepOver(true);
       }
     }
       return MenuActionResult::Handled;
 
+    case eMenuID_ProcessAttach: {
+      WindowSP main_window_sp = m_app.GetMainWindow();
+      FormDelegateSP form_delegate_sp =
+          FormDelegateSP(new ProcessAttachFormDelegate(m_debugger));
+      Rect bounds = main_window_sp->GetCenteredRect(80, 19);
+      WindowSP form_window_sp = main_window_sp->CreateSubWindow(
+          form_delegate_sp->GetName().c_str(), bounds, true);
+      WindowDelegateSP window_delegate_sp =
+          WindowDelegateSP(new FormWindowDelegate(form_delegate_sp));
+      form_window_sp->SetDelegate(window_delegate_sp);
+      return MenuActionResult::Handled;
+    }
+
     case eMenuID_ProcessContinue: {
       ExecutionContext exe_ctx =
           m_debugger.GetCommandInterpreter().GetExecutionContext();
       if (exe_ctx.HasProcessScope()) {
         Process *process = exe_ctx.GetProcessPtr();
         if (process && process->IsAlive() &&
             StateIsStoppedState(process->GetState(), true))
           process->Resume();