Repository: Qiskit/qiskit

Issue:
Inconsistency in drawing classical control in text drawer when cregbundle=False
<!-- ⚠️ If you do not respect this template, your issue will be closed -->
<!-- ⚠️ Make sure to browse the opened and closed issues -->

### Information

- **Qiskit Terra version**: 0.18.0.dev0+b026000
- **Python version**: 3.7
- **Operating system**:

### What is the current behavior?

The classical control is currently drawn in text drawer as a box with control value inside it when cregbundle=False. This is inconsistent with the other drawers in which the same is drawn as bullets.

### Steps to reproduce the problem

We have the following for example:

``` python
from qiskit import *

q = QuantumRegister(2,'q')
c = ClassicalRegister(2,'c')
circ = QuantumCircuit(q,c)
circ.h(0).c_if(c,2)
```

Text drawer draws this circuit as 

![text_control_error](https://user-images.githubusercontent.com/51048173/115784066-43777680-a3db-11eb-87fa-478421615123.png)

while the latex drawer and mpl draws the same as

![latex_control_correct](https://user-images.githubusercontent.com/51048173/115784061-42464980-a3db-11eb-843a-ed092825569a.png)

![mpl_control_correct](https://user-images.githubusercontent.com/51048173/115787924-8c7df980-a3e0-11eb-890c-91a83d48077c.png)

### What is the expected behavior?

For consistency, the classical control in text drawers should be drawn using open and closed bullets.





Discussion:

Resolving patch:
diff --git a/qiskit/visualization/circuit_visualization.py b/qiskit/visualization/circuit_visualization.py
--- a/qiskit/visualization/circuit_visualization.py
+++ b/qiskit/visualization/circuit_visualization.py
@@ -321,6 +321,7 @@ def _text_circuit_drawer(
         qubits,
         clbits,
         nodes,
+        reverse_bits=reverse_bits,
         layout=layout,
         initial_state=initial_state,
         cregbundle=cregbundle,
diff --git a/qiskit/visualization/text.py b/qiskit/visualization/text.py
--- a/qiskit/visualization/text.py
+++ b/qiskit/visualization/text.py
@@ -451,6 +451,63 @@ def __init__(self, top_connect="", bot_connect="", conditional=False, label=None
         self.mid_bck = "─"
 
 
+class DirectOnClWire(DrawElement):
+    """
+    Element to the classical wire (without the box).
+    """
+
+    def __init__(self, label=""):
+        super().__init__(label)
+        self.top_format = " %s "
+        self.mid_format = "═%s═"
+        self.bot_format = " %s "
+        self._mid_padding = self.mid_bck = "═"
+        self.top_connector = {"│": "│"}
+        self.bot_connector = {"│": "│"}
+
+
+class ClBullet(DirectOnClWire):
+    """Draws a bullet on classical wire (usually with a connector). E.g. the top part of a CX gate.
+
+    ::
+
+        top:
+        mid: ═■═  ═══■═══
+        bot:  │      │
+    """
+
+    def __init__(self, top_connect="", bot_connect="", conditional=False, label=None, bottom=False):
+        super().__init__("■")
+        self.top_connect = top_connect
+        self.bot_connect = "║" if conditional else bot_connect
+        if label and bottom:
+            self.bot_connect = label
+        elif label:
+            self.top_connect = label
+        self.mid_bck = "═"
+
+
+class ClOpenBullet(DirectOnClWire):
+    """Draws an open bullet on classical wire (usually with a connector). E.g. the top part of a CX gate.
+
+    ::
+
+        top:
+        mid: ═o═  ═══o═══
+        bot:  │      │
+    """
+
+    def __init__(self, top_connect="", bot_connect="", conditional=False, label=None, bottom=False):
+        super().__init__("o")
+        self.top_connect = top_connect
+        self.bot_connect = "║" if conditional else bot_connect
+        if label and bottom:
+            self.bot_connect = label
+        elif label:
+            self.top_connect = label
+        self.mid_bck = "═"
+
+
 class EmptyWire(DrawElement):
     """This element is just the wire, with no operations."""
 
@@ -532,6 +589,7 @@ def __init__(
         qubits,
         clbits,
         nodes,
+        reverse_bits=False,
         plotbarriers=True,
         line_length=None,
         vertical_compression="high",
@@ -548,6 +606,7 @@ def __init__(
         self.qregs = qregs
         self.cregs = cregs
         self.nodes = nodes
+        self.reverse_bits = reverse_bits
         self.layout = layout
         self.initial_state = initial_state
         self.cregbundle = cregbundle
@@ -981,8 +1040,8 @@ def _node_to_gate(self, node, layer):
 
         if op.condition is not None:
             # conditional
-            cllabel = TextDrawing.label_for_conditional(node)
-            layer.set_cl_multibox(op.condition[0], cllabel, top_connect="╨")
+            op_cond = op.condition
+            layer.set_cl_multibox(op_cond[0], op_cond[1], top_connect="╨")
             conditional = True
 
         # add in a gate that operates over multiple qubits
@@ -1108,7 +1167,7 @@ def build_layers(self):
         layers = [InputWire.fillup_layer(wire_names)]
 
         for node_layer in self.nodes:
-            layer = Layer(self.qubits, self.clbits, self.cregbundle, self.cregs)
+            layer = Layer(self.qubits, self.clbits, self.reverse_bits, self.cregbundle, self.cregs)
 
             for node in node_layer:
                 layer, current_connections, connection_label = self._node_to_gate(node, layer)
@@ -1123,7 +1182,7 @@ def build_layers(self):
 class Layer:
     """A layer is the "column" of the circuit."""
 
-    def __init__(self, qubits, clbits, cregbundle=False, cregs=None):
+    def __init__(self, qubits, clbits, reverse_bits=False, cregbundle=False, cregs=None):
         cregs = [] if cregs is None else cregs
 
         self.qubits = qubits
@@ -1150,6 +1209,7 @@ def __init__(self, qubits, clbits, cregbundle=False, cregs=None):
         self.qubit_layer = [None] * len(qubits)
         self.connections = []
         self.clbit_layer = [None] * len(clbits)
+        self.reverse_bits = reverse_bits
         self.cregbundle = cregbundle
 
     @property
@@ -1308,19 +1368,39 @@ def _set_multibox(
             )
         return bit_index
 
-    def set_cl_multibox(self, creg, label, top_connect="┴"):
+    def set_cl_multibox(self, creg, val, top_connect="┴"):
         """Sets the multi clbit box.
 
         Args:
             creg (string): The affected classical register.
-            label (string): The label for the multi clbit box.
+            val (int): The value of the condition.
             top_connect (char): The char to connect the box on the top.
         """
         if self.cregbundle:
+            label = "= %s" % val
             self.set_clbit(creg[0], BoxOnClWire(label=label, top_connect=top_connect))
         else:
             clbit = [bit for bit in self.clbits if self._clbit_locations[bit]["register"] == creg]
-            self._set_multibox(label, clbits=clbit, top_connect=top_connect)
+            cond_bin = bin(val)[2:].zfill(len(clbit))
+            self.set_cond_bullets(cond_bin, clbits=clbit)
+
+    def set_cond_bullets(self, val, clbits):
+        """Sets bullets for classical conditioning when cregbundle=False.
+
+        Args:
+            val (int): The condition value.
+            clbits (list[Clbit]): The list of classical bits on
+                which the instruction is conditioned.
+        """
+        vlist = list(val) if self.reverse_bits else list(val[::-1])
+        for i, bit in enumerate(clbits):
+            bot_connect = " "
+            if bit == clbits[-1]:
+                bot_connect = "=%s" % str(int(val, 2))
+            if vlist[i] == "1":
+                self.set_clbit(bit, ClBullet(top_connect="║", bot_connect=bot_connect))
+            elif vlist[i] == "0":
+                self.set_clbit(bit, ClOpenBullet(top_connect="║", bot_connect=bot_connect))
 
     def set_qu_multibox(
         self,


Test patch:
diff --git a/test/python/visualization/test_circuit_text_drawer.py b/test/python/visualization/test_circuit_text_drawer.py
--- a/test/python/visualization/test_circuit_text_drawer.py
+++ b/test/python/visualization/test_circuit_text_drawer.py
@@ -1394,6 +1394,32 @@ def test_control_gate_with_base_label_4361(self):
     def test_control_gate_label_with_cond_1_low(self):
         """Control gate has a label and a conditional (compression=low)
         See https://github.com/Qiskit/qiskit-terra/issues/4361"""
+        expected = "\n".join(
+            [
+                "         my ch  ",
+                "q_0: |0>───■────",
+                "           │    ",
+                "        ┌──┴───┐",
+                "q_1: |0>┤ my h ├",
+                "        └──╥───┘",
+                "           ║    ",
+                " c_0: 0 ═══■════",
+                "           =1   ",
+            ]
+        )
+
+        qr = QuantumRegister(2, "q")
+        cr = ClassicalRegister(1, "c")
+        circ = QuantumCircuit(qr, cr)
+        hgate = HGate(label="my h")
+        controlh = hgate.control(label="my ch").c_if(cr, 1)
+        circ.append(controlh, [0, 1])
+
+        self.assertEqual(str(_text_circuit_drawer(circ, vertical_compression="low")), expected)
+
+    def test_control_gate_label_with_cond_1_low_cregbundle(self):
+        """Control gate has a label and a conditional (compression=low) with cregbundle
+        See https://github.com/Qiskit/qiskit-terra/issues/4361"""
         expected = "\n".join(
             [
                 "         my ch  ",
@@ -1403,7 +1429,7 @@ def test_control_gate_label_with_cond_1_low(self):
                 "q_1: |0>┤ my h ├",
                 "        └──╥───┘",
                 "        ┌──╨──┐ ",
-                " c_0: 0 ╡ = 1 ╞═",
+                " c: 0 1/╡ = 1 ╞═",
                 "        └─────┘ ",
             ]
         )
@@ -1415,11 +1441,37 @@ def test_control_gate_label_with_cond_1_low(self):
         controlh = hgate.control(label="my ch").c_if(cr, 1)
         circ.append(controlh, [0, 1])
 
-        self.assertEqual(str(_text_circuit_drawer(circ, vertical_compression="low")), expected)
+        self.assertEqual(
+            str(_text_circuit_drawer(circ, vertical_compression="low", cregbundle=True)), expected
+        )
 
     def test_control_gate_label_with_cond_1_med(self):
         """Control gate has a label and a conditional (compression=med)
         See https://github.com/Qiskit/qiskit-terra/issues/4361"""
+        expected = "\n".join(
+            [
+                "         my ch  ",
+                "q_0: |0>───■────",
+                "        ┌──┴───┐",
+                "q_1: |0>┤ my h ├",
+                "        └──╥───┘",
+                " c_0: 0 ═══■════",
+                "           =1   ",
+            ]
+        )
+
+        qr = QuantumRegister(2, "q")
+        cr = ClassicalRegister(1, "c")
+        circ = QuantumCircuit(qr, cr)
+        hgate = HGate(label="my h")
+        controlh = hgate.control(label="my ch").c_if(cr, 1)
+        circ.append(controlh, [0, 1])
+
+        self.assertEqual(str(_text_circuit_drawer(circ, vertical_compression="medium")), expected)
+
+    def test_control_gate_label_with_cond_1_med_cregbundle(self):
+        """Control gate has a label and a conditional (compression=med) with cregbundle
+        See https://github.com/Qiskit/qiskit-terra/issues/4361"""
         expected = "\n".join(
             [
                 "         my ch  ",
@@ -1428,7 +1480,7 @@ def test_control_gate_label_with_cond_1_med(self):
                 "q_1: |0>┤ my h ├",
                 "        └──╥───┘",
                 "        ┌──╨──┐ ",
-                " c_0: 0 ╡ = 1 ╞═",
+                " c: 0 1/╡ = 1 ╞═",
                 "        └─────┘ ",
             ]
         )
@@ -1440,11 +1492,38 @@ def test_control_gate_label_with_cond_1_med(self):
         controlh = hgate.control(label="my ch").c_if(cr, 1)
         circ.append(controlh, [0, 1])
 
-        self.assertEqual(str(_text_circuit_drawer(circ, vertical_compression="medium")), expected)
+        self.assertEqual(
+            str(_text_circuit_drawer(circ, vertical_compression="medium", cregbundle=True)),
+            expected,
+        )
 
     def test_control_gate_label_with_cond_1_high(self):
         """Control gate has a label and a conditional (compression=high)
         See https://github.com/Qiskit/qiskit-terra/issues/4361"""
+        expected = "\n".join(
+            [
+                "         my ch  ",
+                "q_0: |0>───■────",
+                "        ┌──┴───┐",
+                "q_1: |0>┤ my h ├",
+                "        └──╥───┘",
+                " c_0: 0 ═══■════",
+                "           =1   ",
+            ]
+        )
+
+        qr = QuantumRegister(2, "q")
+        cr = ClassicalRegister(1, "c")
+        circ = QuantumCircuit(qr, cr)
+        hgate = HGate(label="my h")
+        controlh = hgate.control(label="my ch").c_if(cr, 1)
+        circ.append(controlh, [0, 1])
+
+        self.assertEqual(str(_text_circuit_drawer(circ, vertical_compression="high")), expected)
+
+    def test_control_gate_label_with_cond_1_high_cregbundle(self):
+        """Control gate has a label and a conditional (compression=high) with cregbundle
+        See https://github.com/Qiskit/qiskit-terra/issues/4361"""
         expected = "\n".join(
             [
                 "         my ch  ",
@@ -1452,7 +1531,7 @@ def test_control_gate_label_with_cond_1_high(self):
                 "        ┌──┴───┐",
                 "q_1: |0>┤ my h ├",
                 "        ├──╨──┬┘",
-                " c_0: 0 ╡ = 1 ╞═",
+                " c: 0 1/╡ = 1 ╞═",
                 "        └─────┘ ",
             ]
         )
@@ -1464,11 +1543,38 @@ def test_control_gate_label_with_cond_1_high(self):
         controlh = hgate.control(label="my ch").c_if(cr, 1)
         circ.append(controlh, [0, 1])
 
-        self.assertEqual(str(_text_circuit_drawer(circ, vertical_compression="high")), expected)
+        self.assertEqual(
+            str(_text_circuit_drawer(circ, vertical_compression="high", cregbundle=True)), expected
+        )
 
     def test_control_gate_label_with_cond_2_med(self):
         """Control gate has a label and a conditional (on label, compression=med)
         See https://github.com/Qiskit/qiskit-terra/issues/4361"""
+        expected = "\n".join(
+            [
+                "        ┌──────┐",
+                "q_0: |0>┤ my h ├",
+                "        └──┬───┘",
+                "q_1: |0>───■────",
+                "         my ch  ",
+                "           ║    ",
+                " c_0: 0 ═══■════",
+                "           =1   ",
+            ]
+        )
+
+        qr = QuantumRegister(2, "q")
+        cr = ClassicalRegister(1, "c")
+        circ = QuantumCircuit(qr, cr)
+        hgate = HGate(label="my h")
+        controlh = hgate.control(label="my ch").c_if(cr, 1)
+        circ.append(controlh, [1, 0])
+
+        self.assertEqual(str(_text_circuit_drawer(circ, vertical_compression="medium")), expected)
+
+    def test_control_gate_label_with_cond_2_med_cregbundle(self):
+        """Control gate has a label and a conditional (on label, compression=med) with cregbundle
+        See https://github.com/Qiskit/qiskit-terra/issues/4361"""
         expected = "\n".join(
             [
                 "        ┌──────┐",
@@ -1477,7 +1583,7 @@ def test_control_gate_label_with_cond_2_med(self):
                 "q_1: |0>───■────",
                 "         my ch  ",
                 "        ┌──╨──┐ ",
-                " c_0: 0 ╡ = 1 ╞═",
+                " c: 0 1/╡ = 1 ╞═",
                 "        └─────┘ ",
             ]
         )
@@ -1489,11 +1595,40 @@ def test_control_gate_label_with_cond_2_med(self):
         controlh = hgate.control(label="my ch").c_if(cr, 1)
         circ.append(controlh, [1, 0])
 
-        self.assertEqual(str(_text_circuit_drawer(circ, vertical_compression="medium")), expected)
+        self.assertEqual(
+            str(_text_circuit_drawer(circ, vertical_compression="medium", cregbundle=True)),
+            expected,
+        )
 
     def test_control_gate_label_with_cond_2_low(self):
         """Control gate has a label and a conditional (on label, compression=low)
         See https://github.com/Qiskit/qiskit-terra/issues/4361"""
+        expected = "\n".join(
+            [
+                "        ┌──────┐",
+                "q_0: |0>┤ my h ├",
+                "        └──┬───┘",
+                "           │    ",
+                "q_1: |0>───■────",
+                "         my ch  ",
+                "           ║    ",
+                " c_0: 0 ═══■════",
+                "           =1   ",
+            ]
+        )
+
+        qr = QuantumRegister(2, "q")
+        cr = ClassicalRegister(1, "c")
+        circ = QuantumCircuit(qr, cr)
+        hgate = HGate(label="my h")
+        controlh = hgate.control(label="my ch").c_if(cr, 1)
+        circ.append(controlh, [1, 0])
+
+        self.assertEqual(str(_text_circuit_drawer(circ, vertical_compression="low")), expected)
+
+    def test_control_gate_label_with_cond_2_low_cregbundle(self):
+        """Control gate has a label and a conditional (on label, compression=low) with cregbundle
+        See https://github.com/Qiskit/qiskit-terra/issues/4361"""
         expected = "\n".join(
             [
                 "        ┌──────┐",
@@ -1503,7 +1638,7 @@ def test_control_gate_label_with_cond_2_low(self):
                 "q_1: |0>───■────",
                 "         my ch  ",
                 "        ┌──╨──┐ ",
-                " c_0: 0 ╡ = 1 ╞═",
+                " c: 0 1/╡ = 1 ╞═",
                 "        └─────┘ ",
             ]
         )
@@ -1515,7 +1650,9 @@ def test_control_gate_label_with_cond_2_low(self):
         controlh = hgate.control(label="my ch").c_if(cr, 1)
         circ.append(controlh, [1, 0])
 
-        self.assertEqual(str(_text_circuit_drawer(circ, vertical_compression="low")), expected)
+        self.assertEqual(
+            str(_text_circuit_drawer(circ, vertical_compression="low", cregbundle=True)), expected
+        )
 
 
 class TestTextDrawerParams(QiskitTestCase):
@@ -1591,6 +1728,34 @@ class TestTextDrawerVerticalCompressionLow(QiskitTestCase):
     """Test vertical_compression='low'"""
 
     def test_text_conditional_1(self):
+        """Conditional drawing with 1-bit-length regs."""
+        qasm_string = """
+        OPENQASM 2.0;
+        include "qelib1.inc";
+        qreg q[1];
+        creg c0[1];
+        creg c1[1];
+        if(c0==1) x q[0];
+        if(c1==1) x q[0];
+        """
+        expected = "\n".join(
+            [
+                "        ┌───┐┌───┐",
+                "q_0: |0>┤ X ├┤ X ├",
+                "        └─╥─┘└─╥─┘",
+                "          ║    ║  ",
+                "c0_0: 0 ══■════╬══",
+                "          =1   ║  ",
+                "               ║  ",
+                "c1_0: 0 ═══════■══",
+                "               =1 ",
+            ]
+        )
+
+        circuit = QuantumCircuit.from_qasm_str(qasm_string)
+        self.assertEqual(str(_text_circuit_drawer(circuit, vertical_compression="low")), expected)
+
+    def test_text_conditional_1_bundle(self):
         """Conditional drawing with 1-bit-length regs."""
         qasm_string = """
         OPENQASM 2.0;
@@ -1607,16 +1772,19 @@ def test_text_conditional_1(self):
                 "q_0: |0>─┤ X ├──┤ X ├─",
                 "         └─╥─┘  └─╥─┘ ",
                 "        ┌──╨──┐   ║   ",
-                "c0_0: 0 ╡ = 1 ╞═══╬═══",
+                "c0: 0 1/╡ = 1 ╞═══╬═══",
                 "        └─────┘   ║   ",
                 "               ┌──╨──┐",
-                "c1_0: 0 ═══════╡ = 1 ╞",
+                "c1: 0 1/═══════╡ = 1 ╞",
                 "               └─────┘",
             ]
         )
 
         circuit = QuantumCircuit.from_qasm_str(qasm_string)
-        self.assertEqual(str(_text_circuit_drawer(circuit, vertical_compression="low")), expected)
+        self.assertEqual(
+            str(_text_circuit_drawer(circuit, vertical_compression="low", cregbundle=True)),
+            expected,
+        )
 
     def test_text_conditional_reverse_bits_true(self):
         """Conditional drawing with 1-bit-length regs."""
@@ -1631,23 +1799,22 @@ def test_text_conditional_reverse_bits_true(self):
         circuit.x(0)
         circuit.measure(2, 1)
         circuit.x(2).c_if(cr, 2)
-        circuit.draw("text", cregbundle=False, reverse_bits=True)
 
         expected = "\n".join(
             [
-                "         ┌───┐     ┌─┐      ┌───┐ ",
-                "qr_2: |0>┤ H ├─────┤M├──────┤ X ├─",
-                "         ├───┤     └╥┘      └─╥─┘ ",
-                "qr_1: |0>┤ H ├──────╫─────────╫───",
-                "         ├───┤┌───┐ ║ ┌───┐   ║   ",
-                "qr_0: |0>┤ H ├┤ X ├─╫─┤ X ├───╫───",
-                "         └───┘└───┘ ║ └───┘   ║   ",
-                "cr2_0: 0 ═══════════╬═════════╬═══",
-                "                    ║      ┌──╨──┐",
-                " cr_1: 0 ═══════════╩══════╡     ╞",
-                "                           │ = 2 │",
-                " cr_0: 0 ══════════════════╡     ╞",
-                "                           └─────┘",
+                "         ┌───┐     ┌─┐     ┌───┐",
+                "qr_2: |0>┤ H ├─────┤M├─────┤ X ├",
+                "         ├───┤     └╥┘     └─╥─┘",
+                "qr_1: |0>┤ H ├──────╫────────╫──",
+                "         ├───┤┌───┐ ║ ┌───┐  ║  ",
+                "qr_0: |0>┤ H ├┤ X ├─╫─┤ X ├──╫──",
+                "         └───┘└───┘ ║ └───┘  ║  ",
+                "cr2_0: 0 ═══════════╬════════╬══",
+                "                    ║        ║  ",
+                " cr_1: 0 ═══════════╩════════■══",
+                "                             ║  ",
+                " cr_0: 0 ════════════════════o══",
+                "                             =2 ",
             ]
         )
 
@@ -1668,23 +1835,22 @@ def test_text_conditional_reverse_bits_false(self):
         circuit.x(0)
         circuit.measure(2, 1)
         circuit.x(2).c_if(cr, 2)
-        circuit.draw("text", cregbundle=False, reverse_bits=False)
-
-        expected = "\n".join(
-            [
-                "         ┌───┐┌───┐ ┌───┐ ",
-                "qr_0: |0>┤ H ├┤ X ├─┤ X ├─",
-                "         ├───┤└───┘ └───┘ ",
-                "qr_1: |0>┤ H ├────────────",
-                "         ├───┤ ┌─┐  ┌───┐ ",
-                "qr_2: |0>┤ H ├─┤M├──┤ X ├─",
-                "         └───┘ └╥┘ ┌┴─╨─┴┐",
-                " cr_0: 0 ═══════╬══╡     ╞",
-                "                ║  │ = 2 │",
-                " cr_1: 0 ═══════╩══╡     ╞",
-                "                   └─────┘",
-                "cr2_0: 0 ═════════════════",
-                "                          ",
+
+        expected = "\n".join(
+            [
+                "         ┌───┐┌───┐┌───┐",
+                "qr_0: |0>┤ H ├┤ X ├┤ X ├",
+                "         ├───┤└───┘└───┘",
+                "qr_1: |0>┤ H ├──────────",
+                "         ├───┤ ┌─┐ ┌───┐",
+                "qr_2: |0>┤ H ├─┤M├─┤ X ├",
+                "         └───┘ └╥┘ └─╥─┘",
+                " cr_0: 0 ═══════╬════o══",
+                "                ║    ║  ",
+                " cr_1: 0 ═══════╩════■══",
+                "                     =2 ",
+                "cr2_0: 0 ═══════════════",
+                "                        ",
             ]
         )
 
@@ -1727,6 +1893,34 @@ class TestTextDrawerVerticalCompressionMedium(QiskitTestCase):
     """Test vertical_compression='medium'"""
 
     def test_text_conditional_1(self):
+        """Medium vertical compression avoids box overlap."""
+        qasm_string = """
+        OPENQASM 2.0;
+        include "qelib1.inc";
+        qreg q[1];
+        creg c0[1];
+        creg c1[1];
+        if(c0==1) x q[0];
+        if(c1==1) x q[0];
+        """
+        expected = "\n".join(
+            [
+                "        ┌───┐┌───┐",
+                "q_0: |0>┤ X ├┤ X ├",
+                "        └─╥─┘└─╥─┘",
+                "c0_0: 0 ══■════╬══",
+                "          =1   ║  ",
+                "c1_0: 0 ═══════■══",
+                "               =1 ",
+            ]
+        )
+
+        circuit = QuantumCircuit.from_qasm_str(qasm_string)
+        self.assertEqual(
+            str(_text_circuit_drawer(circuit, vertical_compression="medium")), expected
+        )
+
+    def test_text_conditional_1_bundle(self):
         """Medium vertical compression avoids box overlap."""
         qasm_string = """
         OPENQASM 2.0;
@@ -1743,19 +1937,52 @@ def test_text_conditional_1(self):
                 "q_0: |0>─┤ X ├──┤ X ├─",
                 "         └─╥─┘  └─╥─┘ ",
                 "        ┌──╨──┐   ║   ",
-                "c0_0: 0 ╡ = 1 ╞═══╬═══",
+                "c0: 0 1/╡ = 1 ╞═══╬═══",
                 "        └─────┘┌──╨──┐",
-                "c1_0: 0 ═══════╡ = 1 ╞",
+                "c1: 0 1/═══════╡ = 1 ╞",
                 "               └─────┘",
             ]
         )
 
         circuit = QuantumCircuit.from_qasm_str(qasm_string)
         self.assertEqual(
-            str(_text_circuit_drawer(circuit, vertical_compression="medium")), expected
+            str(_text_circuit_drawer(circuit, vertical_compression="medium", cregbundle=True)),
+            expected,
         )
 
     def test_text_measure_with_spaces(self):
+        """Measure wire might have extra spaces
+        Found while reproducing
+        https://quantumcomputing.stackexchange.com/q/10194/1859"""
+        qasm_string = """
+            OPENQASM 2.0;
+            include "qelib1.inc";
+            qreg q[2];
+            creg c[3];
+            measure q[0] -> c[1];
+            if(c==1) x q[1];
+        """
+        expected = "\n".join(
+            [
+                "        ┌─┐     ",
+                "q_0: |0>┤M├─────",
+                "        └╥┘┌───┐",
+                "q_1: |0>─╫─┤ X ├",
+                "         ║ └─╥─┘",
+                " c_0: 0 ═╬═══■══",
+                "         ║   ║  ",
+                " c_1: 0 ═╩═══o══",
+                "             ║  ",
+                " c_2: 0 ═════o══",
+                "             =1 ",
+            ]
+        )
+        circuit = QuantumCircuit.from_qasm_str(qasm_string)
+        self.assertEqual(
+            str(_text_circuit_drawer(circuit, vertical_compression="medium")), expected
+        )
+
+    def test_text_measure_with_spaces_bundle(self):
         """Measure wire might have extra spaces
         Found while reproducing
         https://quantumcomputing.stackexchange.com/q/10194/1859"""
@@ -1771,23 +1998,19 @@ def test_text_measure_with_spaces(self):
             [
                 "        ┌─┐       ",
                 "q_0: |0>┤M├───────",
-                "        └╥┘       ",
-                "         ║  ┌───┐ ",
+                "        └╥┘ ┌───┐ ",
                 "q_1: |0>─╫──┤ X ├─",
                 "         ║  └─╥─┘ ",
                 "         ║ ┌──╨──┐",
-                " c_0: 0 ═╬═╡     ╞",
-                "         ║ │     │",
-                "         ║ │     │",
-                " c_1: 0 ═╩═╡ = 1 ╞",
-                "           │     │",
-                "           │     │",
-                " c_2: 0 ═══╡     ╞",
-                "           └─────┘",
+                " c: 0 3/═╩═╡ = 1 ╞",
+                "         1 └─────┘",
             ]
         )
         circuit = QuantumCircuit.from_qasm_str(qasm_string)
-        self.assertEqual(str(_text_circuit_drawer(circuit, vertical_compression="low")), expected)
+        self.assertEqual(
+            str(_text_circuit_drawer(circuit, vertical_compression="medium", cregbundle=True)),
+            expected,
+        )
 
 
 class TestTextConditional(QiskitTestCase):
@@ -1832,13 +2055,13 @@ def test_text_conditional_1(self):
         """
         expected = "\n".join(
             [
-                "         ┌───┐  ┌───┐ ",
-                "q_0: |0>─┤ X ├──┤ X ├─",
-                "        ┌┴─╨─┴┐ └─╥─┘ ",
-                "c0_0: 0 ╡ = 1 ╞═══╬═══",
-                "        └─────┘┌──╨──┐",
-                "c1_0: 0 ═══════╡ = 1 ╞",
-                "               └─────┘",
+                "        ┌───┐┌───┐",
+                "q_0: |0>┤ X ├┤ X ├",
+                "        └─╥─┘└─╥─┘",
+                "c0_0: 0 ══■════╬══",
+                "          =1   ║  ",
+                "c1_0: 0 ═══════■══",
+                "               =1 ",
             ]
         )
 
@@ -1881,23 +2104,48 @@ def test_text_conditional_2(self):
         if(c0==2) x q[0];
         if(c1==2) x q[0];
         """
+        expected = "\n".join(
+            [
+                "        ┌───┐┌───┐",
+                "q_0: |0>┤ X ├┤ X ├",
+                "        └─╥─┘└─╥─┘",
+                "c0_0: 0 ══o════╬══",
+                "          ║    ║  ",
+                "c0_1: 0 ══■════╬══",
+                "          =2   ║  ",
+                "c1_0: 0 ═══════o══",
+                "               ║  ",
+                "c1_1: 0 ═══════■══",
+                "               =2 ",
+            ]
+        )
+        circuit = QuantumCircuit.from_qasm_str(qasm_string)
+        self.assertEqual(str(_text_circuit_drawer(circuit)), expected)
+
+    def test_text_conditional_3_cregbundle(self):
+        """Conditional drawing with 3-bit-length regs with cregbundle."""
+        qasm_string = """
+        OPENQASM 2.0;
+        include "qelib1.inc";
+        qreg q[1];
+        creg c0[3];
+        creg c1[3];
+        if(c0==3) x q[0];
+        if(c1==3) x q[0];
+        """
         expected = "\n".join(
             [
                 "         ┌───┐  ┌───┐ ",
                 "q_0: |0>─┤ X ├──┤ X ├─",
                 "        ┌┴─╨─┴┐ └─╥─┘ ",
-                "c0_0: 0 ╡     ╞═══╬═══",
-                "        │ = 2 │   ║   ",
-                "c0_1: 0 ╡     ╞═══╬═══",
+                "c0: 0 3/╡ = 3 ╞═══╬═══",
                 "        └─────┘┌──╨──┐",
-                "c1_0: 0 ═══════╡     ╞",
-                "               │ = 2 │",
-                "c1_1: 0 ═══════╡     ╞",
+                "c1: 0 3/═══════╡ = 3 ╞",
                 "               └─────┘",
             ]
         )
         circuit = QuantumCircuit.from_qasm_str(qasm_string)
-        self.assertEqual(str(_text_circuit_drawer(circuit)), expected)
+        self.assertEqual(str(_text_circuit_drawer(circuit, cregbundle=True)), expected)
 
     def test_text_conditional_3(self):
         """Conditional drawing with 3-bit-length regs."""
@@ -1912,21 +2160,21 @@ def test_text_conditional_3(self):
         """
         expected = "\n".join(
             [
-                "         ┌───┐  ┌───┐ ",
-                "q_0: |0>─┤ X ├──┤ X ├─",
-                "        ┌┴─╨─┴┐ └─╥─┘ ",
-                "c0_0: 0 ╡     ╞═══╬═══",
-                "        │     │   ║   ",
-                "c0_1: 0 ╡ = 3 ╞═══╬═══",
-                "        │     │   ║   ",
-                "c0_2: 0 ╡     ╞═══╬═══",
-                "        └─────┘┌──╨──┐",
-                "c1_0: 0 ═══════╡     ╞",
-                "               │     │",
-                "c1_1: 0 ═══════╡ = 3 ╞",
-                "               │     │",
-                "c1_2: 0 ═══════╡     ╞",
-                "               └─────┘",
+                "        ┌───┐┌───┐",
+                "q_0: |0>┤ X ├┤ X ├",
+                "        └─╥─┘└─╥─┘",
+                "c0_0: 0 ══■════╬══",
+                "          ║    ║  ",
+                "c0_1: 0 ══■════╬══",
+                "          ║    ║  ",
+                "c0_2: 0 ══o════╬══",
+                "          =3   ║  ",
+                "c1_0: 0 ═══════■══",
+                "               ║  ",
+                "c1_1: 0 ═══════■══",
+                "               ║  ",
+                "c1_2: 0 ═══════o══",
+                "               =3 ",
             ]
         )
         circuit = QuantumCircuit.from_qasm_str(qasm_string)
@@ -1945,25 +2193,25 @@ def test_text_conditional_4(self):
         """
         expected = "\n".join(
             [
-                "         ┌───┐  ┌───┐ ",
-                "q_0: |0>─┤ X ├──┤ X ├─",
-                "        ┌┴─╨─┴┐ └─╥─┘ ",
-                "c0_0: 0 ╡     ╞═══╬═══",
-                "        │     │   ║   ",
-                "c0_1: 0 ╡     ╞═══╬═══",
-                "        │ = 4 │   ║   ",
-                "c0_2: 0 ╡     ╞═══╬═══",
-                "        │     │   ║   ",
-                "c0_3: 0 ╡     ╞═══╬═══",
-                "        └─────┘┌──╨──┐",
-                "c1_0: 0 ═══════╡     ╞",
-                "               │     │",
-                "c1_1: 0 ═══════╡     ╞",
-                "               │ = 4 │",
-                "c1_2: 0 ═══════╡     ╞",
-                "               │     │",
-                "c1_3: 0 ═══════╡     ╞",
-                "               └─────┘",
+                "        ┌───┐┌───┐",
+                "q_0: |0>┤ X ├┤ X ├",
+                "        └─╥─┘└─╥─┘",
+                "c0_0: 0 ══o════╬══",
+                "          ║    ║  ",
+                "c0_1: 0 ══o════╬══",
+                "          ║    ║  ",
+                "c0_2: 0 ══■════╬══",
+                "          ║    ║  ",
+                "c0_3: 0 ══o════╬══",
+                "          =4   ║  ",
+                "c1_0: 0 ═══════o══",
+                "               ║  ",
+                "c1_1: 0 ═══════o══",
+                "               ║  ",
+                "c1_2: 0 ═══════■══",
+                "               ║  ",
+                "c1_3: 0 ═══════o══",
+                "               =4 ",
             ]
         )
         circuit = QuantumCircuit.from_qasm_str(qasm_string)
@@ -1982,35 +2230,35 @@ def test_text_conditional_5(self):
         """
         expected = "\n".join(
             [
-                "         ┌───┐  ┌───┐ ",
-                "q_0: |0>─┤ X ├──┤ X ├─",
-                "        ┌┴─╨─┴┐ └─╥─┘ ",
-                "c0_0: 0 ╡     ╞═══╬═══",
-                "        │     │   ║   ",
-                "c0_1: 0 ╡     ╞═══╬═══",
-                "        │     │   ║   ",
-                "c0_2: 0 ╡ = 5 ╞═══╬═══",
-                "        │     │   ║   ",
-                "c0_3: 0 ╡     ╞═══╬═══",
-                "        │     │   ║   ",
-                "c0_4: 0 ╡     ╞═══╬═══",
-                "        └─────┘┌──╨──┐",
-                "c1_0: 0 ═══════╡     ╞",
-                "               │     │",
-                "c1_1: 0 ═══════╡     ╞",
-                "               │     │",
-                "c1_2: 0 ═══════╡ = 5 ╞",
-                "               │     │",
-                "c1_3: 0 ═══════╡     ╞",
-                "               │     │",
-                "c1_4: 0 ═══════╡     ╞",
-                "               └─────┘",
+                "        ┌───┐┌───┐",
+                "q_0: |0>┤ X ├┤ X ├",
+                "        └─╥─┘└─╥─┘",
+                "c0_0: 0 ══■════╬══",
+                "          ║    ║  ",
+                "c0_1: 0 ══o════╬══",
+                "          ║    ║  ",
+                "c0_2: 0 ══■════╬══",
+                "          ║    ║  ",
+                "c0_3: 0 ══o════╬══",
+                "          ║    ║  ",
+                "c0_4: 0 ══o════╬══",
+                "          =5   ║  ",
+                "c1_0: 0 ═══════■══",
+                "               ║  ",
+                "c1_1: 0 ═══════o══",
+                "               ║  ",
+                "c1_2: 0 ═══════■══",
+                "               ║  ",
+                "c1_3: 0 ═══════o══",
+                "               ║  ",
+                "c1_4: 0 ═══════o══",
+                "               =5 ",
             ]
         )
         circuit = QuantumCircuit.from_qasm_str(qasm_string)
         self.assertEqual(str(_text_circuit_drawer(circuit)), expected)
 
-    def test_text_conditional_cz_no_space(self):
+    def test_text_conditional_cz_no_space_cregbundle(self):
         """Conditional CZ without space"""
         qr = QuantumRegister(2, "qr")
         cr = ClassicalRegister(1, "cr")
@@ -2024,14 +2272,35 @@ def test_text_conditional_cz_no_space(self):
                 "            │   ",
                 "qr_1: |0>───■───",
                 "         ┌──╨──┐",
-                " cr_0: 0 ╡ = 1 ╞",
+                " cr: 0 1/╡ = 1 ╞",
                 "         └─────┘",
             ]
         )
 
+        self.assertEqual(str(_text_circuit_drawer(circuit, cregbundle=True)), expected)
+
+    def test_text_conditional_cz_no_space(self):
+        """Conditional CZ without space"""
+        qr = QuantumRegister(2, "qr")
+        cr = ClassicalRegister(1, "cr")
+        circuit = QuantumCircuit(qr, cr)
+        circuit.cz(qr[0], qr[1]).c_if(cr, 1)
+
+        expected = "\n".join(
+            [
+                "             ",
+                "qr_0: |0>─■──",
+                "          │  ",
+                "qr_1: |0>─■──",
+                "          ║  ",
+                " cr_0: 0 ═■══",
+                "          =1 ",
+            ]
+        )
+
         self.assertEqual(str(_text_circuit_drawer(circuit)), expected)
 
-    def test_text_conditional_cz(self):
+    def test_text_conditional_cz_cregbundle(self):
         """Conditional CZ with a wire in the middle"""
         qr = QuantumRegister(3, "qr")
         cr = ClassicalRegister(1, "cr")
@@ -2047,14 +2316,37 @@ def test_text_conditional_cz(self):
                 "            ║   ",
                 "qr_2: |0>───╫───",
                 "         ┌──╨──┐",
-                " cr_0: 0 ╡ = 1 ╞",
+                " cr: 0 1/╡ = 1 ╞",
                 "         └─────┘",
             ]
         )
 
+        self.assertEqual(str(_text_circuit_drawer(circuit, cregbundle=True)), expected)
+
+    def test_text_conditional_cz(self):
+        """Conditional CZ with a wire in the middle"""
+        qr = QuantumRegister(3, "qr")
+        cr = ClassicalRegister(1, "cr")
+        circuit = QuantumCircuit(qr, cr)
+        circuit.cz(qr[0], qr[1]).c_if(cr, 1)
+
+        expected = "\n".join(
+            [
+                "             ",
+                "qr_0: |0>─■──",
+                "          │  ",
+                "qr_1: |0>─■──",
+                "          ║  ",
+                "qr_2: |0>─╫──",
+                "          ║  ",
+                " cr_0: 0 ═■══",
+                "          =1 ",
+            ]
+        )
+
         self.assertEqual(str(_text_circuit_drawer(circuit)), expected)
 
-    def test_text_conditional_cx_ct(self):
+    def test_text_conditional_cx_ct_cregbundle(self):
         """Conditional CX (control-target) with a wire in the middle"""
         qr = QuantumRegister(3, "qr")
         cr = ClassicalRegister(1, "cr")
@@ -2070,15 +2362,38 @@ def test_text_conditional_cx_ct(self):
                 "          └─╥─┘ ",
                 "qr_2: |0>───╫───",
                 "         ┌──╨──┐",
-                " cr_0: 0 ╡ = 1 ╞",
+                " cr: 0 1/╡ = 1 ╞",
                 "         └─────┘",
             ]
         )
 
+        self.assertEqual(str(_text_circuit_drawer(circuit, cregbundle=True)), expected)
+
+    def test_text_conditional_cx_ct(self):
+        """Conditional CX (control-target) with a wire in the middle"""
+        qr = QuantumRegister(3, "qr")
+        cr = ClassicalRegister(1, "cr")
+        circuit = QuantumCircuit(qr, cr)
+        circuit.cx(qr[0], qr[1]).c_if(cr, 1)
+
+        expected = "\n".join(
+            [
+                "              ",
+                "qr_0: |0>──■──",
+                "         ┌─┴─┐",
+                "qr_1: |0>┤ X ├",
+                "         └─╥─┘",
+                "qr_2: |0>──╫──",
+                "           ║  ",
+                " cr_0: 0 ══■══",
+                "           =1 ",
+            ]
+        )
+
         self.assertEqual(str(_text_circuit_drawer(circuit)), expected)
 
-    def test_text_conditional_cx_tc(self):
-        """Conditional CX (target-control) with a wire in the middle"""
+    def test_text_conditional_cx_tc_cregbundle(self):
+        """Conditional CX (target-control) with a wire in the middle with cregbundle."""
         qr = QuantumRegister(3, "qr")
         cr = ClassicalRegister(1, "cr")
         circuit = QuantumCircuit(qr, cr)
@@ -2093,13 +2408,59 @@ def test_text_conditional_cx_tc(self):
                 "            ║   ",
                 "qr_2: |0>───╫───",
                 "         ┌──╨──┐",
-                " cr_0: 0 ╡ = 1 ╞",
+                " cr: 0 1/╡ = 1 ╞",
                 "         └─────┘",
             ]
         )
 
+        self.assertEqual(str(_text_circuit_drawer(circuit, cregbundle=True)), expected)
+
+    def test_text_conditional_cx_tc(self):
+        """Conditional CX (target-control) with a wire in the middle"""
+        qr = QuantumRegister(3, "qr")
+        cr = ClassicalRegister(1, "cr")
+        circuit = QuantumCircuit(qr, cr)
+        circuit.cx(qr[1], qr[0]).c_if(cr, 1)
+
+        expected = "\n".join(
+            [
+                "         ┌───┐",
+                "qr_0: |0>┤ X ├",
+                "         └─┬─┘",
+                "qr_1: |0>──■──",
+                "           ║  ",
+                "qr_2: |0>──╫──",
+                "           ║  ",
+                " cr_0: 0 ══■══",
+                "           =1 ",
+            ]
+        )
+
         self.assertEqual(str(_text_circuit_drawer(circuit)), expected)
 
+    def test_text_conditional_cu3_ct_cregbundle(self):
+        """Conditional Cu3 (control-target) with a wire in the middle with cregbundle"""
+        qr = QuantumRegister(3, "qr")
+        cr = ClassicalRegister(1, "cr")
+        circuit = QuantumCircuit(qr, cr)
+        circuit.append(CU3Gate(pi / 2, pi / 2, pi / 2), [qr[0], qr[1]]).c_if(cr, 1)
+
+        expected = "\n".join(
+            [
+                "                            ",
+                "qr_0: |0>─────────■─────────",
+                "         ┌────────┴────────┐",
+                "qr_1: |0>┤ U3(π/2,π/2,π/2) ├",
+                "         └────────╥────────┘",
+                "qr_2: |0>─────────╫─────────",
+                "               ┌──╨──┐      ",
+                " cr: 0 1/══════╡ = 1 ╞══════",
+                "               └─────┘      ",
+            ]
+        )
+
+        self.assertEqual(str(_text_circuit_drawer(circuit, cregbundle=True)), expected)
+
     def test_text_conditional_cu3_ct(self):
         """Conditional Cu3 (control-target) with a wire in the middle"""
         qr = QuantumRegister(3, "qr")
@@ -2115,13 +2476,36 @@ def test_text_conditional_cu3_ct(self):
                 "qr_1: |0>┤ U3(π/2,π/2,π/2) ├",
                 "         └────────╥────────┘",
                 "qr_2: |0>─────────╫─────────",
+                "                  ║         ",
+                " cr_0: 0 ═════════■═════════",
+                "                  =1        ",
+            ]
+        )
+
+        self.assertEqual(str(_text_circuit_drawer(circuit)), expected)
+
+    def test_text_conditional_cu3_tc_cregbundle(self):
+        """Conditional Cu3 (target-control) with a wire in the middle with cregbundle"""
+        qr = QuantumRegister(3, "qr")
+        cr = ClassicalRegister(1, "cr")
+        circuit = QuantumCircuit(qr, cr)
+        circuit.append(CU3Gate(pi / 2, pi / 2, pi / 2), [qr[1], qr[0]]).c_if(cr, 1)
+
+        expected = "\n".join(
+            [
+                "         ┌─────────────────┐",
+                "qr_0: |0>┤ U3(π/2,π/2,π/2) ├",
+                "         └────────┬────────┘",
+                "qr_1: |0>─────────■─────────",
+                "                  ║         ",
+                "qr_2: |0>─────────╫─────────",
                 "               ┌──╨──┐      ",
-                " cr_0: 0 ══════╡ = 1 ╞══════",
+                " cr: 0 1/══════╡ = 1 ╞══════",
                 "               └─────┘      ",
             ]
         )
 
-        self.assertEqual(str(_text_circuit_drawer(circuit)), expected)
+        self.assertEqual(str(_text_circuit_drawer(circuit, cregbundle=True)), expected)
 
     def test_text_conditional_cu3_tc(self):
         """Conditional Cu3 (target-control) with a wire in the middle"""
@@ -2138,16 +2522,16 @@ def test_text_conditional_cu3_tc(self):
                 "qr_1: |0>─────────■─────────",
                 "                  ║         ",
                 "qr_2: |0>─────────╫─────────",
-                "               ┌──╨──┐      ",
-                " cr_0: 0 ══════╡ = 1 ╞══════",
-                "               └─────┘      ",
+                "                  ║         ",
+                " cr_0: 0 ═════════■═════════",
+                "                  =1        ",
             ]
         )
 
         self.assertEqual(str(_text_circuit_drawer(circuit)), expected)
 
-    def test_text_conditional_ccx(self):
-        """Conditional CCX with a wire in the middle"""
+    def test_text_conditional_ccx_cregbundle(self):
+        """Conditional CCX with a wire in the middle with cregbundle"""
         qr = QuantumRegister(4, "qr")
         cr = ClassicalRegister(1, "cr")
         circuit = QuantumCircuit(qr, cr)
@@ -2164,15 +2548,40 @@ def test_text_conditional_ccx(self):
                 "          └─╥─┘ ",
                 "qr_3: |0>───╫───",
                 "         ┌──╨──┐",
-                " cr_0: 0 ╡ = 1 ╞",
+                " cr: 0 1/╡ = 1 ╞",
                 "         └─────┘",
             ]
         )
 
+        self.assertEqual(str(_text_circuit_drawer(circuit, cregbundle=True)), expected)
+
+    def test_text_conditional_ccx(self):
+        """Conditional CCX with a wire in the middle"""
+        qr = QuantumRegister(4, "qr")
+        cr = ClassicalRegister(1, "cr")
+        circuit = QuantumCircuit(qr, cr)
+        circuit.ccx(qr[0], qr[1], qr[2]).c_if(cr, 1)
+
+        expected = "\n".join(
+            [
+                "              ",
+                "qr_0: |0>──■──",
+                "           │  ",
+                "qr_1: |0>──■──",
+                "         ┌─┴─┐",
+                "qr_2: |0>┤ X ├",
+                "         └─╥─┘",
+                "qr_3: |0>──╫──",
+                "           ║  ",
+                " cr_0: 0 ══■══",
+                "           =1 ",
+            ]
+        )
+
         self.assertEqual(str(_text_circuit_drawer(circuit)), expected)
 
-    def test_text_conditional_ccx_no_space(self):
-        """Conditional CCX without space"""
+    def test_text_conditional_ccx_no_space_cregbundle(self):
+        """Conditional CCX without space with cregbundle"""
         qr = QuantumRegister(3, "qr")
         cr = ClassicalRegister(1, "cr")
         circuit = QuantumCircuit(qr, cr)
@@ -2187,15 +2596,38 @@ def test_text_conditional_ccx_no_space(self):
                 "          ┌─┴─┐ ",
                 "qr_2: |0>─┤ X ├─",
                 "         ┌┴─╨─┴┐",
-                " cr_0: 0 ╡ = 1 ╞",
+                " cr: 0 1/╡ = 1 ╞",
                 "         └─────┘",
             ]
         )
 
+        self.assertEqual(str(_text_circuit_drawer(circuit, cregbundle=True)), expected)
+
+    def test_text_conditional_ccx_no_space(self):
+        """Conditional CCX without space"""
+        qr = QuantumRegister(3, "qr")
+        cr = ClassicalRegister(1, "cr")
+        circuit = QuantumCircuit(qr, cr)
+        circuit.ccx(qr[0], qr[1], qr[2]).c_if(cr, 1)
+
+        expected = "\n".join(
+            [
+                "              ",
+                "qr_0: |0>──■──",
+                "           │  ",
+                "qr_1: |0>──■──",
+                "         ┌─┴─┐",
+                "qr_2: |0>┤ X ├",
+                "         └─╥─┘",
+                " cr_0: 0 ══■══",
+                "           =1 ",
+            ]
+        )
+
         self.assertEqual(str(_text_circuit_drawer(circuit)), expected)
 
-    def test_text_conditional_h(self):
-        """Conditional H with a wire in the middle"""
+    def test_text_conditional_h_cregbundle(self):
+        """Conditional H with a wire in the middle with cregbundle"""
         qr = QuantumRegister(2, "qr")
         cr = ClassicalRegister(1, "cr")
         circuit = QuantumCircuit(qr, cr)
@@ -2208,15 +2640,36 @@ def test_text_conditional_h(self):
                 "          └─╥─┘ ",
                 "qr_1: |0>───╫───",
                 "         ┌──╨──┐",
-                " cr_0: 0 ╡ = 1 ╞",
+                " cr: 0 1/╡ = 1 ╞",
                 "         └─────┘",
             ]
         )
 
+        self.assertEqual(str(_text_circuit_drawer(circuit, cregbundle=True)), expected)
+
+    def test_text_conditional_h(self):
+        """Conditional H with a wire in the middle"""
+        qr = QuantumRegister(2, "qr")
+        cr = ClassicalRegister(1, "cr")
+        circuit = QuantumCircuit(qr, cr)
+        circuit.h(qr[0]).c_if(cr, 1)
+
+        expected = "\n".join(
+            [
+                "         ┌───┐",
+                "qr_0: |0>┤ H ├",
+                "         └─╥─┘",
+                "qr_1: |0>──╫──",
+                "           ║  ",
+                " cr_0: 0 ══■══",
+                "           =1 ",
+            ]
+        )
+
         self.assertEqual(str(_text_circuit_drawer(circuit)), expected)
 
-    def test_text_conditional_swap(self):
-        """Conditional SWAP"""
+    def test_text_conditional_swap_cregbundle(self):
+        """Conditional SWAP with cregbundle"""
         qr = QuantumRegister(3, "qr")
         cr = ClassicalRegister(1, "cr")
         circuit = QuantumCircuit(qr, cr)
@@ -2231,15 +2684,38 @@ def test_text_conditional_swap(self):
                 "            ║   ",
                 "qr_2: |0>───╫───",
                 "         ┌──╨──┐",
-                " cr_0: 0 ╡ = 1 ╞",
+                " cr: 0 1/╡ = 1 ╞",
                 "         └─────┘",
             ]
         )
 
+        self.assertEqual(str(_text_circuit_drawer(circuit, cregbundle=True)), expected)
+
+    def test_text_conditional_swap(self):
+        """Conditional SWAP"""
+        qr = QuantumRegister(3, "qr")
+        cr = ClassicalRegister(1, "cr")
+        circuit = QuantumCircuit(qr, cr)
+        circuit.swap(qr[0], qr[1]).c_if(cr, 1)
+
+        expected = "\n".join(
+            [
+                "             ",
+                "qr_0: |0>─X──",
+                "          │  ",
+                "qr_1: |0>─X──",
+                "          ║  ",
+                "qr_2: |0>─╫──",
+                "          ║  ",
+                " cr_0: 0 ═■══",
+                "          =1 ",
+            ]
+        )
+
         self.assertEqual(str(_text_circuit_drawer(circuit)), expected)
 
-    def test_text_conditional_cswap(self):
-        """Conditional CSwap"""
+    def test_text_conditional_cswap_cregbundle(self):
+        """Conditional CSwap with cregbundle"""
         qr = QuantumRegister(4, "qr")
         cr = ClassicalRegister(1, "cr")
         circuit = QuantumCircuit(qr, cr)
@@ -2256,15 +2732,40 @@ def test_text_conditional_cswap(self):
                 "            ║   ",
                 "qr_3: |0>───╫───",
                 "         ┌──╨──┐",
-                " cr_0: 0 ╡ = 1 ╞",
+                " cr: 0 1/╡ = 1 ╞",
                 "         └─────┘",
             ]
         )
 
+        self.assertEqual(str(_text_circuit_drawer(circuit, cregbundle=True)), expected)
+
+    def test_text_conditional_cswap(self):
+        """Conditional CSwap"""
+        qr = QuantumRegister(4, "qr")
+        cr = ClassicalRegister(1, "cr")
+        circuit = QuantumCircuit(qr, cr)
+        circuit.cswap(qr[0], qr[1], qr[2]).c_if(cr, 1)
+
+        expected = "\n".join(
+            [
+                "             ",
+                "qr_0: |0>─■──",
+                "          │  ",
+                "qr_1: |0>─X──",
+                "          │  ",
+                "qr_2: |0>─X──",
+                "          ║  ",
+                "qr_3: |0>─╫──",
+                "          ║  ",
+                " cr_0: 0 ═■══",
+                "          =1 ",
+            ]
+        )
+
         self.assertEqual(str(_text_circuit_drawer(circuit)), expected)
 
-    def test_conditional_reset(self):
-        """Reset drawing."""
+    def test_conditional_reset_cregbundle(self):
+        """Reset drawing with cregbundle."""
         qr = QuantumRegister(2, "qr")
         cr = ClassicalRegister(1, "cr")
 
@@ -2278,13 +2779,61 @@ def test_conditional_reset(self):
                 "            ║   ",
                 "qr_1: |0>───╫───",
                 "         ┌──╨──┐",
-                " cr_0: 0 ╡ = 1 ╞",
+                " cr: 0 1/╡ = 1 ╞",
                 "         └─────┘",
             ]
         )
 
+        self.assertEqual(str(_text_circuit_drawer(circuit, cregbundle=True)), expected)
+
+    def test_conditional_reset(self):
+        """Reset drawing."""
+        qr = QuantumRegister(2, "qr")
+        cr = ClassicalRegister(1, "cr")
+
+        circuit = QuantumCircuit(qr, cr)
+        circuit.reset(qr[0]).c_if(cr, 1)
+
+        expected = "\n".join(
+            [
+                "              ",
+                "qr_0: |0>─|0>─",
+                "           ║  ",
+                "qr_1: |0>──╫──",
+                "           ║  ",
+                " cr_0: 0 ══■══",
+                "           =1 ",
+            ]
+        )
+
         self.assertEqual(str(_text_circuit_drawer(circuit)), expected)
 
+    @unittest.skip("Add back when Multiplexer is implemented in terms of UCGate")
+    def test_conditional_multiplexer_cregbundle(self):
+        """Test Multiplexer with cregbundle."""
+        cx_multiplexer = Gate("multiplexer", 2, [numpy.eye(2), numpy.array([[0, 1], [1, 0]])])
+        qr = QuantumRegister(3, name="qr")
+        cr = ClassicalRegister(1, "cr")
+        qc = QuantumCircuit(qr, cr)
+        qc.append(cx_multiplexer.c_if(cr, 1), [qr[0], qr[1]])
+
+        expected = "\n".join(
+            [
+                "         ┌──────────────┐",
+                "qr_0: |0>┤0             ├",
+                "         │  multiplexer │",
+                "qr_1: |0>┤1             ├",
+                "         └──────╥───────┘",
+                "qr_2: |0>───────╫────────",
+                "             ┌──╨──┐     ",
+                " cr: 0 1/════╡ = 1 ╞═════",
+                "             └─────┘     ",
+            ]
+        )
+
+        self.assertEqual(str(_text_circuit_drawer(qc, cregbundle=True)), expected)
+
+    @unittest.skip("Add back when Multiplexer is implemented in terms of UCGate")
     def test_conditional_multiplexer(self):
         """Test Multiplexer."""
         cx_multiplexer = UCGate([numpy.eye(2), numpy.array([[0, 1], [1, 0]])])
@@ -2301,6 +2850,9 @@ def test_conditional_multiplexer(self):
                 "qr_1: |0>┤1             ├",
                 "         └──────╥───────┘",
                 "qr_2: |0>───────╫────────",
+                "                ║        ",
+                " cr_0: 0 ═══════■════════",
+                "                =1       ",
                 "             ┌──╨──┐     ",
                 " cr_0: 0 ════╡ = 1 ╞═════",
                 "             └─────┘     ",
@@ -2309,8 +2861,8 @@ def test_conditional_multiplexer(self):
 
         self.assertEqual(str(_text_circuit_drawer(qc)), expected)
 
-    def test_text_conditional_measure(self):
-        """Conditional with measure on same clbit"""
+    def test_text_conditional_measure_cregbundle(self):
+        """Conditional with measure on same clbit with cregbundle"""
         qr = QuantumRegister(2, "qr")
         cr = ClassicalRegister(2, "cr")
         circuit = QuantumCircuit(qr, cr)
@@ -2325,15 +2877,97 @@ def test_text_conditional_measure(self):
                 "         └───┘└╥┘ ┌───┐ ",
                 "qr_1: |0>──────╫──┤ H ├─",
                 "               ║ ┌┴─╨─┴┐",
-                " cr_0: 0 ══════╩═╡     ╞",
-                "                 │ = 1 │",
-                " cr_1: 0 ════════╡     ╞",
-                "                 └─────┘",
+                " cr: 0 2/══════╩═╡ = 1 ╞",
+                "               0 └─────┘",
+            ]
+        )
+
+        self.assertEqual(str(_text_circuit_drawer(circuit, cregbundle=True)), expected)
+
+    def test_text_conditional_measure(self):
+        """Conditional with measure on same clbit"""
+        qr = QuantumRegister(2, "qr")
+        cr = ClassicalRegister(2, "cr")
+        circuit = QuantumCircuit(qr, cr)
+        circuit.h(qr[0])
+        circuit.measure(qr[0], cr[0])
+        circuit.h(qr[1]).c_if(cr, 1)
+
+        expected = "\n".join(
+            [
+                "         ┌───┐┌─┐     ",
+                "qr_0: |0>┤ H ├┤M├─────",
+                "         └───┘└╥┘┌───┐",
+                "qr_1: |0>──────╫─┤ H ├",
+                "               ║ └─╥─┘",
+                " cr_0: 0 ══════╩═══■══",
+                "                   ║  ",
+                " cr_1: 0 ══════════o══",
+                "                   =1 ",
             ]
         )
 
         self.assertEqual(str(_text_circuit_drawer(circuit)), expected)
 
+    def test_text_conditional_reverse_bits_1(self):
+        """Classical condition on 2q2c circuit with cregbundle=False and reverse bits"""
+        qr = QuantumRegister(2, "qr")
+        cr = ClassicalRegister(2, "cr")
+        circuit = QuantumCircuit(qr, cr)
+        circuit.h(qr[0])
+        circuit.measure(qr[0], cr[0])
+        circuit.h(qr[1]).c_if(cr, 1)
+
+        expected = "\n".join(
+            [
+                "                 ┌───┐",
+                "qr_1: |0>────────┤ H ├",
+                "         ┌───┐┌─┐└─╥─┘",
+                "qr_0: |0>┤ H ├┤M├──╫──",
+                "         └───┘└╥┘  ║  ",
+                " cr_1: 0 ══════╬═══o══",
+                "               ║   ║  ",
+                " cr_0: 0 ══════╩═══■══",
+                "                   =1 ",
+            ]
+        )
+
+        self.assertEqual(
+            str(_text_circuit_drawer(circuit, cregbundle=False, reverse_bits=True)), expected
+        )
+
+    def test_text_conditional_reverse_bits_2(self):
+        """Classical condition on 3q3c circuit with cergbundle=False and reverse bits"""
+        qr = QuantumRegister(3, "qr")
+        cr = ClassicalRegister(3, "cr")
+        circuit = QuantumCircuit(qr, cr)
+        circuit.h(qr[0]).c_if(cr, 6)
+        circuit.h(qr[1]).c_if(cr, 1)
+        circuit.h(qr[2]).c_if(cr, 2)
+        circuit.cx(0, 1).c_if(cr, 3)
+
+        expected = "\n".join(
+            [
+                "                   ┌───┐     ",
+                "qr_2: |0>──────────┤ H ├─────",
+                "              ┌───┐└─╥─┘┌───┐",
+                "qr_1: |0>─────┤ H ├──╫──┤ X ├",
+                "         ┌───┐└─╥─┘  ║  └─┬─┘",
+                "qr_0: |0>┤ H ├──╫────╫────■──",
+                "         └─╥─┘  ║    ║    ║  ",
+                " cr_2: 0 ══■════o════o════o══",
+                "           ║    ║    ║    ║  ",
+                " cr_1: 0 ══■════o════■════■══",
+                "           ║    ║    ║    ║  ",
+                " cr_0: 0 ══o════■════o════■══",
+                "           =6   =1   =2   =3 ",
+            ]
+        )
+
+        self.assertEqual(
+            str(_text_circuit_drawer(circuit, cregbundle=False, reverse_bits=True)), expected
+        )
+
 
 class TestTextIdleWires(QiskitTestCase):
     """The idle_wires option"""
@@ -3138,17 +3772,17 @@ def test_cccz_conditional(self):
         """Closed-Open controlled Z (with conditional)"""
         expected = "\n".join(
             [
-                "               ",
-                "q_0: |0>───■───",
-                "           │   ",
-                "q_1: |0>───o───",
-                "           │   ",
-                "q_2: |0>───■───",
-                "           │   ",
-                "q_3: |0>───■───",
-                "        ┌──╨──┐",
-                " c_0: 0 ╡ = 1 ╞",
-                "        └─────┘",
+                "            ",
+                "q_0: |0>─■──",
+                "         │  ",
+                "q_1: |0>─o──",
+                "         │  ",
+                "q_2: |0>─■──",
+                "         │  ",
+                "q_3: |0>─■──",
+                "         ║  ",
+                " c_0: 0 ═■══",
+                "         =1 ",
             ]
         )
         qr = QuantumRegister(4, "q")