<!DOCTYPE HTML>
<html lang="en">
<head>
<!-- Generated by javadoc (17) -->
<title>GuiPackage (Apache JMeter dist API)</title>
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<meta name="description" content="declaration: package: org.apache.jmeter.gui, class: GuiPackage">
<meta name="generator" content="javadoc/ClassWriterImpl">
<link rel="stylesheet" type="text/css" href="../../../../stylesheet.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../script-dir/jquery-ui.min.css" title="Style">
<link rel="stylesheet" type="text/css" href="../../../../jquery-ui.overrides.css" title="Style">
<script type="text/javascript" src="../../../../script.js"></script>
<script type="text/javascript" src="../../../../script-dir/jquery-3.6.1.min.js"></script>
<script type="text/javascript" src="../../../../script-dir/jquery-ui.min.js"></script>
</head>
<body class="class-declaration-page">
<script type="text/javascript">var evenRowColor = "even-row-color";
var oddRowColor = "odd-row-color";
var tableTab = "table-tab";
var activeTableTab = "active-table-tab";
var pathtoroot = "../../../../";
loadScripts(document, 'script');</script>
<noscript>
<div>JavaScript is disabled on your browser.</div>
</noscript>
<div class="flex-box">
<header role="banner" class="flex-header">
<nav role="navigation">
<!-- ========= START OF TOP NAVBAR ======= -->
<div class="top-nav" id="navbar-top">
<div class="skip-nav"><a href="#skip-navbar-top" title="Skip navigation links">Skip navigation links</a></div>
<div class="about-language"><b>Apache JMeter</b></div>
<ul id="navbar-top-firstrow" class="nav-list" title="Navigation">
<li><a href="../../../../index.html">Overview</a></li>
<li><a href="package-summary.html">Package</a></li>
<li class="nav-bar-cell1-rev">Class</li>
<li><a href="package-tree.html">Tree</a></li>
<li><a href="../../../../deprecated-list.html">Deprecated</a></li>
<li><a href="../../../../index-all.html">Index</a></li>
<li><a href="../../../../help-doc.html#class">Help</a></li>
</ul>
</div>
<div class="sub-nav">
<div>
<ul class="sub-nav-list">
<li>Summary:&nbsp;</li>
<li>Nested&nbsp;|&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method-summary">Method</a></li>
</ul>
<ul class="sub-nav-list">
<li>Detail:&nbsp;</li>
<li>Field&nbsp;|&nbsp;</li>
<li>Constr&nbsp;|&nbsp;</li>
<li><a href="#method-detail">Method</a></li>
</ul>
</div>
<div class="nav-list-search"><label for="search-input">SEARCH:</label>
<input type="text" id="search-input" value="search" disabled="disabled">
<input type="reset" id="reset-button" value="reset" disabled="disabled">
</div>
</div>
<!-- ========= END OF TOP NAVBAR ========= -->
<span class="skip-nav" id="skip-navbar-top"></span></nav>
</header>
<div class="flex-content">
<main role="main">
<!-- ======== START OF CLASS DATA ======== -->
<div class="header">
<div class="sub-title"><span class="package-label-in-type">Package</span>&nbsp;<a href="package-summary.html">org.apache.jmeter.gui</a></div>
<h1 title="Class GuiPackage" class="title">Class GuiPackage</h1>
</div>
<div class="inheritance" title="Inheritance Tree"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">java.lang.Object</a>
<div class="inheritance">org.apache.jmeter.gui.GuiPackage</div>
</div>
<section class="class-description" id="class-description">
<dl class="notes">
<dt>All Implemented Interfaces:</dt>
<dd><code><a href="UndoHistory.HistoryListener.html" title="interface in org.apache.jmeter.gui">UndoHistory.HistoryListener</a></code>, <code><a href="../util/LocaleChangeListener.html" title="interface in org.apache.jmeter.util">LocaleChangeListener</a></code></dd>
</dl>
<hr>
<div class="type-signature"><span class="modifiers">public final class </span><span class="element-name type-name-label">GuiPackage</span>
<span class="extends-implements">extends <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a>
implements <a href="../util/LocaleChangeListener.html" title="interface in org.apache.jmeter.util">LocaleChangeListener</a>, <a href="UndoHistory.HistoryListener.html" title="interface in org.apache.jmeter.gui">UndoHistory.HistoryListener</a></span></div>
<div class="block">GuiPackage is a static class that provides convenient access to information
 about the current state of JMeter's GUI. Any GUI class can grab a handle to
 GuiPackage by calling the static method <a href="#getInstance()"><code>getInstance()</code></a> and then use
 it to query the GUI about it's state. When actions, for instance, need to
 affect the GUI, they typically use GuiPackage to get access to different
 parts of the GUI.</div>
</section>
<section class="summary">
<ul class="summary-list">
<!-- ========== METHOD SUMMARY =========== -->
<li>
<section class="method-summary" id="method-summary">
<h2>Method Summary</h2>
<div id="method-summary-table">
<div class="table-tabs" role="tablist" aria-orientation="horizontal"><button id="method-summary-table-tab0" role="tab" aria-selected="true" aria-controls="method-summary-table.tabpanel" tabindex="0" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table', 3)" class="active-table-tab">All Methods</button><button id="method-summary-table-tab1" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab1', 3)" class="table-tab">Static Methods</button><button id="method-summary-table-tab2" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab2', 3)" class="table-tab">Instance Methods</button><button id="method-summary-table-tab4" role="tab" aria-selected="false" aria-controls="method-summary-table.tabpanel" tabindex="-1" onkeydown="switchTab(event)" onclick="show('method-summary-table', 'method-summary-table-tab4', 3)" class="table-tab">Concrete Methods</button></div>
<div id="method-summary-table.tabpanel" role="tabpanel">
<div class="summary-table three-column-summary" aria-labelledby="method-summary-table-tab0">
<div class="table-header col-first">Modifier and Type</div>
<div class="table-header col-second">Method</div>
<div class="table-header col-last">Description</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../../jorphan/collections/HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#addSubTree(org.apache.jorphan.collections.HashTree)" class="member-name-link">addSubTree</a><wbr>(<a href="../../jorphan/collections/HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&nbsp;subTree)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Add a subtree to the currently selected node.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#addTestPlanListener(org.apache.jmeter.gui.TestPlanListener)" class="member-name-link">addTestPlanListener</a><wbr>(<a href="TestPlanListener.html" title="interface in org.apache.jmeter.gui">TestPlanListener</a>&nbsp;listener)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Adds a test plan listener.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#beginUndoTransaction()" class="member-name-link">beginUndoTransaction</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Begin a group of actions modeled as 1 undo</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#canRedo()" class="member-name-link">canRedo</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#canUndo()" class="member-name-link">canUndo</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#clearTestPlan()" class="member-name-link">clearTestPlan</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Clears the test plan and associated objects.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#clearTestPlan(org.apache.jmeter.testelement.TestElement)" class="member-name-link">clearTestPlan</a><wbr>(org.apache.jmeter.testelement.TestElement&nbsp;element)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Clears the test plan element and associated object</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>org.apache.jmeter.testelement.TestElement</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#createTestElement(java.lang.Class,java.lang.Class)" class="member-name-link">createTestElement</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;?&gt;&nbsp;guiClass,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;?&gt;&nbsp;testClass)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Create a TestElement corresponding to the specified GUI class.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>org.apache.jmeter.testelement.TestElement</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#createTestElement(java.lang.String)" class="member-name-link">createTestElement</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;objClass)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Create a TestElement for a GUI or TestBean class.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#displayPopUp(java.awt.Component,java.awt.event.MouseEvent,javax.swing.JPopupMenu)" class="member-name-link">displayPopUp</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/java/awt/Component.html" title="class or interface in java.awt" class="external-link">Component</a>&nbsp;invoker,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/java/awt/event/MouseEvent.html" title="class or interface in java.awt.event" class="external-link">MouseEvent</a>&nbsp;e,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/swing/JPopupMenu.html" title="class or interface in javax.swing" class="external-link">JPopupMenu</a>&nbsp;popup)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Display the specified popup menu at the location specified by a mouse
 event with the specified source component.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#displayPopUp(java.awt.event.MouseEvent,javax.swing.JPopupMenu)" class="member-name-link">displayPopUp</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/java/awt/event/MouseEvent.html" title="class or interface in java.awt.event" class="external-link">MouseEvent</a>&nbsp;e,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/swing/JPopupMenu.html" title="class or interface in javax.swing" class="external-link">JPopupMenu</a>&nbsp;popup)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Display the specified popup menu with the source component and location
 from the specified mouse event.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#endUndoTransaction()" class="member-name-link">endUndoTransaction</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">End a group of actions modeled as 1 undo</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>org.apache.jmeter.testelement.TestElement</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getCurrentElement()" class="member-name-link">getCurrentElement</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="JMeterGUIComponent.html" title="interface in org.apache.jmeter.gui">JMeterGUIComponent</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getCurrentGui()" class="member-name-link">getCurrentGui</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Convenience method for grabbing the gui for the current node.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="tree/JMeterTreeNode.html" title="class in org.apache.jmeter.gui.tree">JMeterTreeNode</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getCurrentNode()" class="member-name-link">getCurrentNode</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../../jorphan/collections/HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getCurrentSubTree()" class="member-name-link">getCurrentSubTree</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Get the currently selected subtree.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="JMeterGUIComponent.html" title="interface in org.apache.jmeter.gui">JMeterGUIComponent</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getGui(org.apache.jmeter.testelement.TestElement)" class="member-name-link">getGui</a><wbr>(org.apache.jmeter.testelement.TestElement&nbsp;node)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Get a JMeterGUIComponent for the specified test element.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="JMeterGUIComponent.html" title="interface in org.apache.jmeter.gui">JMeterGUIComponent</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getGui(org.apache.jmeter.testelement.TestElement,java.lang.Class,java.lang.Class)" class="member-name-link">getGui</a><wbr>(org.apache.jmeter.testelement.TestElement&nbsp;node,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;?&gt;&nbsp;guiClass,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;?&gt;&nbsp;testClass)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Get a JMeterGUIComponent for the specified test element.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static <a href="GuiPackage.html" title="class in org.apache.jmeter.gui">GuiPackage</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#getInstance()" class="member-name-link">getInstance</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">Retrieve the singleton GuiPackage instance.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="logging/GuiLogEventBus.html" title="class in org.apache.jmeter.gui.logging">GuiLogEventBus</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getLogEventBus()" class="member-name-link">getLogEventBus</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Return <a href="logging/GuiLogEventBus.html" title="class in org.apache.jmeter.gui.logging"><code>GuiLogEventBus</code></a>.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="LoggerPanel.html" title="class in org.apache.jmeter.gui">LoggerPanel</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getLoggerPanel()" class="member-name-link">getLoggerPanel</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="MainFrame.html" title="class in org.apache.jmeter.gui">MainFrame</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getMainFrame()" class="member-name-link">getMainFrame</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Get the main JMeter frame.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/swing/JToolBar.html" title="class or interface in javax.swing" class="external-link">JToolBar</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getMainToolbar()" class="member-name-link">getMainToolbar</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Get the main JMeter toolbar.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/swing/JCheckBoxMenuItem.html" title="class or interface in javax.swing" class="external-link">JCheckBoxMenuItem</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getMenuItemLoggerPanel()" class="member-name-link">getMenuItemLoggerPanel</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Get the menu item LoggerPanel.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/swing/JCheckBoxMenuItem.html" title="class or interface in javax.swing" class="external-link">JCheckBoxMenuItem</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getMenuItemSaveBeforeRunPanel()" class="member-name-link">getMenuItemSaveBeforeRunPanel</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Get the menu item SaveBeforeRunPanel.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="action/TreeNodeNamingPolicy.html" title="interface in org.apache.jmeter.gui.action">TreeNodeNamingPolicy</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getNamingPolicy()" class="member-name-link">getNamingPolicy</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="tree/JMeterTreeNode.html" title="class in org.apache.jmeter.gui.tree">JMeterTreeNode</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getNodeOf(org.apache.jmeter.testelement.TestElement)" class="member-name-link">getNodeOf</a><wbr>(org.apache.jmeter.testelement.TestElement&nbsp;userObject)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Find the JMeterTreeNode for a certain TestElement object.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="../engine/util/ValueReplacer.html" title="class in org.apache.jmeter.engine.util">ValueReplacer</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getReplacer()" class="member-name-link">getReplacer</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Get a ValueReplacer for the test tree.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="Stoppable.html" title="interface in org.apache.jmeter.gui">Stoppable</a>&gt;</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getStoppables()" class="member-name-link">getStoppables</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getTestPlanFile()" class="member-name-link">getTestPlanFile</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="tree/JMeterTreeListener.html" title="class in org.apache.jmeter.gui.tree">JMeterTreeListener</a></code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getTreeListener()" class="member-name-link">getTreeListener</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Get the listener for JMeter's test tree.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="tree/JMeterTreeModel.html" title="class in org.apache.jmeter.gui.tree">JMeterTreeModel</a></code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#getTreeModel()" class="member-name-link">getTreeModel</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Get the model for JMeter's test tree.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#initInstance(org.apache.jmeter.gui.tree.JMeterTreeListener,org.apache.jmeter.gui.tree.JMeterTreeModel)" class="member-name-link">initInstance</a><wbr>(<a href="tree/JMeterTreeListener.html" title="class in org.apache.jmeter.gui.tree">JMeterTreeListener</a>&nbsp;listener,
 <a href="tree/JMeterTreeModel.html" title="class in org.apache.jmeter.gui.tree">JMeterTreeModel</a>&nbsp;treeModel)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">
<div class="block">When GuiPackage is requested for the first time, it should be given
 handles to JMeter's Tree Listener and TreeModel.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#invalidateCachedUi()" class="member-name-link">invalidateCachedUi</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#isDirty()" class="member-name-link">isDirty</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Retrieves the state of the 'dirty' property, a flag that indicates if
 there are test tree components that have been modified since they were
 last saved.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#localeChanged(org.apache.jmeter.util.LocaleChangeEvent)" class="member-name-link">localeChanged</a><wbr>(<a href="../util/LocaleChangeEvent.html" title="class in org.apache.jmeter.util">LocaleChangeEvent</a>&nbsp;event)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"></div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#notifyChangeInHistory(org.apache.jmeter.gui.UndoHistory)" class="member-name-link">notifyChangeInHistory</a><wbr>(<a href="UndoHistory.html" title="class in org.apache.jmeter.gui">UndoHistory</a>&nbsp;history)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Called when history changes, it updates toolbar</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#redo()" class="member-name-link">redo</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Navigate forward through undo history</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#refreshCurrentGui()" class="member-name-link">refreshCurrentGui</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Refresh GUI from node state.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#register(org.apache.jmeter.gui.Stoppable)" class="member-name-link">register</a><wbr>(<a href="Stoppable.html" title="interface in org.apache.jmeter.gui">Stoppable</a>&nbsp;stoppable)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Register process to stop on reload</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#registerAsListener()" class="member-name-link">registerAsListener</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Register as listener of:
 - UndoHistory
 - Locale Changes</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#removeNode(org.apache.jmeter.testelement.TestElement)" class="member-name-link">removeNode</a><wbr>(org.apache.jmeter.testelement.TestElement&nbsp;node)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Remove a test element from the tree.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#removeTestPlanListener(org.apache.jmeter.gui.TestPlanListener)" class="member-name-link">removeTestPlanListener</a><wbr>(<a href="TestPlanListener.html" title="interface in org.apache.jmeter.gui">TestPlanListener</a>&nbsp;listener)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Removes a test plan listener.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setDirty(boolean)" class="member-name-link">setDirty</a><wbr>(boolean&nbsp;dirty)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">The dirty property is a flag that indicates whether there are parts of
 JMeter's test tree that the user has not saved since last modification.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setLoggerPanel(org.apache.jmeter.gui.LoggerPanel)" class="member-name-link">setLoggerPanel</a><wbr>(<a href="LoggerPanel.html" title="class in org.apache.jmeter.gui">LoggerPanel</a>&nbsp;loggerPanel)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setMainFrame(org.apache.jmeter.gui.MainFrame)" class="member-name-link">setMainFrame</a><wbr>(<a href="MainFrame.html" title="class in org.apache.jmeter.gui">MainFrame</a>&nbsp;newMainFrame)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Set the main JMeter frame.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setMainToolbar(javax.swing.JToolBar)" class="member-name-link">setMainToolbar</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/swing/JToolBar.html" title="class or interface in javax.swing" class="external-link">JToolBar</a>&nbsp;newToolbar)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Set the main JMeter toolbar.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setMenuItemLoggerPanel(javax.swing.JCheckBoxMenuItem)" class="member-name-link">setMenuItemLoggerPanel</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/swing/JCheckBoxMenuItem.html" title="class or interface in javax.swing" class="external-link">JCheckBoxMenuItem</a>&nbsp;menuItemLoggerPanel)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Set the menu item LoggerPanel.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setMenuItemSaveBeforeRunPanel(javax.swing.JCheckBoxMenuItem)" class="member-name-link">setMenuItemSaveBeforeRunPanel</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/swing/JCheckBoxMenuItem.html" title="class or interface in javax.swing" class="external-link">JCheckBoxMenuItem</a>&nbsp;menuItemSaveBeforeRunPanel)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Set the menu item SaveBeforeRunPanel.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setSaveBeforeRunByPreference(boolean)" class="member-name-link">setSaveBeforeRunByPreference</a><wbr>(boolean&nbsp;saveBeforeRun)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Should Save Before Run by Preference Only</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#setTestPlanFile(java.lang.String)" class="member-name-link">setTestPlanFile</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;f)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Sets the filepath of the current test plan.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#shouldSaveBeforeRun()" class="member-name-link">shouldSaveBeforeRun</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Should Save Before Run
 Decide by Preference and if not exists by Property</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>boolean</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#shouldSaveBeforeRunByPreference()" class="member-name-link">shouldSaveBeforeRunByPreference</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Should Save Before Run by Preference Only</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#showErrorMessage(java.lang.String,java.lang.String)" class="member-name-link">showErrorMessage</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;message,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;title)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#showInfoMessage(java.lang.String,java.lang.String)" class="member-name-link">showInfoMessage</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;message,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;title)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#showMessage(java.lang.String,java.lang.String,int)" class="member-name-link">showMessage</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;message,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;title,
 int&nbsp;type)</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code>static void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4"><code><a href="#showWarningMessage(java.lang.String,java.lang.String)" class="member-name-link">showWarningMessage</a><wbr>(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;message,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;title)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab1 method-summary-table-tab4">&nbsp;</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#undo()" class="member-name-link">undo</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Navigate back through undo history</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#unregister(org.apache.jmeter.gui.Stoppable)" class="member-name-link">unregister</a><wbr>(<a href="Stoppable.html" title="interface in org.apache.jmeter.gui">Stoppable</a>&nbsp;stoppableToUnregister)</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Unregister stoppable</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#updateCurrentGui()" class="member-name-link">updateCurrentGui</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Update the GUI for the currently selected node.</div>
</div>
<div class="col-first even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#updateCurrentNode()" class="member-name-link">updateCurrentNode</a>()</code></div>
<div class="col-last even-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">This method should be called in order for GuiPackage to change the
 current node.</div>
</div>
<div class="col-first odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code>void</code></div>
<div class="col-second odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4"><code><a href="#updateUIForHiddenComponents()" class="member-name-link">updateUIForHiddenComponents</a>()</code></div>
<div class="col-last odd-row-color method-summary-table method-summary-table-tab2 method-summary-table-tab4">
<div class="block">Tells hidden GUI components to update UIs when they are shown.</div>
</div>
</div>
</div>
</div>
<div class="inherited-list">
<h3 id="methods-inherited-from-class-java.lang.Object">Methods inherited from class&nbsp;java.lang.<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html" title="class or interface in java.lang" class="external-link">Object</a></h3>
<code><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#clone()" title="class or interface in java.lang" class="external-link">clone</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#equals(java.lang.Object)" title="class or interface in java.lang" class="external-link">equals</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#finalize()" title="class or interface in java.lang" class="external-link">finalize</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#getClass()" title="class or interface in java.lang" class="external-link">getClass</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#hashCode()" title="class or interface in java.lang" class="external-link">hashCode</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#notify()" title="class or interface in java.lang" class="external-link">notify</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#notifyAll()" title="class or interface in java.lang" class="external-link">notifyAll</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#toString()" title="class or interface in java.lang" class="external-link">toString</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#wait()" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#wait(long)" title="class or interface in java.lang" class="external-link">wait</a>, <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Object.html#wait(long,int)" title="class or interface in java.lang" class="external-link">wait</a></code></div>
</section>
</li>
</ul>
</section>
<section class="details">
<ul class="details-list">
<!-- ============ METHOD DETAIL ========== -->
<li>
<section class="method-details" id="method-detail">
<h2>Method Details</h2>
<ul class="member-list">
<li>
<section class="detail" id="getInstance()">
<h3>getInstance</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type"><a href="GuiPackage.html" title="class in org.apache.jmeter.gui">GuiPackage</a></span>&nbsp;<span class="element-name">getInstance</span>()</div>
<div class="block">Retrieve the singleton GuiPackage instance.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the GuiPackage instance (may be null, e.g in non-Gui mode)</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="registerAsListener()">
<h3>registerAsListener</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">registerAsListener</span>()</div>
<div class="block">Register as listener of:
 - UndoHistory
 - Locale Changes</div>
</section>
</li>
<li>
<section class="detail" id="initInstance(org.apache.jmeter.gui.tree.JMeterTreeListener,org.apache.jmeter.gui.tree.JMeterTreeModel)">
<h3>initInstance</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">initInstance</span><wbr><span class="parameters">(<a href="tree/JMeterTreeListener.html" title="class in org.apache.jmeter.gui.tree">JMeterTreeListener</a>&nbsp;listener,
 <a href="tree/JMeterTreeModel.html" title="class in org.apache.jmeter.gui.tree">JMeterTreeModel</a>&nbsp;treeModel)</span></div>
<div class="block">When GuiPackage is requested for the first time, it should be given
 handles to JMeter's Tree Listener and TreeModel.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>listener</code> - the TreeListener for JMeter's test tree</dd>
<dd><code>treeModel</code> - the model for JMeter's test tree</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getGui(org.apache.jmeter.testelement.TestElement)">
<h3>getGui</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="JMeterGUIComponent.html" title="interface in org.apache.jmeter.gui">JMeterGUIComponent</a></span>&nbsp;<span class="element-name">getGui</span><wbr><span class="parameters">(org.apache.jmeter.testelement.TestElement&nbsp;node)</span></div>
<div class="block">Get a JMeterGUIComponent for the specified test element. If the GUI has
 already been created, that instance will be returned. Otherwise, if a GUI
 component of the same type has been created, and the component is not
 marked as an <a href="UnsharedComponent.html" title="interface in org.apache.jmeter.gui"><code>UnsharedComponent</code></a>, that shared component will be
 returned. Otherwise, a new instance of the component will be created. The
 TestElement's GUI_CLASS property will be used to determine the
 appropriate type of GUI component to use.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>node</code> - the test element which this GUI is being created for</dd>
<dt>Returns:</dt>
<dd>the GUI component corresponding to the specified test element</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getGui(org.apache.jmeter.testelement.TestElement,java.lang.Class,java.lang.Class)">
<h3>getGui</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="JMeterGUIComponent.html" title="interface in org.apache.jmeter.gui">JMeterGUIComponent</a></span>&nbsp;<span class="element-name">getGui</span><wbr><span class="parameters">(org.apache.jmeter.testelement.TestElement&nbsp;node,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;?&gt;&nbsp;guiClass,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;?&gt;&nbsp;testClass)</span></div>
<div class="block">Get a JMeterGUIComponent for the specified test element. If the GUI has
 already been created, that instance will be returned. Otherwise, if a GUI
 component of the same type has been created, and the component is not
 marked as an <a href="UnsharedComponent.html" title="interface in org.apache.jmeter.gui"><code>UnsharedComponent</code></a>, that shared component will be
 returned. Otherwise, a new instance of the component will be created.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>node</code> - the test element which this GUI is being created for</dd>
<dd><code>guiClass</code> - the fully qualified class name of the GUI component which will
            be created if it doesn't already exist</dd>
<dd><code>testClass</code> - the fully qualified class name of the test elements which have
            to be edited by the returned GUI component</dd>
<dt>Returns:</dt>
<dd>the GUI component corresponding to the specified test element</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="removeNode(org.apache.jmeter.testelement.TestElement)">
<h3>removeNode</h3>
<div class="member-signature"><span class="annotations">@API(since="5.3",
     status=MAINTAINED)
</span><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">removeNode</span><wbr><span class="parameters">(org.apache.jmeter.testelement.TestElement&nbsp;node)</span></div>
<div class="block">Remove a test element from the tree. This removes the reference to any
 associated GUI component.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>node</code> - the test element being removed</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getCurrentGui()">
<h3>getCurrentGui</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="JMeterGUIComponent.html" title="interface in org.apache.jmeter.gui">JMeterGUIComponent</a></span>&nbsp;<span class="element-name">getCurrentGui</span>()</div>
<div class="block">Convenience method for grabbing the gui for the current node.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the GUI component associated with the currently selected node</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getNodeOf(org.apache.jmeter.testelement.TestElement)">
<h3>getNodeOf</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="tree/JMeterTreeNode.html" title="class in org.apache.jmeter.gui.tree">JMeterTreeNode</a></span>&nbsp;<span class="element-name">getNodeOf</span><wbr><span class="parameters">(org.apache.jmeter.testelement.TestElement&nbsp;userObject)</span></div>
<div class="block">Find the JMeterTreeNode for a certain TestElement object.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>userObject</code> - the test element to search for</dd>
<dt>Returns:</dt>
<dd>the tree node associated with the test element</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="createTestElement(java.lang.Class,java.lang.Class)">
<h3>createTestElement</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">org.apache.jmeter.testelement.TestElement</span>&nbsp;<span class="element-name">createTestElement</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;?&gt;&nbsp;guiClass,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/Class.html" title="class or interface in java.lang" class="external-link">Class</a>&lt;?&gt;&nbsp;testClass)</span></div>
<div class="block">Create a TestElement corresponding to the specified GUI class.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>guiClass</code> - the fully qualified class name of the GUI component or a
            TestBean class for TestBeanGUIs.</dd>
<dd><code>testClass</code> - the fully qualified class name of the test elements edited by
            this GUI component.</dd>
<dt>Returns:</dt>
<dd>the test element corresponding to the specified GUI class.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="createTestElement(java.lang.String)">
<h3>createTestElement</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">org.apache.jmeter.testelement.TestElement</span>&nbsp;<span class="element-name">createTestElement</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;objClass)</span></div>
<div class="block">Create a TestElement for a GUI or TestBean class.
 <p>
 This is a utility method to help actions do with one single String
 parameter.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>objClass</code> - the fully qualified class name of the GUI component or of the
            TestBean subclass for which a TestBeanGUI is wanted.</dd>
<dt>Returns:</dt>
<dd>the test element corresponding to the specified GUI class.</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="updateCurrentGui()">
<h3>updateCurrentGui</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">updateCurrentGui</span>()</div>
<div class="block">Update the GUI for the currently selected node. The GUI component is
 configured to reflect the settings in the current tree node.</div>
</section>
</li>
<li>
<section class="detail" id="refreshCurrentGui()">
<h3>refreshCurrentGui</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">refreshCurrentGui</span>()</div>
<div class="block">Refresh GUI from node state.
 This method does not update the current node from GUI at the
 difference of <a href="#updateCurrentGui()"><code>updateCurrentGui()</code></a></div>
</section>
</li>
<li>
<section class="detail" id="updateCurrentNode()">
<h3>updateCurrentNode</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">updateCurrentNode</span>()</div>
<div class="block">This method should be called in order for GuiPackage to change the
 current node. This will save any changes made to the earlier node before
 choosing the new node.</div>
</section>
</li>
<li>
<section class="detail" id="getCurrentNode()">
<h3>getCurrentNode</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="tree/JMeterTreeNode.html" title="class in org.apache.jmeter.gui.tree">JMeterTreeNode</a></span>&nbsp;<span class="element-name">getCurrentNode</span>()</div>
</section>
</li>
<li>
<section class="detail" id="getCurrentElement()">
<h3>getCurrentElement</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">org.apache.jmeter.testelement.TestElement</span>&nbsp;<span class="element-name">getCurrentElement</span>()</div>
</section>
</li>
<li>
<section class="detail" id="setDirty(boolean)">
<h3>setDirty</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setDirty</span><wbr><span class="parameters">(boolean&nbsp;dirty)</span></div>
<div class="block">The dirty property is a flag that indicates whether there are parts of
 JMeter's test tree that the user has not saved since last modification.
 Various <a href="action/Command.html" title="interface in org.apache.jmeter.gui.action"><code>Command</code></a> actions set this property when components are
 modified/created/saved.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>dirty</code> - the new value of the dirty flag</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="isDirty()">
<h3>isDirty</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">isDirty</span>()</div>
<div class="block">Retrieves the state of the 'dirty' property, a flag that indicates if
 there are test tree components that have been modified since they were
 last saved.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>true if some tree components have been modified since they were
         last saved, false otherwise</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="addSubTree(org.apache.jorphan.collections.HashTree)">
<h3>addSubTree</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../../jorphan/collections/HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></span>&nbsp;<span class="element-name">addSubTree</span><wbr><span class="parameters">(<a href="../../jorphan/collections/HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a>&nbsp;subTree)</span>
                    throws <span class="exceptions"><a href="../exceptions/IllegalUserActionException.html" title="class in org.apache.jmeter.exceptions">IllegalUserActionException</a></span></div>
<div class="block">Add a subtree to the currently selected node.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>subTree</code> - the subtree to add.</dd>
<dt>Returns:</dt>
<dd>the resulting subtree starting with the currently selected node</dd>
<dt>Throws:</dt>
<dd><code><a href="../exceptions/IllegalUserActionException.html" title="class in org.apache.jmeter.exceptions">IllegalUserActionException</a></code> - if a subtree cannot be added to the currently selected node</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getCurrentSubTree()">
<h3>getCurrentSubTree</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../../jorphan/collections/HashTree.html" title="class in org.apache.jorphan.collections">HashTree</a></span>&nbsp;<span class="element-name">getCurrentSubTree</span>()</div>
<div class="block">Get the currently selected subtree.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the subtree of the currently selected node</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getTreeModel()">
<h3>getTreeModel</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="tree/JMeterTreeModel.html" title="class in org.apache.jmeter.gui.tree">JMeterTreeModel</a></span>&nbsp;<span class="element-name">getTreeModel</span>()</div>
<div class="block">Get the model for JMeter's test tree.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the JMeter tree model</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getReplacer()">
<h3>getReplacer</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="../engine/util/ValueReplacer.html" title="class in org.apache.jmeter.engine.util">ValueReplacer</a></span>&nbsp;<span class="element-name">getReplacer</span>()</div>
<div class="block">Get a ValueReplacer for the test tree.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>a ValueReplacer configured for the test tree</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setMainFrame(org.apache.jmeter.gui.MainFrame)">
<h3>setMainFrame</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setMainFrame</span><wbr><span class="parameters">(<a href="MainFrame.html" title="class in org.apache.jmeter.gui">MainFrame</a>&nbsp;newMainFrame)</span></div>
<div class="block">Set the main JMeter frame.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>newMainFrame</code> - the new JMeter main frame</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getMainFrame()">
<h3>getMainFrame</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="MainFrame.html" title="class in org.apache.jmeter.gui">MainFrame</a></span>&nbsp;<span class="element-name">getMainFrame</span>()</div>
<div class="block">Get the main JMeter frame.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the main JMeter frame</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getTreeListener()">
<h3>getTreeListener</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="tree/JMeterTreeListener.html" title="class in org.apache.jmeter.gui.tree">JMeterTreeListener</a></span>&nbsp;<span class="element-name">getTreeListener</span>()</div>
<div class="block">Get the listener for JMeter's test tree.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the JMeter test tree listener</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setMainToolbar(javax.swing.JToolBar)">
<h3>setMainToolbar</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setMainToolbar</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/swing/JToolBar.html" title="class or interface in javax.swing" class="external-link">JToolBar</a>&nbsp;newToolbar)</span></div>
<div class="block">Set the main JMeter toolbar.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>newToolbar</code> - the new JMeter main toolbar</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getMainToolbar()">
<h3>getMainToolbar</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/swing/JToolBar.html" title="class or interface in javax.swing" class="external-link">JToolBar</a></span>&nbsp;<span class="element-name">getMainToolbar</span>()</div>
<div class="block">Get the main JMeter toolbar.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the main JMeter toolbar</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="displayPopUp(java.awt.event.MouseEvent,javax.swing.JPopupMenu)">
<h3>displayPopUp</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">displayPopUp</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/java/awt/event/MouseEvent.html" title="class or interface in java.awt.event" class="external-link">MouseEvent</a>&nbsp;e,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/swing/JPopupMenu.html" title="class or interface in javax.swing" class="external-link">JPopupMenu</a>&nbsp;popup)</span></div>
<div class="block">Display the specified popup menu with the source component and location
 from the specified mouse event.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>e</code> - the mouse event causing this popup to be displayed</dd>
<dd><code>popup</code> - the popup menu to display</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="displayPopUp(java.awt.Component,java.awt.event.MouseEvent,javax.swing.JPopupMenu)">
<h3>displayPopUp</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">displayPopUp</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/java/awt/Component.html" title="class or interface in java.awt" class="external-link">Component</a>&nbsp;invoker,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/java/awt/event/MouseEvent.html" title="class or interface in java.awt.event" class="external-link">MouseEvent</a>&nbsp;e,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/swing/JPopupMenu.html" title="class or interface in javax.swing" class="external-link">JPopupMenu</a>&nbsp;popup)</span></div>
<div class="block">Display the specified popup menu at the location specified by a mouse
 event with the specified source component.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>invoker</code> - the source component</dd>
<dd><code>e</code> - the mouse event causing this popup to be displayed</dd>
<dd><code>popup</code> - the popup menu to display</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="localeChanged(org.apache.jmeter.util.LocaleChangeEvent)">
<h3>localeChanged</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">localeChanged</span><wbr><span class="parameters">(<a href="../util/LocaleChangeEvent.html" title="class in org.apache.jmeter.util">LocaleChangeEvent</a>&nbsp;event)</span></div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="../util/LocaleChangeListener.html#localeChanged(org.apache.jmeter.util.LocaleChangeEvent)">localeChanged</a></code>&nbsp;in interface&nbsp;<code><a href="../util/LocaleChangeListener.html" title="interface in org.apache.jmeter.util">LocaleChangeListener</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="invalidateCachedUi()">
<h3>invalidateCachedUi</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">invalidateCachedUi</span>()</div>
</section>
</li>
<li>
<section class="detail" id="updateUIForHiddenComponents()">
<h3>updateUIForHiddenComponents</h3>
<div class="member-signature"><span class="annotations">@API(since="5.3",
     status=EXPERIMENTAL)
</span><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">updateUIForHiddenComponents</span>()</div>
<div class="block">Tells hidden GUI components to update UIs when they are shown.
 <p>When Look and Feel (or zoom scaling) changes, only visible components are updated.
 The hidden ones are updated as they are shown.</p></div>
</section>
</li>
<li>
<section class="detail" id="setTestPlanFile(java.lang.String)">
<h3>setTestPlanFile</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setTestPlanFile</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;f)</span></div>
<div class="block">Sets the filepath of the current test plan. It's shown in the main frame
 title and used on saving.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>f</code> - The filepath of the current test plan</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getTestPlanFile()">
<h3>getTestPlanFile</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a></span>&nbsp;<span class="element-name">getTestPlanFile</span>()</div>
</section>
</li>
<li>
<section class="detail" id="clearTestPlan()">
<h3>clearTestPlan</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">clearTestPlan</span>()</div>
<div class="block">Clears the test plan and associated objects.
 Clears the test plan file name.</div>
</section>
</li>
<li>
<section class="detail" id="clearTestPlan(org.apache.jmeter.testelement.TestElement)">
<h3>clearTestPlan</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">clearTestPlan</span><wbr><span class="parameters">(org.apache.jmeter.testelement.TestElement&nbsp;element)</span></div>
<div class="block">Clears the test plan element and associated object</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>element</code> - to clear</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="showErrorMessage(java.lang.String,java.lang.String)">
<h3>showErrorMessage</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">showErrorMessage</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;message,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;title)</span></div>
</section>
</li>
<li>
<section class="detail" id="showInfoMessage(java.lang.String,java.lang.String)">
<h3>showInfoMessage</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">showInfoMessage</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;message,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;title)</span></div>
</section>
</li>
<li>
<section class="detail" id="showWarningMessage(java.lang.String,java.lang.String)">
<h3>showWarningMessage</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">showWarningMessage</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;message,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;title)</span></div>
</section>
</li>
<li>
<section class="detail" id="showMessage(java.lang.String,java.lang.String,int)">
<h3>showMessage</h3>
<div class="member-signature"><span class="modifiers">public static</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">showMessage</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;message,
 <a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/lang/String.html" title="class or interface in java.lang" class="external-link">String</a>&nbsp;title,
 int&nbsp;type)</span></div>
</section>
</li>
<li>
<section class="detail" id="unregister(org.apache.jmeter.gui.Stoppable)">
<h3>unregister</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">unregister</span><wbr><span class="parameters">(<a href="Stoppable.html" title="interface in org.apache.jmeter.gui">Stoppable</a>&nbsp;stoppableToUnregister)</span></div>
<div class="block">Unregister stoppable</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>stoppableToUnregister</code> - Stoppable to unregister</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="register(org.apache.jmeter.gui.Stoppable)">
<h3>register</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">register</span><wbr><span class="parameters">(<a href="Stoppable.html" title="interface in org.apache.jmeter.gui">Stoppable</a>&nbsp;stoppable)</span></div>
<div class="block">Register process to stop on reload</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>stoppable</code> - The <a href="Stoppable.html" title="interface in org.apache.jmeter.gui"><code>Stoppable</code></a> to be registered</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getStoppables()">
<h3>getStoppables</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/List.html" title="class or interface in java.util" class="external-link">List</a>&lt;<a href="Stoppable.html" title="interface in org.apache.jmeter.gui">Stoppable</a>&gt;</span>&nbsp;<span class="element-name">getStoppables</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>copy of list of <a href="Stoppable.html" title="interface in org.apache.jmeter.gui"><code>Stoppable</code></a>s</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setMenuItemLoggerPanel(javax.swing.JCheckBoxMenuItem)">
<h3>setMenuItemLoggerPanel</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setMenuItemLoggerPanel</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/swing/JCheckBoxMenuItem.html" title="class or interface in javax.swing" class="external-link">JCheckBoxMenuItem</a>&nbsp;menuItemLoggerPanel)</span></div>
<div class="block">Set the menu item LoggerPanel.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>menuItemLoggerPanel</code> - The menu item LoggerPanel</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getMenuItemLoggerPanel()">
<h3>getMenuItemLoggerPanel</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/swing/JCheckBoxMenuItem.html" title="class or interface in javax.swing" class="external-link">JCheckBoxMenuItem</a></span>&nbsp;<span class="element-name">getMenuItemLoggerPanel</span>()</div>
<div class="block">Get the menu item LoggerPanel.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the menu item LoggerPanel</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setMenuItemSaveBeforeRunPanel(javax.swing.JCheckBoxMenuItem)">
<h3>setMenuItemSaveBeforeRunPanel</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setMenuItemSaveBeforeRunPanel</span><wbr><span class="parameters">(<a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/swing/JCheckBoxMenuItem.html" title="class or interface in javax.swing" class="external-link">JCheckBoxMenuItem</a>&nbsp;menuItemSaveBeforeRunPanel)</span></div>
<div class="block">Set the menu item SaveBeforeRunPanel.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>menuItemSaveBeforeRunPanel</code> - The menu item SaveBeforeRunPanel</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getMenuItemSaveBeforeRunPanel()">
<h3>getMenuItemSaveBeforeRunPanel</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="https://docs.oracle.com/en/java/javase/11/docs/api/java.desktop/javax/swing/JCheckBoxMenuItem.html" title="class or interface in javax.swing" class="external-link">JCheckBoxMenuItem</a></span>&nbsp;<span class="element-name">getMenuItemSaveBeforeRunPanel</span>()</div>
<div class="block">Get the menu item SaveBeforeRunPanel.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the menu item SaveBeforeRunPanel</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setLoggerPanel(org.apache.jmeter.gui.LoggerPanel)">
<h3>setLoggerPanel</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setLoggerPanel</span><wbr><span class="parameters">(<a href="LoggerPanel.html" title="class in org.apache.jmeter.gui">LoggerPanel</a>&nbsp;loggerPanel)</span></div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>loggerPanel</code> - LoggerPanel</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getLoggerPanel()">
<h3>getLoggerPanel</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="LoggerPanel.html" title="class in org.apache.jmeter.gui">LoggerPanel</a></span>&nbsp;<span class="element-name">getLoggerPanel</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>the loggerPanel</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="undo()">
<h3>undo</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">undo</span>()</div>
<div class="block">Navigate back through undo history</div>
</section>
</li>
<li>
<section class="detail" id="redo()">
<h3>redo</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">redo</span>()</div>
<div class="block">Navigate forward through undo history</div>
</section>
</li>
<li>
<section class="detail" id="canRedo()">
<h3>canRedo</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">canRedo</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>true if history contains redo item</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="canUndo()">
<h3>canUndo</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">canUndo</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>true if history contains undo item</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="notifyChangeInHistory(org.apache.jmeter.gui.UndoHistory)">
<h3>notifyChangeInHistory</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">notifyChangeInHistory</span><wbr><span class="parameters">(<a href="UndoHistory.html" title="class in org.apache.jmeter.gui">UndoHistory</a>&nbsp;history)</span></div>
<div class="block">Called when history changes, it updates toolbar</div>
<dl class="notes">
<dt>Specified by:</dt>
<dd><code><a href="UndoHistory.HistoryListener.html#notifyChangeInHistory(org.apache.jmeter.gui.UndoHistory)">notifyChangeInHistory</a></code>&nbsp;in interface&nbsp;<code><a href="UndoHistory.HistoryListener.html" title="interface in org.apache.jmeter.gui">UndoHistory.HistoryListener</a></code></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getNamingPolicy()">
<h3>getNamingPolicy</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="action/TreeNodeNamingPolicy.html" title="interface in org.apache.jmeter.gui.action">TreeNodeNamingPolicy</a></span>&nbsp;<span class="element-name">getNamingPolicy</span>()</div>
<dl class="notes">
<dt>Returns:</dt>
<dd><a href="action/TreeNodeNamingPolicy.html" title="interface in org.apache.jmeter.gui.action"><code>TreeNodeNamingPolicy</code></a></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="getLogEventBus()">
<h3>getLogEventBus</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type"><a href="logging/GuiLogEventBus.html" title="class in org.apache.jmeter.gui.logging">GuiLogEventBus</a></span>&nbsp;<span class="element-name">getLogEventBus</span>()</div>
<div class="block">Return <a href="logging/GuiLogEventBus.html" title="class in org.apache.jmeter.gui.logging"><code>GuiLogEventBus</code></a>.</div>
<dl class="notes">
<dt>Returns:</dt>
<dd><a href="logging/GuiLogEventBus.html" title="class in org.apache.jmeter.gui.logging"><code>GuiLogEventBus</code></a></dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="beginUndoTransaction()">
<h3>beginUndoTransaction</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">beginUndoTransaction</span>()</div>
<div class="block">Begin a group of actions modeled as 1 undo</div>
</section>
</li>
<li>
<section class="detail" id="endUndoTransaction()">
<h3>endUndoTransaction</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">endUndoTransaction</span>()</div>
<div class="block">End a group of actions modeled as 1 undo</div>
</section>
</li>
<li>
<section class="detail" id="shouldSaveBeforeRunByPreference()">
<h3>shouldSaveBeforeRunByPreference</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">shouldSaveBeforeRunByPreference</span>()</div>
<div class="block">Should Save Before Run by Preference Only</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>boolean</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="setSaveBeforeRunByPreference(boolean)">
<h3>setSaveBeforeRunByPreference</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">setSaveBeforeRunByPreference</span><wbr><span class="parameters">(boolean&nbsp;saveBeforeRun)</span></div>
<div class="block">Should Save Before Run by Preference Only</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>saveBeforeRun</code> - boolean</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="shouldSaveBeforeRun()">
<h3>shouldSaveBeforeRun</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">boolean</span>&nbsp;<span class="element-name">shouldSaveBeforeRun</span>()</div>
<div class="block">Should Save Before Run
 Decide by Preference and if not exists by Property</div>
<dl class="notes">
<dt>Returns:</dt>
<dd>boolean Should Save Before Run</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="addTestPlanListener(org.apache.jmeter.gui.TestPlanListener)">
<h3>addTestPlanListener</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">addTestPlanListener</span><wbr><span class="parameters">(<a href="TestPlanListener.html" title="interface in org.apache.jmeter.gui">TestPlanListener</a>&nbsp;listener)</span></div>
<div class="block">Adds a test plan listener.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>listener</code> - to add</dd>
</dl>
</section>
</li>
<li>
<section class="detail" id="removeTestPlanListener(org.apache.jmeter.gui.TestPlanListener)">
<h3>removeTestPlanListener</h3>
<div class="member-signature"><span class="modifiers">public</span>&nbsp;<span class="return-type">void</span>&nbsp;<span class="element-name">removeTestPlanListener</span><wbr><span class="parameters">(<a href="TestPlanListener.html" title="interface in org.apache.jmeter.gui">TestPlanListener</a>&nbsp;listener)</span></div>
<div class="block">Removes a test plan listener.</div>
<dl class="notes">
<dt>Parameters:</dt>
<dd><code>listener</code> - to remove</dd>
</dl>
</section>
</li>
</ul>
</section>
</li>
</ul>
</section>
<!-- ========= END OF CLASS DATA ========= -->
</main>
<footer role="contentinfo">
<hr>
<p class="legal-copy"><small>Copyright &copy; 1998-2024 Apache Software Foundation. All Rights Reserved.</small></p>
</footer>
</div>
</div>
</body>
</html>
