Is there a way to prevent object mode change?

Question

Once setting an object mode with bpy.ops.object.mode_set(mode='EDIT'), can it be programmatically "locked" in that mode until the script explicitly sets another mode? Effectively locking out this button or any other ways of changing modes.

I've tried forcing it back using a modal operator if it detects a different mode, but that seems clunky and I feel like there should be a better way?

if bpy.context.object.mode != 'EDIT':
   bpy.ops.object.mode_set(mode='EDIT')

Answer 1

Or... You could register an operator named object.mode_set that does nothing and unregister it afterwards:

import bpy
from bpy.props import (
    BoolProperty, 
    StringProperty,
)
class FakeModeSet(bpy.types.Operator):
    """Locked Object Mode"""
    bl_idname = "object.mode_set"
    bl_label = "Fake Mode Set Operator to lock all the mode setting"
    mode: StringProperty() # So it doesn't get angry when buttons from UI 
    toggle: BoolProperty() # try to pass stuff to it
def execute(self, context):
    return {'FINISHED'}



bpy.utils.register_class(FakeModeSet)
#bpy.utils.unregister_class(FakeModeSet)

Answer 2

Lock Edit Mode for 10 seconds

import bpy
def msgbus_callback():
    print("mode changed")
    try:
        if bpy.context.object.mode != 'EDIT':
            bpy.ops.object.mode_set(mode='EDIT')
    except:
        pass
owner = "owner"
bpy.msgbus.subscribe_rna(
    key=(bpy.types.Object, 'mode'),
    owner=owner,
    args=(),
    notify=msgbus_callback
)
def in_10_sec():
    print("done")
    bpy.msgbus.clear_by_owner(owner)
bpy.app.timers.register(in_10_sec, first_interval=10)

Method 2: Use operator to block/allow some operator

Here is a operator to block object.mode_set and wm.search_menu

import bpy
def is_inside_viewport(event, context, header):
    r = context.region
    cy = r.height // 2 + r.y
    x = event.mouse_region_x
    y = event.mouse_region_y
    L = 0
    R = r.width
    B = 0
    T = r.height
if header.y > cy: # header is on top
    T -= header.height
else: # header is on bottom
    B += header.height

if x < L: return False
if x > R: return False
if y < B: return False
if y > T: return False
return True


class MY_OP(bpy.types.Operator):
    bl_idname = "view3d.my_operator"
    bl_label = "Operator"
def invoke(self, context, event):
    header = None
    for r in context.area.regions:
        if r.type == 'TOOL_HEADER':
            tool_header = r
        elif r.type == 'HEADER':
            header = r

    if header is None:
        print("header not find, cancelled")
        return {'CANCELLED'}

    self.header = header
    self.tool_header = tool_header
    context.window_manager.modal_handler_add(self)
    return {'RUNNING_MODAL'}

def modal(self, context, event):
    if event.type == 'ESC':
        print("operator finished")
        return {'FINISHED'}

    # check is the mouse under the viewport and not in header, but you can't use the header button
    if is_inside_viewport(event, context, self.header):
        is_mode_set = False
        for kc in context.window_manager.keyconfigs:
            for km in kc.keymaps:
                found_keymap = km.keymap_items.match_event(event)
                if found_keymap is not None:
                    name = found_keymap.idname
                    # print(name)
                    if name in {'object.mode_set', 'wm.search_menu'}:
                        is_mode_set = True
                        break

        if not is_mode_set:
            return {'PASS_THROUGH'}

    return {'RUNNING_MODAL'}



def register():
    bpy.utils.register_class(MY_OP)
def unregister():
    bpy.utils.unregister_class(MY_OP)
if name == "main":
    register()