file_path
stringlengths 32
153
| content
stringlengths 0
3.14M
|
|---|---|
omniverse-code/kit/exts/omni.kit.commands/omni/kit/commands/__init__.py | """Commands for Omniverse Kit.
:mod:`omni.kit.commands` module is used to register and execute **Commands**. It is built on top of :mod:`omni.kit.undo` module to enable undo/redo operations with **Commands**.
**Command** is any class with ``do()`` method and optionally ``undo()`` method. If **Command** has ``undo()`` method it is put on the undo stack when executed.
It must be inherited from :class:`Command` class for type checking.
Example of creating your command, registering it, passing arguments and undoing.
.. code-block:: python
class MyOrange(omni.kit.commands.Command):
def __init__(self, bar: list):
self._bar = bar
def do(self):
self._bar.append('orange')
def undo(self):
del self._bar[-1]
>>> import omni.kit.commands
>>> omni.kit.commands.register(MyOrangeCommand)
>>> my_list = []
>>> omni.kit.commands.execute("MyOrange", bar=my_list)
>>> my_list
['orange']
>>> import omni.kit.undo
>>> omni.kit.undo.undo()
>>> my_list
[]
>>> omni.kit.undo.redo()
>>> my_list
['orange']
"""
__all__ = [
"Command",
"create",
"register",
"register_all_commands_in_module",
"unregister_module_commands",
"unregister",
"PRE_DO_CALLBACK",
"POST_DO_CALLBACK",
"PRE_UNDO_CALLBACK",
"POST_UNDO_CALLBACK",
"register_callback",
"unregister_callback",
"get_command_class",
"get_command_class_signature",
"get_command_doc",
"get_command_parameters",
"get_commands",
"get_commands_list",
"execute",
"execute_argv",
"get_argument_parser_from_function",
"set_logging_enabled",
]
from .command import (
Command,
create,
register,
register_all_commands_in_module,
unregister_module_commands,
unregister,
PRE_DO_CALLBACK,
POST_DO_CALLBACK,
PRE_UNDO_CALLBACK,
POST_UNDO_CALLBACK,
register_callback,
unregister_callback,
get_command_class,
get_command_class_signature,
get_command_doc,
get_command_parameters,
get_commands,
get_commands_list,
execute,
execute_argv,
get_argument_parser_from_function,
_log_error,
set_logging_enabled,
)
from .command_actions import register_actions, deregister_actions
from .command_bridge import CommandBridge
from .on_change import subscribe_on_change, unsubscribe_on_change, _dispatch_changed
import omni.ext
import omni.kit.app
# this is needed for physx.ui
# once it properly imports its own dependencies, it can be removed
from typing import Any
class CommandExt(omni.ext.IExt):
"""Monitor for new extensions and register all commands in python modules of those extensions,
along with setting up a bridge that allows commands to be registered and executed from C++,
and registration of actions that wrap some basic command functionality like undo and redo.
"""
def on_startup(self, ext_id):
# Setup the command bridge
self._command_bridge = CommandBridge()
self._command_bridge.on_startup()
# Register command related actions
self._ext_name = omni.ext.get_extension_name(ext_id)
register_actions(self._ext_name)
# Monitor for commands in new or reloaded extensions
manager = omni.kit.app.get_app().get_extension_manager()
def on_change(e):
if e.type == omni.ext.EXTENSION_EVENT_SCRIPT_CHANGED:
def register_subclasses(cls):
register(cls)
for subcls in cls.__subclasses__():
register_subclasses(subcls)
register_subclasses(Command)
self._change_script_sub = manager.get_change_event_stream().create_subscription_to_pop(
on_change, name="kit.commands ExtensionChange"
)
def on_shutdown(self):
# Stop monitoring for commands in new or reloaded extensions
self._change_script_sub = None
# Deregister command related actions
deregister_actions(self._ext_name)
# Shutdown the command bridge
self._command_bridge.on_shutdown()
self._command_bridge = None
|
omniverse-code/kit/exts/omni.kit.commands/omni/kit/commands/on_change.py | _on_change = set()
def subscribe_on_change(on_change):
"""Subscribe to module change events. Triggered when commands added, executed."""
global _on_change
_on_change.add(on_change)
def unsubscribe_on_change(on_change):
"""Unsubscribe to module change events."""
global _on_change
_on_change.discard(on_change)
def _dispatch_changed():
for f in _on_change:
f()
|
omniverse-code/kit/exts/omni.kit.commands/omni/kit/commands/command_bridge.py | import carb
from ._kit_commands import *
from .command import (
Command,
execute,
register,
unregister,
get_command_class,
)
class CommandBridge:
def on_startup(self):
self._command_bridge = acquire_command_bridge()
def register_cpp_command(
extension_id: str, command_name: str, default_kwargs: dict, optional_kwargs: dict, required_kwargs: dict
):
def constructor(self, **kwargs):
# Check whether all the required keyword arguments specified from C++ have been provided.
for required_kwarg in self._required_kwargs:
if not required_kwarg in kwargs:
carb.log_error(
f"Required keyword argument '{required_kwarg}' not found when executing C++ command '{self.__class__.__name__}'."
)
# Check whether all the provided keyword arguments were specified as expected from C++.
for supplied_key, supplied_value in kwargs.items():
expected_value = self._all_kwargs.get(supplied_key, None)
if expected_value is None:
carb.log_warn(
f"Unexpected keyword argument '{supplied_key}' encountered when executing C++ command '{self.__class__.__name__}'."
)
# Merge the provided keyword arguments with the defaults specified from C++.
kwargs_with_defaults = {}
kwargs_with_defaults.update(self._default_kwargs)
kwargs_with_defaults.update(kwargs)
# Create the underlying C++ command object that can later be 'done' and 'undone.
self._cpp_command_object = self._command_bridge.create_cpp_command_object(
self.__class__.__module__, self.__class__.__name__, **kwargs_with_defaults
)
def do(self):
return self._cpp_command_object.do()
def undo(self):
self._cpp_command_object.undo()
new_cpp_command_class = type(
command_name,
(omni.kit.commands.Command,),
{
"__module__": extension_id,
"__init__": constructor,
"_default_kwargs": default_kwargs,
"_optional_kwargs": optional_kwargs,
"_required_kwargs": required_kwargs,
"_all_kwargs": {**default_kwargs, **optional_kwargs, **required_kwargs},
"_command_bridge": self._command_bridge,
"do": do,
"undo": undo,
},
)
omni.kit.commands.register(new_cpp_command_class)
def get_qualified_command_name(extension_id: str, command_name: str):
return extension_id + "." + command_name if extension_id else command_name
def deregister_cpp_command(extension_id: str, command_name: str):
qualified_command_name = get_qualified_command_name(extension_id, command_name)
command_class = omni.kit.commands.get_command_class(qualified_command_name)
if command_class:
omni.kit.commands.unregister(command_class)
command_class._command_bridge = None
def execute_command_from_cpp(extension_id: str, command_name: str, **kwargs):
qualified_command_name = get_qualified_command_name(extension_id, command_name)
return omni.kit.commands.execute(qualified_command_name, **kwargs)
import omni.kit.undo
self._command_bridge.enable(
register_cpp_command,
deregister_cpp_command,
execute_command_from_cpp,
omni.kit.undo.undo,
omni.kit.undo.redo,
omni.kit.undo.repeat,
omni.kit.undo.begin_group,
omni.kit.undo.end_group,
omni.kit.undo.begin_disabled,
omni.kit.undo.end_disabled,
)
def on_shutdown(self):
self._command_bridge.disable()
release_command_bridge(self._command_bridge)
self._command_bridge = None
|
omniverse-code/kit/exts/omni.kit.commands/omni/kit/commands/command.py | import argparse
import carb
from collections import defaultdict
import inspect
import re
import sys
from abc import ABC, abstractmethod
from typing import Any, Callable, Dict, List, Tuple, Type
from .on_change import _dispatch_changed
_commands = defaultdict(dict)
LOGGING_ENABLED = True
# Callback types
PRE_DO_CALLBACK = 'pre_do'
POST_DO_CALLBACK = 'post_do'
PRE_UNDO_CALLBACK = 'pre_undo'
POST_UNDO_CALLBACK = 'post_undo'
# Callback dictionary:
# Keys: tuple(command class name minus any trailing 'Command', module name), callback type.
# Value: list of callables.
_callbacks: Dict[Tuple[str, str], Dict[str, List[Callable]]] = defaultdict(lambda: defaultdict(list))
# Callback ID object. We don't expose this publicly to prevent users from relying on its internal representation.
class CallbackID:
def __init__(self, command_name, module_name, callback_type, callback):
self.__command_name = command_name
self.__module_name = module_name
self.__cb_type = callback_type
self.__callable = callback
def get(self):
return (self.__command_name, self.__module_name, self.__cb_type, self.__callable)
class Command(ABC):
"""Base class for all **Commands**."""
@abstractmethod
def do(self):
pass
def modify_callback_info(self, cb_type: str, args: Dict[str, Any]) -> Dict[str, Any]:
"""Returns a dictionary of information to be passed to callbacks of the given type.
By default callbacks are passed a copy of the arguments which were passed to **execute()** when the command
was invoked. This method can be overridden to modify that information for specific callback types.
Args:
cb_type: Type of callback the information will be passed to.
args: A dictionary containing a copy of the arguments with which the command was invoked. This is a
shallow copy so implementations may add, remove or replace dictionary elements but should not
modify any of the objects contained within it.
Returns:
A dictionary of information to be passed to callbacks of the specified type.
"""
return args
def _log_error(message: str):
if LOGGING_ENABLED:
carb.log_error(message)
def set_logging_enabled(enabled: bool):
global LOGGING_ENABLED
LOGGING_ENABLED = enabled
def _get_module_and_class(name: str) -> Tuple[str, str]:
x = name.rsplit(".", 1)
if len(x) > 1:
return x[0], x[1]
return "", x[0]
def _get_module_and_stripped_class(name: str) -> Tuple[str, str]:
if name.endswith('Command'):
name = name[:-7]
return _get_module_and_class(name)
def create(name, **kwargs):
"""Create **Command** object.
Args:
name: **Command** name.
**kwargs: Arbitrary keyword arguments to be passed into into **Command** constructor.
Returns:
**Command** object if succeeded. `None` if failed.
"""
command_class = get_command_class(name)
if not command_class:
return None
return command_class(**kwargs)
def register(command_class: Type[Command]):
"""Register a **Command**.
Args:
command_class: **Command** class.
"""
if not issubclass(command_class, Command):
_log_error(f"Can't register command: {command_class} it is not a subclass of a Command.")
return
global _commands
name = command_class.__name__
module = command_class.__module__
if module in _commands[name]:
carb.log_verbose('Command: "{}" is already registered. Overwriting it.'.format(name))
# If the class contains the "Command" suffix, register it without the suffix
if name.endswith("Command"):
name = name[:-7]
_commands[name][module] = command_class
_dispatch_changed()
def register_all_commands_in_module(module):
"""Register all **Commands** found in specified module.
Register all classes in module which inherit :class:`omni.kit.commands.Command`.
Args:
module: Module name or module object.
Returns:
An accessor object that contains a function for every command to execute it. e.g. if you register
the commands "Run" and "Hide" then the accessor behaves like:
.. code-block:: python
class Accessor:
@staticmethod
def Run(**kwargs):
execute("Run", **kwargs)
@staticmethod
def Hide(**kwargs):
execute("Hide", **kwargs)
This gives you a nicer syntax for running your commands:
.. code-block:: python
cmds = register_all_commands_in_module(module)
cmds.Run(3.14)
cmds.Hide("Behind the tree")
"""
class CommandInterface:
class Immediate:
pass
def add_command(cls, name: str, command: Command):
def execute_command(cls, **kwargs):
return execute(command.__name__, **kwargs)
def execute_command_immediate(cls, **kwargs):
return command.do_immediate(**kwargs)
execute_command.__doc__ = command.__doc__
execute_command.__name__ = name
setattr(cls, name, execute_command)
# If the command has an immediate mode add that to the command interface too
if hasattr(command, "do_immediate"):
if not hasattr(cls, "imm"):
setattr(cls, "imm", CommandInterface.Immediate())
execute_command_immediate.__doc__ = command.do_immediate.__doc__
execute_command_immediate.__name__ = name
setattr(cls.imm, name, command.do_immediate)
if isinstance(module, str) and module in sys.modules:
module = sys.modules[module]
for name in dir(module):
obj = getattr(module, name)
if isinstance(obj, type) and issubclass(obj, Command) and obj is not Command:
register(obj)
# Strip the redundant "Command" suffix if it exists on the command, so you can run "CreateNodeCommand"
# by calling command_interface.CreateNode()
if obj.__name__.endswith("Command"):
add_command(CommandInterface, obj.__name__[:-7], obj)
else:
add_command(CommandInterface, obj.__name__, obj)
return CommandInterface()
def unregister_module_commands(command_interface):
"""Unregister the list of commands registered by register_all_commands_in_module
Args:
command_interface: An object whose only members are command classes that were registered
"""
if command_interface is None:
return
for command_name in dir(command_interface):
command_class = get_command_class(command_name)
if command_class is not None:
unregister(command_class)
def unregister(command_class: Type[Command]):
"""Unregister a **Command**.
Args:
command_class: **Command** class.
"""
if not issubclass(command_class, Command):
_log_error(f"Can't unregister command: {command_class} it is not a subclass of a Command.")
return
global _commands, _callbacks
name = command_class.__name__
# If the class contains the "Command" suffix, unregister it without the suffix
if name.endswith("Command"):
name = name[:-7]
module = command_class.__module__
_commands[name].pop(module, None)
_callbacks.pop((name, module), None)
_dispatch_changed()
def get_command_class(name: str) -> Type[Command]:
"""Get **Command** class(type) by name.
Args:
name: **Command** name. It may include a module name to be more specific and avoid conflicts.
Returns:
**Command** class if succeeded. `None` if can't find a command with this name.
"""
module_name, class_name = _get_module_and_class(name)
cmds = _commands[class_name]
if len(cmds) == 0:
# Backward compatibility - allow commands to be invoked with "Command" suffix in their name
if name.endswith("Command"):
stripped_name = name[:-7]
module_name, class_name = _get_module_and_class(stripped_name)
cmds = _commands[class_name]
if not cmds:
return None
else:
return None
if len(cmds) == 1:
return next(iter(cmds.values()))
else:
if module_name == "":
_log_error(f"There are multiple commands with {name}. Pass full command name including module name.")
return None
return cmds.get(module_name, None)
def get_command_class_signature(name: str):
"""Get the init signature for a **Command**.
Args:
name: **Command** name. It may include a module name to be more specific and avoid conflicts.
Returns:
__init__ signature
"""
command_class = get_command_class(name)
if command_class is None:
return None
function = command_class.__init__
return inspect.signature(function)
def get_command_doc(name: str) -> str:
"""Get **Command** docstring by name.
Args:
name: **Command** name. It may include a module name to be more specific and avoid conflicts.
Returns:
Python docstring (__doc__) from a command type.
"""
command_class = get_command_class(name)
return inspect.getdoc(command_class) if command_class else ""
def register_callback(name: str, cb_type: str, callback: Callable[[Dict[str, Any]], None]) -> CallbackID:
"""Register a callback for a command.
Args:
name: **Command** name. It may include a module name to be more specific and avoid conflicts.
cb_type: Type of callback. Currently supported types are:
PRE_DO_CALLBACK - called before the command is executed
POST_DO_CALLBACK - called after the command is executed
PRE_UNDO_CALLBACK - called before the command is undone
POST_UNDO_CALLBACK - called after the command is undone
callback: Callable to be called. Will be passed a dictionary of information specific to that
command invocation. By default the dictionary will contain the parameters passed to
execute(), but this may be overridden by individual commands so check their documentation.
Many command parameters are optional so it is important that callbacks check for their
presence before attempting to access them. The callback must not make any changes to
the dictionary passed to it.
Returns:
An ID that can be passed to **unregister_callback**.
"""
global _callbacks
module_name, class_name = _get_module_and_stripped_class(name)
_callbacks[(class_name, module_name)][cb_type] += [callback]
return CallbackID(class_name, module_name, cb_type, callback)
def unregister_callback(id: CallbackID):
"""Unregister a command callback previously registered through **register_callback**.
Args:
id: The ID returned by **register_callback** when the callback was registered.
"""
global _callbacks
if isinstance(id, CallbackID):
class_name, module_name, cb_type, callback = id.get()
cbs = _callbacks[(class_name, module_name)][cb_type]
try:
cbs.remove(callback)
return
except:
pass
carb.log_error(f'Attempt to unregister a {cb_type} callback on {module_name}.{class_name} which was not registered.')
else:
carb.log_error('Invalid callback id')
class CommandParameter:
"""Parameter details from inspect.Parameter with documentation if present"""
def __init__(self, param: inspect.Parameter, doc):
self._param = param
self._doc = doc
@property
def name(self) -> str:
if self._param.kind == inspect.Parameter.VAR_POSITIONAL:
return "*" + self._param.name
elif self._param.kind == inspect.Parameter.VAR_KEYWORD:
return "**" + self._param.name
return self._param.name
@property
def type(self):
if self._param.annotation is inspect._empty:
return None
return self._param.annotation
@property
def type_str(self) -> str:
if self._param.annotation is inspect._empty:
return ""
return inspect.formatannotation(self._param.annotation)
@property
def default(self):
if self._param.default is inspect._empty:
return None
return self._param.default
@property
def default_str(self) -> str:
if self._param.default is inspect._empty:
return ""
return str(self._param.default)
@property
def doc(self) -> str:
return self._doc
def get_command_parameters(name: str) -> List[Type[CommandParameter]]:
"""Get all parameters for a **Commands**.
Args:
name: **Command** name. It may include a module name to be more specific and avoid conflicts.
Returns:
A list of **CommandParameter** (except 'self' parameter)
"""
command_class = get_command_class(name)
if command_class is None:
return []
result = []
function = command_class.__init__
vardata = _get_argument_doc(function.__doc__ or command_class.__doc__)
sig = inspect.signature(function)
for param in sig.parameters.values():
if param.name == "self":
continue
var_help = ""
if param.name in vardata and "doc" in vardata[param.name]:
var_help = vardata[param.name]["doc"]
result.append(CommandParameter(param, var_help))
return result
def get_commands():
"""Get all registered **Commands**."""
return _commands
def get_commands_list() -> List[Type[Command]]:
"""Return list of all **Command** classes registered."""
return [c for m in _commands.values() for c in m.values()]
def _get_callback_info(cb_type:str, command: Command, cmd_args: Dict[str, Any]) -> Dict[str, Any]:
cmd_args = cmd_args.copy()
info = command.modify_callback_info(cb_type, cmd_args)
if isinstance(info, dict):
return info
return cmd_args
def _call_callbacks(command: Command, name: str, kwargs: Dict[str, Any], cb_type: str):
module_name, class_name = _get_module_and_stripped_class(name)
callbacks = _callbacks[(class_name, module_name)][cb_type]
if callbacks:
info = _get_callback_info(cb_type, command, kwargs)
for cb in callbacks:
cb(info)
def execute(name, **kwargs) -> Tuple[bool, Any]:
"""Execute **Command**.
Args:
name: **Command** name. Can be class name (e.g. "My") or full name including module (e.g. "foo.bar.MyCommand")
**kwargs: Arbitrary keyword arguments to be passed into into **Command** constructor.
"""
# Create command using passed params
command = create(name, **kwargs)
# Check command is valid
if not command:
_log_error("Can't execute command: \"{}\", it wasn't registered or ambigious.".format(name))
return (False, None)
if not callable(getattr(command, "do", None)):
_log_error("Can't execute command: \"{}\", it doesn't have do() method.".format(name))
return (False, None)
import omni.kit.undo # Prevent a circular dependency which breaks the doc-gen
# Execute the command.
result = omni.kit.undo.execute(command, name, kwargs)
return result
def execute_argv(name, argv: list) -> Tuple[bool, Any]:
"""Execute **Command** using argument list..
Attempts to convert argument list into **Command**'s kwargs. If a **Command** has *get_argument_parser* method defined, it will be called to get :class:`argparse.ArgumentParser` instance to use for parsing.
Otherwise command docstring is used to extract argument information.
Args:
name: **Command** name.
argv: Argument list.
"""
command_class = get_command_class(name)
if not command_class:
return (False, None)
kwargs = {}
cmd_argparse = None
if hasattr(command_class, "get_argument_parser"):
cmd_argparse = command_class.get_argument_parser()
else:
cmd_argparse = get_argument_parser_from_function(command_class.__init__)
try:
parsed_args = cmd_argparse.parse_known_args(argv)
kwargs = vars(parsed_args[0])
except SystemExit:
pass
return execute(name, **kwargs)
def _get_argument_doc(doc):
if doc is None:
return {}
vardata = {}
param_name = None
for line in doc.splitlines():
stripped = line.strip()
if stripped:
m = re.match(r"\s*(?P<param>\w+)(?P<type>.*): (?P<doc>.*)", line)
if m is not None:
param_name = m.group("param")
vardata[param_name] = {}
vardata[param_name]["doc"] = m.group("doc")
elif param_name is not None:
# group multiline doc with previous param
vardata[param_name]["doc"] += " " + stripped
else:
param_name = None
return vardata
def get_argument_parser_from_function(function):
fn_argparse = argparse.ArgumentParser()
# Note: should probably be replaced with `vardata = _get_argument_doc(function)`
param_regex = re.compile(r":param (?P<param>\w+)[\[\s\[]*(?P<meta>[\w\s\,]*)[\]\]*]*: (?P<doc>.*)")
vardata = {}
for var_match in re.finditer(param_regex, function.__doc__):
param_name = var_match.group("param")
vardata[param_name] = {}
vardata[param_name]["doc"] = var_match.group("doc")
vardata[param_name]["meta"] = var_match.group("meta")
varnames = function.__code__.co_varnames
for var_name in varnames:
if var_name == "self":
continue
var_help = ""
is_required = True
nargs = None
if var_name in vardata:
var_help = vardata[var_name]["doc"]
if "optional" in vardata[var_name]["meta"]:
is_required = False
if "list" in vardata[var_name]["meta"]:
nargs = "*"
if nargs is not None:
fn_argparse.add_argument(
"--" + var_name, nargs=nargs, metavar=var_name, help=var_help, required=is_required
)
else:
fn_argparse.add_argument("--" + var_name, metavar=var_name, help=var_help, required=is_required)
return fn_argparse
|
omniverse-code/kit/exts/omni.kit.commands/omni/kit/commands/builtin/__init__.py | from .settings_commands import *
|
omniverse-code/kit/exts/omni.kit.commands/omni/kit/commands/builtin/settings_commands.py | import carb.settings
import omni.kit.commands
class ChangeSettingCommand(omni.kit.commands.Command):
"""
Change setting **Command**.
Args:
path: Path to the setting to change.
value: New value to change to.
prev: Previous value to for undo operation. If `None` current value would be saved as previous.
"""
def __init__(self, path, value, prev=None):
super().__init__()
self._value = value
self._prev = prev
self._path = path
self._settings = carb.settings.get_settings()
def do(self):
if self._prev is None:
self._prev = self._settings.get(self._path)
self._settings.set(self._path, self._value)
def undo(self):
self._settings.set(self._path, self._prev)
class ChangeDraggableSettingCommand(omni.kit.commands.Command):
"""
Change draggable setting **Command**.
Args:
path: Path to the setting to change.
value: New value to change to.
"""
def __init__(self, path, value):
super().__init__()
self._value = value
self._path = path
self._settings = carb.settings.get_settings()
def do(self):
self._settings.set(self._path, self._value)
|
omniverse-code/kit/exts/omni.kit.commands/omni/kit/commands/tests/__init__.py | from .test_commands import *
|
omniverse-code/kit/exts/omni.kit.commands/omni/kit/commands/tests/test_commands.py | import carb.settings
import omni.kit.test
import omni.kit.commands
import omni.kit.undo
from functools import partial
from ._kit_command_tests import *
_result = []
_command_tests = None
def setUpModule():
global _command_tests
_command_tests = acquire_command_tests()
def tearDownModule():
global _command_tests
release_command_tests(_command_tests)
_command_tests = None
class TestAppendCommand(omni.kit.commands.Command):
def __init__(self, x, y):
self._x = x
self._y = y
def do(self):
global _result
_result.append(self._x)
_result.append(self._y)
def undo(self):
global _result
del _result[-1]
del _result[-1]
def modify_callback_info(self, cb_type, cmd_args):
if cb_type == omni.kit.commands.PRE_DO_CALLBACK:
cmd_args['pre_do'] = 1
elif cb_type == omni.kit.commands.POST_DO_CALLBACK:
cmd_args['post_do'] = 2
elif cb_type == omni.kit.commands.PRE_UNDO_CALLBACK:
cmd_args['pre_undo'] = 3
elif cb_type == omni.kit.commands.POST_UNDO_CALLBACK:
cmd_args['post_undo'] = 4
else:
cmd_args['other'] = 5
return cmd_args
class TestAppendNoUndoCommand(omni.kit.commands.Command):
def __init__(self, x, y):
self._x = x
self._y = y
def do(self):
global _result
_result.append(self._x)
_result.append(self._y)
class TestRaiseException(omni.kit.commands.Command):
def __init__(self, x, y):
self._x = x
self._y = y
def do(self):
raise Exception("testing an error happening")
global _result
_result.append(self._x)
_result.append(self._y)
class TestNoBaseCommand:
def __init__(self, x, y):
self._x = x
self._y = y
def do(self):
global _result
_result.append(self._x)
_result.append(self._y)
class TestMissingDoMethod(omni.kit.commands.Command):
def __init__(self, x, y):
global _result
_result.append(x)
_result.append(y)
class TestCommandParameters(omni.kit.commands.Command):
"""
TestCommandParameters **Command**.
Args:
x: x argument doc
yy: int: yy argument doc slightly longer
zzz: zzz argument doc but
on 2 lines
More info here.
"""
def __init__(self, x, yy: int, zzz="some default value"):
self._x = x
self._y = yy
self._z = zzz
def do(self):
pass
def undo(self):
pass
class TestCommands(omni.kit.test.AsyncTestCase):
async def setUp(self):
# Cache the command tests interface.
global _command_tests
self.command_tests = _command_tests
# Disable logging for the time of tests to avoid spewing errors
omni.kit.commands.set_logging_enabled(False)
# make sure we are starting from a clean state
omni.kit.undo.clear_stack()
# Register all commands
omni.kit.commands.register(TestAppendCommand)
omni.kit.commands.register(TestAppendNoUndoCommand)
omni.kit.commands.register(TestRaiseException)
omni.kit.commands.register(TestNoBaseCommand)
omni.kit.commands.register(TestMissingDoMethod)
omni.kit.commands.register(TestCommandParameters)
async def tearDown(self):
# Unregister all commands
omni.kit.commands.unregister(TestAppendCommand)
omni.kit.commands.unregister(TestAppendNoUndoCommand)
omni.kit.commands.unregister(TestRaiseException)
omni.kit.commands.unregister(TestNoBaseCommand)
omni.kit.commands.unregister(TestMissingDoMethod)
omni.kit.commands.unregister(TestCommandParameters)
omni.kit.commands.set_logging_enabled(True)
# Clear the command tests interface.
self.command_tests = None
async def test_commands(self):
global _result
# Execute and undo
_result = []
omni.kit.commands.execute("TestAppend", x=1, y=2)
self.assertListEqual(_result, [1, 2])
omni.kit.undo.undo()
self.assertListEqual(_result, [])
# Execute and undo command with undo
_result = []
undo_stack_len = len(omni.kit.undo.get_undo_stack())
omni.kit.commands.execute("TestAppendNoUndo", x=1, y=2)
self.assertListEqual(_result, [1, 2])
self.assertEqual(undo_stack_len, len(omni.kit.undo.get_undo_stack()))
# Execute command without base, it should not be registered
_result = []
omni.kit.commands.execute("TestNoBase", x=1, y=2)
self.assertListEqual(_result, [])
# Unregister -> execution does nothing
omni.kit.commands.unregister(TestAppendCommand)
omni.kit.commands.execute("TestAppend", x=1, y=2)
self.assertListEqual(_result, [])
# Register twice works fine
omni.kit.commands.register(TestAppendCommand)
omni.kit.commands.register(TestAppendCommand)
omni.kit.commands.execute("omni.kit.builtin.tests.core.test_commands.TestAppendCommand", x=1, y=2)
self.assertListEqual(_result, [1, 2])
# Automatically register command from a module
_result = []
omni.kit.commands.unregister(TestAppendCommand)
omni.kit.commands.register_all_commands_in_module(__name__)
omni.kit.commands.execute("TestAppend", x=1, y=2)
omni.kit.commands.execute("TestAppend", x=3, y=4)
self.assertListEqual(_result, [1, 2, 3, 4])
omni.kit.undo.undo()
self.assertListEqual(_result, [1, 2])
omni.kit.undo.undo()
self.assertListEqual(_result, [])
_result = []
omni.kit.commands.execute("TestAppendNoUndo", x=1, y=2)
self.assertListEqual(_result, [1, 2])
_result = []
omni.kit.commands.execute("TestNoBase", x=1, y=2)
self.assertListEqual(_result, [])
async def test_multiple_calls(self):
global _result
# make sure that Undo/Redo work properly when called on multiple commands
_result = []
omni.kit.commands.execute("TestAppend", x=1, y=2)
self.assertListEqual(_result, [1, 2])
omni.kit.commands.execute("TestAppend", x=3, y=4)
self.assertListEqual(_result, [1, 2, 3, 4])
# first call should do actual work and return True
res = omni.kit.undo.undo()
self.assertListEqual(_result, [1, 2])
self.assertTrue(res)
# same for second since 2 commands were run
res = omni.kit.undo.undo()
self.assertListEqual(_result, [])
self.assertTrue(res)
# third call should do nothing and return False
res = omni.kit.undo.undo()
self.assertListEqual(_result, [])
self.assertFalse(res)
# now do the same for Redo
# first call should do actual work and return True
res = omni.kit.undo.redo()
self.assertListEqual(_result, [1, 2])
self.assertTrue(res)
# test undo while there are still commands on the redo stack
res = omni.kit.undo.undo()
self.assertListEqual(_result, [])
self.assertTrue(res)
# now redo both of the original commands
res = omni.kit.undo.redo()
self.assertListEqual(_result, [1, 2])
self.assertTrue(res)
res = omni.kit.undo.redo()
self.assertListEqual(_result, [1, 2, 3, 4])
self.assertTrue(res)
# third call should do nothing and return False
res = omni.kit.undo.redo()
self.assertListEqual(_result, [1, 2, 3, 4])
self.assertFalse(res)
def test_group(self):
global _result
# Group multiple commands
_result = []
omni.kit.undo.begin_group()
omni.kit.commands.execute("TestAppend", x=1, y=2)
omni.kit.commands.execute("TestAppend", x=3, y=4)
omni.kit.undo.end_group()
self.assertListEqual(_result, [1, 2, 3, 4])
omni.kit.undo.undo()
self.assertListEqual(_result, [])
# Context manager version
_result = []
with omni.kit.undo.group():
omni.kit.commands.execute("TestAppend", x=1, y=2)
omni.kit.commands.execute("TestAppend", x=3, y=4)
self.assertListEqual(_result, [1, 2, 3, 4])
omni.kit.undo.undo()
self.assertListEqual(_result, [])
# Nested groups do nothing different:
_result = []
omni.kit.undo.begin_group()
omni.kit.commands.execute("TestAppend", x=1, y=2)
omni.kit.commands.execute("TestAppend", x=3, y=4)
omni.kit.undo.begin_group()
omni.kit.commands.execute("TestAppend", x=5, y=6)
omni.kit.commands.execute("TestAppend", x=7, y=8)
omni.kit.undo.end_group()
omni.kit.undo.end_group()
self.assertListEqual(_result, [1, 2, 3, 4, 5, 6, 7, 8])
omni.kit.undo.undo()
self.assertListEqual(_result, [])
# test redo/undo multiple times with groups
omni.kit.undo.redo()
self.assertListEqual(_result, [1, 2, 3, 4, 5, 6, 7, 8])
omni.kit.undo.undo()
self.assertListEqual(_result, [])
omni.kit.undo.redo()
self.assertListEqual(_result, [1, 2, 3, 4, 5, 6, 7, 8])
omni.kit.undo.undo()
self.assertListEqual(_result, [])
# Group multiple commands from C++
_result = []
self.command_tests.test_begin_undo_group_from_cpp()
omni.kit.commands.execute("TestAppend", x=1, y=2)
omni.kit.commands.execute("TestAppend", x=3, y=4)
self.command_tests.test_end_undo_group_from_cpp()
self.assertListEqual(_result, [1, 2, 3, 4])
omni.kit.undo.undo()
self.assertListEqual(_result, [])
def test_disabled(self):
global _result
# Disable undo
_result = []
omni.kit.undo.begin_disabled()
omni.kit.commands.execute("TestAppend", x=1, y=2)
omni.kit.commands.execute("TestAppend", x=3, y=4)
omni.kit.undo.end_disabled()
self.assertListEqual(_result, [1, 2, 3, 4])
omni.kit.undo.undo()
self.assertListEqual(_result, [1, 2, 3, 4])
# Context manager version
_result = []
with omni.kit.undo.disabled():
omni.kit.commands.execute("TestAppend", x=1, y=2)
omni.kit.commands.execute("TestAppend", x=3, y=4)
self.assertListEqual(_result, [1, 2, 3, 4])
omni.kit.undo.undo()
self.assertListEqual(_result, [1, 2, 3, 4])
omni.kit.commands.execute("TestAppend", x=5, y=6)
omni.kit.commands.execute("TestAppend", x=7, y=8)
omni.kit.undo.undo()
omni.kit.undo.undo()
self.assertListEqual(_result, [1, 2, 3, 4])
# Disable undo then enable
_result = []
omni.kit.undo.begin_disabled()
omni.kit.commands.execute("TestAppend", x=1, y=2)
omni.kit.commands.execute("TestAppend", x=3, y=4)
omni.kit.undo.end_disabled()
omni.kit.commands.execute("TestAppend", x=5, y=6)
omni.kit.commands.execute("TestAppend", x=7, y=8)
self.assertListEqual(_result, [1, 2, 3, 4, 5, 6, 7, 8])
omni.kit.undo.undo()
self.assertListEqual(_result, [1, 2, 3, 4, 5, 6])
omni.kit.undo.undo()
self.assertListEqual(_result, [1, 2, 3, 4])
omni.kit.undo.undo()
self.assertListEqual(_result, [1, 2, 3, 4])
# Nested calls to disable undo
_result = []
omni.kit.undo.begin_disabled()
omni.kit.commands.execute("TestAppend", x=1, y=2)
omni.kit.commands.execute("TestAppend", x=3, y=4)
omni.kit.undo.begin_disabled()
omni.kit.commands.execute("TestAppend", x=5, y=6)
omni.kit.commands.execute("TestAppend", x=7, y=8)
omni.kit.undo.end_disabled()
omni.kit.undo.end_disabled()
self.assertListEqual(_result, [1, 2, 3, 4, 5, 6, 7, 8])
omni.kit.undo.undo()
self.assertListEqual(_result, [1, 2, 3, 4, 5, 6, 7, 8])
# Disable undo then enable from C++
_result = []
self.command_tests.test_begin_undo_disabled_from_cpp()
omni.kit.commands.execute("TestAppend", x=1, y=2)
omni.kit.commands.execute("TestAppend", x=3, y=4)
self.command_tests.test_end_undo_disabled_from_cpp()
omni.kit.commands.execute("TestAppend", x=5, y=6)
omni.kit.commands.execute("TestAppend", x=7, y=8)
self.assertListEqual(_result, [1, 2, 3, 4, 5, 6, 7, 8])
omni.kit.undo.undo()
self.assertListEqual(_result, [1, 2, 3, 4, 5, 6])
omni.kit.undo.undo()
self.assertListEqual(_result, [1, 2, 3, 4])
omni.kit.undo.undo()
self.assertListEqual(_result, [1, 2, 3, 4])
async def test_error(self):
global _result
# test command raising and exception during `do()`
_result = []
res = omni.kit.commands.execute("TestRaiseException", x=1, y=2)
self.assertEqual(res, (False, None))
self.assertListEqual(_result, [])
# test command TypeError exception because `do()` is missing
_result = [1, 2]
try:
omni.kit.commands.execute("TestMissingDoMethod", x=3, y=4)
except TypeError:
_result = []
self.assertListEqual(_result, [])
async def test_command_parameters(self):
params = omni.kit.commands.get_command_parameters("TestCommandParameters")
# test parameters
self.assertEqual(len(params), 3)
self.assertEqual(params[0].name, "x")
self.assertEqual(params[1].name, "yy")
self.assertEqual(params[2].name, "zzz")
self.assertEqual(params[0].type_str, "")
self.assertEqual(params[1].type_str, "int")
self.assertEqual(params[2].type_str, "")
self.assertEqual(params[0].default_str, "")
self.assertEqual(params[1].default_str, "")
self.assertEqual(params[2].default_str, "some default value")
# test documentation in parameters
self.assertEqual(params[0].doc, "x argument doc")
self.assertEqual(params[1].doc, "yy argument doc slightly longer")
self.assertEqual(params[2].doc, "zzz argument doc but on 2 lines")
async def test_callbacks(self):
self.x = None
self.y = None
self.pre_do_count = 0
self.post_do_count = 0
self.pre_undo_count = 0
self.post_undo_count = 0
self.cmd_specific_pre_do_count = 0
self.cmd_specific_post_do_count = 0
self.cmd_specific_pre_undo_count = 0
self.cmd_specific_post_undo_count = 0
self.cmd_specific_other_count = 0
def pre_do_callback(self, info):
self.pre_do_count += 1
self.x = info.get('x', None)
if info.get('pre_do', None):
self.cmd_specific_pre_do_count += 1
if info.get('post_do', None):
self.cmd_specific_post_do_count += 1
if info.get('pre_undo', None):
self.cmd_specific_pre_undo_count += 1
if info.get('post_undo', None):
self.cmd_specific_post_undo_count += 1
if info.get('other', None):
self.cmd_specific_other_count += 1
def post_do_callback(self, info):
self.post_do_count += 1
self.y = info.get('y', None)
if info.get('pre_do', None):
self.cmd_specific_pre_do_count += 1
if info.get('post_do', None):
self.cmd_specific_post_do_count += 1
if info.get('pre_undo', None):
self.cmd_specific_pre_undo_count += 1
if info.get('post_undo', None):
self.cmd_specific_post_undo_count += 1
if info.get('other', None):
self.cmd_specific_other_count += 1
def pre_undo_callback(self, info):
self.pre_undo_count += 1
self.x = info.get('x', None)
if info.get('pre_do', None):
self.cmd_specific_pre_undo_count += 1
if info.get('post_do', None):
self.cmd_specific_post_undo_count += 1
if info.get('pre_undo', None):
self.cmd_specific_pre_undo_count += 1
if info.get('post_undo', None):
self.cmd_specific_post_undo_count += 1
if info.get('other', None):
self.cmd_specific_other_count += 1
def post_undo_callback(self, info):
self.post_undo_count += 1
self.y = info.get('y', None)
if info.get('pre_do', None):
self.cmd_specific_pre_undo_count += 1
if info.get('post_do', None):
self.cmd_specific_post_undo_count += 1
if info.get('pre_undo', None):
self.cmd_specific_pre_undo_count += 1
if info.get('post_undo', None):
self.cmd_specific_post_undo_count += 1
if info.get('other', None):
self.cmd_specific_other_count += 1
# With no callbacks registered, nothing should change.
omni.kit.commands.execute("TestAppend", x=1, y=2)
self.assertEqual(self.x, None)
self.assertEqual(self.y, None)
self.assertEqual(self.pre_do_count, 0)
self.assertEqual(self.post_do_count, 0)
self.assertEqual(self.cmd_specific_pre_do_count, 0)
self.assertEqual(self.cmd_specific_post_do_count, 0)
self.assertEqual(self.pre_undo_count, 0)
self.assertEqual(self.post_undo_count, 0)
self.assertEqual(self.cmd_specific_pre_undo_count, 0)
self.assertEqual(self.cmd_specific_post_undo_count, 0)
self.assertEqual(self.cmd_specific_other_count, 0)
# With only the pre- callback registered only x, pre_do_count and cmd_specific_pre_do_count should
# change.
pre_do_cb = omni.kit.commands.register_callback("TestAppend", omni.kit.commands.PRE_DO_CALLBACK, partial(pre_do_callback, self))
omni.kit.commands.execute("TestAppend", x=3, y=4)
self.assertEqual(self.x, 3)
self.assertEqual(self.y, None)
self.assertEqual(self.pre_do_count, 1)
self.assertEqual(self.post_do_count, 0)
self.assertEqual(self.cmd_specific_pre_do_count, 1)
self.assertEqual(self.cmd_specific_post_do_count, 0)
self.assertEqual(self.pre_undo_count, 0)
self.assertEqual(self.post_undo_count, 0)
self.assertEqual(self.cmd_specific_pre_undo_count, 0)
self.assertEqual(self.cmd_specific_post_undo_count, 0)
self.assertEqual(self.cmd_specific_other_count, 0)
# With both callbacks registered, everything except cmd_specific_other_count and various *_undo_counts should change.
post_do_cb = omni.kit.commands.register_callback("TestAppend", omni.kit.commands.POST_DO_CALLBACK, partial(post_do_callback, self))
omni.kit.commands.execute("TestAppend", x=5, y=6)
self.assertEqual(self.x, 5)
self.assertEqual(self.y, 6)
self.assertEqual(self.pre_do_count, 2)
self.assertEqual(self.post_do_count, 1)
self.assertEqual(self.cmd_specific_pre_do_count, 2)
self.assertEqual(self.cmd_specific_post_do_count, 1)
self.assertEqual(self.pre_undo_count, 0)
self.assertEqual(self.post_undo_count, 0)
self.assertEqual(self.cmd_specific_pre_undo_count, 0)
self.assertEqual(self.cmd_specific_post_undo_count, 0)
self.assertEqual(self.cmd_specific_other_count, 0)
# With callbacks removed, nothing should change.
omni.kit.commands.unregister_callback(pre_do_cb)
omni.kit.commands.unregister_callback(post_do_cb)
omni.kit.commands.execute("TestAppend", x=7, y=8)
self.assertEqual(self.x, 5)
self.assertEqual(self.y, 6)
self.assertEqual(self.pre_do_count, 2)
self.assertEqual(self.post_do_count, 1)
self.assertEqual(self.cmd_specific_pre_do_count, 2)
self.assertEqual(self.cmd_specific_post_do_count, 1)
self.assertEqual(self.pre_undo_count, 0)
self.assertEqual(self.post_undo_count, 0)
self.assertEqual(self.cmd_specific_pre_undo_count, 0)
self.assertEqual(self.cmd_specific_post_undo_count, 0)
self.assertEqual(self.cmd_specific_other_count, 0)
# TestAppendNoUndoCommand doesn't provide any special callback info
# so none of the 'specific' data counts should change.
pre_do_cb = omni.kit.commands.register_callback("TestAppendNoUndoCommand", omni.kit.commands.PRE_DO_CALLBACK, partial(pre_do_callback, self))
post_do_cb = omni.kit.commands.register_callback("TestAppendNoUndoCommand", omni.kit.commands.POST_DO_CALLBACK, partial(post_do_callback, self))
omni.kit.commands.execute("TestAppendNoUndoCommand", x=9, y=10)
self.assertEqual(self.x, 9)
self.assertEqual(self.y, 10)
self.assertEqual(self.pre_do_count, 3)
self.assertEqual(self.post_do_count, 2)
self.assertEqual(self.cmd_specific_pre_do_count, 2)
self.assertEqual(self.cmd_specific_post_do_count, 1)
self.assertEqual(self.pre_undo_count, 0)
self.assertEqual(self.post_undo_count, 0)
self.assertEqual(self.cmd_specific_pre_undo_count, 0)
self.assertEqual(self.cmd_specific_post_undo_count, 0)
self.assertEqual(self.cmd_specific_other_count, 0)
omni.kit.commands.unregister_callback(pre_do_cb)
omni.kit.commands.unregister_callback(post_do_cb)
# With no undo callbacks registered, nothing should change.
omni.kit.undo.undo()
self.assertEqual(self.x, 9)
self.assertEqual(self.y, 10)
self.assertEqual(self.pre_do_count, 3)
self.assertEqual(self.post_do_count, 2)
self.assertEqual(self.cmd_specific_pre_do_count, 2)
self.assertEqual(self.cmd_specific_post_do_count, 1)
self.assertEqual(self.pre_undo_count, 0)
self.assertEqual(self.post_undo_count, 0)
self.assertEqual(self.cmd_specific_pre_undo_count, 0)
self.assertEqual(self.cmd_specific_post_undo_count, 0)
self.assertEqual(self.cmd_specific_other_count, 0)
# With only the pre-undo callback registered only x, pre_undo_count and cmd_specific_pre_undo_count should change.
pre_undo_cb = omni.kit.commands.register_callback("TestAppend", omni.kit.commands.PRE_UNDO_CALLBACK, partial(pre_undo_callback, self))
omni.kit.undo.undo()
self.assertEqual(self.x, 5)
self.assertEqual(self.y, 10)
self.assertEqual(self.pre_do_count, 3)
self.assertEqual(self.post_do_count, 2)
self.assertEqual(self.cmd_specific_pre_do_count, 2)
self.assertEqual(self.cmd_specific_post_do_count, 1)
self.assertEqual(self.pre_undo_count, 1)
self.assertEqual(self.post_undo_count, 0)
self.assertEqual(self.cmd_specific_pre_undo_count, 1)
self.assertEqual(self.cmd_specific_post_undo_count, 0)
self.assertEqual(self.cmd_specific_other_count, 0)
# With both callbacks registered, everything except cmd_specific_other_count and various *_do_counts should change.
post_undo_cb = omni.kit.commands.register_callback("TestAppend", omni.kit.commands.POST_UNDO_CALLBACK, partial(post_undo_callback, self))
omni.kit.undo.undo()
self.assertEqual(self.x, 3)
self.assertEqual(self.y, 4)
self.assertEqual(self.pre_do_count, 3)
self.assertEqual(self.post_do_count, 2)
self.assertEqual(self.cmd_specific_pre_do_count, 2)
self.assertEqual(self.cmd_specific_post_do_count, 1)
self.assertEqual(self.pre_undo_count, 2)
self.assertEqual(self.post_undo_count, 1)
self.assertEqual(self.cmd_specific_pre_undo_count, 2)
self.assertEqual(self.cmd_specific_post_undo_count, 1)
self.assertEqual(self.cmd_specific_other_count, 0)
# With callbacks removed, nothing should change.
omni.kit.commands.unregister_callback(pre_undo_cb)
omni.kit.commands.unregister_callback(post_undo_cb)
omni.kit.undo.undo()
self.assertEqual(self.x, 3)
self.assertEqual(self.y, 4)
self.assertEqual(self.pre_do_count, 3)
self.assertEqual(self.post_do_count, 2)
self.assertEqual(self.cmd_specific_pre_do_count, 2)
self.assertEqual(self.cmd_specific_post_do_count, 1)
self.assertEqual(self.pre_undo_count, 2)
self.assertEqual(self.post_undo_count, 1)
self.assertEqual(self.cmd_specific_pre_undo_count, 2)
self.assertEqual(self.cmd_specific_post_undo_count, 1)
self.assertEqual(self.cmd_specific_other_count, 0)
# With callbacks registered again but nothing left to undo, nothing should change.
pre_undo_cb = omni.kit.commands.register_callback("TestAppend", omni.kit.commands.PRE_UNDO_CALLBACK, partial(pre_undo_callback, self))
post_undo_cb = omni.kit.commands.register_callback("TestAppend", omni.kit.commands.POST_UNDO_CALLBACK, partial(post_undo_callback, self))
omni.kit.undo.undo()
self.assertEqual(self.x, 3)
self.assertEqual(self.y, 4)
self.assertEqual(self.pre_do_count, 3)
self.assertEqual(self.post_do_count, 2)
self.assertEqual(self.cmd_specific_pre_do_count, 2)
self.assertEqual(self.cmd_specific_post_do_count, 1)
self.assertEqual(self.pre_undo_count, 2)
self.assertEqual(self.post_undo_count, 1)
self.assertEqual(self.cmd_specific_pre_undo_count, 2)
self.assertEqual(self.cmd_specific_post_undo_count, 1)
self.assertEqual(self.cmd_specific_other_count, 0)
async def test_subscribe_on_undo_stack_change(self):
self.command_names = []
self.command_entries = []
def on_undo_stack_change(command_names):
self.command_names += command_names
def on_undo_stack_change_detailed(command_entries):
self.command_entries += command_entries
# Execute a command before subscribing to on_change callbacks.
omni.kit.commands.execute("TestAppend", x=1, y=2)
self.assertListEqual(self.command_names, [])
self.assertListEqual(self.command_entries, [])
# Subscribe to on_change callbacks.
omni.kit.undo.subscribe_on_change(on_undo_stack_change)
omni.kit.undo.subscribe_on_change_detailed(on_undo_stack_change_detailed)
# Execute a command.
omni.kit.commands.execute("TestAppend", x=1, y=2)
self.assertListEqual(self.command_names, ["TestAppend"])
self.assertEqual(len(self.command_entries), 1)
self.assertEqual(self.command_entries[0].name, "TestAppend")
self.assertDictEqual(self.command_entries[0].kwargs, {"x":1, "y":2})
self.assertEqual(self.command_entries[0].level, 0)
self.assertEqual(self.command_entries[0].error, False)
# Undo the command.
self.command_names = []
self.command_entries = []
omni.kit.undo.undo()
self.assertListEqual(self.command_names, ["TestAppend"])
self.assertEqual(len(self.command_entries), 1)
self.assertEqual(self.command_entries[0].name, "TestAppend")
self.assertDictEqual(self.command_entries[0].kwargs, {"x":1, "y":2})
self.assertEqual(self.command_entries[0].level, 0)
self.assertEqual(self.command_entries[0].error, False)
# Redo the command.
self.command_names = []
self.command_entries = []
omni.kit.undo.redo()
self.assertListEqual(self.command_names, ["TestAppend"])
self.assertEqual(len(self.command_entries), 1)
self.assertEqual(self.command_entries[0].name, "TestAppend")
self.assertDictEqual(self.command_entries[0].kwargs, {"x":1, "y":2})
self.assertEqual(self.command_entries[0].level, 0)
self.assertEqual(self.command_entries[0].error, False)
# Group multiple commands
omni.kit.undo.begin_group()
self.command_names = []
self.command_entries = []
omni.kit.commands.execute("TestAppend", x=1, y=2)
self.assertListEqual(self.command_names, ["TestAppend"])
self.assertEqual(len(self.command_entries), 1)
self.assertEqual(self.command_entries[0].name, "TestAppend")
self.assertDictEqual(self.command_entries[0].kwargs, {"x":1, "y":2})
self.assertEqual(self.command_entries[0].level, 1)
self.assertEqual(self.command_entries[0].error, False)
self.command_names = []
self.command_entries = []
omni.kit.commands.execute("TestAppend", x=3, y=4)
self.assertListEqual(self.command_names, ["TestAppend"])
self.assertEqual(len(self.command_entries), 1)
self.assertEqual(self.command_entries[0].name, "TestAppend")
self.assertDictEqual(self.command_entries[0].kwargs, {"x":3, "y":4})
self.assertEqual(self.command_entries[0].level, 1)
self.assertEqual(self.command_entries[0].error, False)
self.command_names = []
self.command_entries = []
omni.kit.undo.end_group()
self.assertListEqual(self.command_names, ["Group"])
self.assertEqual(len(self.command_entries), 1)
self.assertEqual(self.command_entries[0].name, "Group")
self.assertDictEqual(self.command_entries[0].kwargs, {})
self.assertEqual(self.command_entries[0].level, 0)
self.assertEqual(self.command_entries[0].error, False)
# Undo the grouped commands (the callback will only be invoked once for the whole group).
self.command_names = []
self.command_entries = []
omni.kit.undo.undo()
self.assertListEqual(self.command_names, ["TestAppend", "TestAppend", "Group"])
self.assertEqual(len(self.command_entries), 3)
self.assertEqual(self.command_entries[0].name, "TestAppend")
self.assertDictEqual(self.command_entries[0].kwargs, {"x":3, "y":4})
self.assertEqual(self.command_entries[0].level, 1)
self.assertEqual(self.command_entries[0].error, False)
self.assertEqual(self.command_entries[1].name, "TestAppend")
self.assertDictEqual(self.command_entries[1].kwargs, {"x":1, "y":2})
self.assertEqual(self.command_entries[1].level, 1)
self.assertEqual(self.command_entries[1].error, False)
self.assertEqual(self.command_entries[2].name, "Group")
self.assertDictEqual(self.command_entries[2].kwargs, {})
self.assertEqual(self.command_entries[2].level, 0)
self.assertEqual(self.command_entries[2].error, False)
# Redo the grouped commands (the callback will be invoked once for each command being redone).
self.command_names = []
self.command_entries = []
omni.kit.undo.redo()
self.assertListEqual(self.command_names, ["TestAppend", "TestAppend", "Group"])
self.assertEqual(len(self.command_entries), 3)
self.assertEqual(self.command_entries[0].name, "TestAppend")
self.assertDictEqual(self.command_entries[0].kwargs, {"x":1, "y":2})
self.assertEqual(self.command_entries[0].level, 1)
self.assertEqual(self.command_entries[0].error, False)
self.assertEqual(self.command_entries[1].name, "TestAppend")
self.assertDictEqual(self.command_entries[1].kwargs, {"x":3, "y":4})
self.assertEqual(self.command_entries[1].level, 1)
self.assertEqual(self.command_entries[1].error, False)
self.assertEqual(self.command_entries[2].name, "Group")
self.assertDictEqual(self.command_entries[2].kwargs, {})
self.assertEqual(self.command_entries[2].level, 0)
self.assertEqual(self.command_entries[2].error, False)
# Unsubscribe from on_change callbacks.
omni.kit.undo.unsubscribe_on_change_detailed(on_undo_stack_change_detailed)
omni.kit.undo.unsubscribe_on_change(on_undo_stack_change)
async def test_cpp_commands(self):
global _result
_result = []
# Give the C++ test code access to the global test result list
self.command_tests.set_test_result_list(_result)
# Register a new command type from C++
self.command_tests.test_register_cpp_command("omni.kit.command_tests", "TestCppAppendCommand")
# Execute the C++ command from Python
res = omni.kit.commands.execute("TestCppAppend", x=7, y=9)
self.assertListEqual(_result, [7, 9])
self.assertEqual(res, (True, None))
# Undo the C++ command from C++
res = self.command_tests.test_undo_command_from_cpp()
self.assertListEqual(_result, [])
self.assertTrue(res)
# Redo the C++ command from Python
res = omni.kit.undo.redo()
self.assertListEqual(_result, [7, 9])
self.assertTrue(res)
# Execute the C++ command from C++
res = self.command_tests.test_execute_command_from_cpp("TestCppAppend", x=99, y=0)
self.assertListEqual(_result, [7, 9, 99, 0])
self.assertTrue(res)
# Undo the C++ command from Python
res = omni.kit.undo.undo()
self.assertListEqual(_result, [7,9])
self.assertTrue(res)
# Execute the C++ command from C++ with a default argument
res = self.command_tests.test_execute_command_from_cpp("TestCppAppend", x=99)
self.assertListEqual(_result, [7, 9, 99, -1])
self.assertTrue(res)
# Execute the C++ command from Python with a default argument
res = omni.kit.commands.execute("TestCppAppend", y=-9)
self.assertListEqual(_result, [7, 9, 99, -1, 9, -9])
self.assertEqual(res, (True, None))
# Undo the C++ command from C++
res = self.command_tests.test_undo_command_from_cpp()
self.assertListEqual(_result, [7, 9, 99, -1])
self.assertTrue(res)
# Undo the C++ command from Python
res = omni.kit.undo.undo()
self.assertListEqual(_result, [7,9])
self.assertTrue(res)
# Execute an existng Python command from C++
res = self.command_tests.test_execute_command_from_cpp("TestAppend", x=1, y=2)
self.assertListEqual(_result, [7, 9, 1, 2])
self.assertTrue(res)
# Undo the Python command from C++
res = self.command_tests.test_undo_command_from_cpp()
self.assertListEqual(_result, [7,9])
self.assertTrue(res)
# Redo the Python command from C++
res = self.command_tests.test_redo_command_from_cpp()
self.assertListEqual(_result, [7,9, 1, 2])
self.assertTrue(res)
# Undo the Python command from Python
res = omni.kit.undo.undo()
self.assertListEqual(_result, [7,9])
self.assertTrue(res)
# Deregister the C++ command from C++
self.command_tests.test_deregister_cpp_command("omni.kit.command_tests", "TestCppAppendCommand")
# Undo the C++ command from Python after it has been deregistered
res = omni.kit.undo.undo()
self.assertListEqual(_result, [])
self.assertTrue(res)
# Execute the C++ command from C++ after it has been deregistered (does nothing)
res = self.command_tests.test_execute_command_from_cpp("TestCppAppend", x=10, y=20)
self.assertListEqual(_result, [])
self.assertFalse(res)
# Execute the C++ command from Python after it has been deregistered (does nothing)
res = omni.kit.commands.execute("TestCppAppend", x=10, y=20)
self.assertListEqual(_result, [])
self.assertEqual(res, (False, None))
# Redo the C++ command from C++ after it has been deregistered
res = self.command_tests.test_redo_command_from_cpp()
self.assertListEqual(_result, [7, 9])
self.assertTrue(res)
# Undo the C++ command from C++ after it has been deregistered
res = self.command_tests.test_undo_command_from_cpp()
self.assertListEqual(_result, [])
self.assertTrue(res)
# Release the C++ reference to the global test result list
self.command_tests.clear_test_result_list()
def test_repeat(self):
global _result
_result = []
# Execute a command
res = omni.kit.commands.execute("TestAppend", x=1, y=2)
self.assertListEqual(_result, [1, 2])
self.assertEqual(res, (True, None))
# Repeat the command
res = omni.kit.undo.repeat()
self.assertListEqual(_result, [1, 2, 1, 2])
self.assertTrue(res)
# Undo the repeated command
res = omni.kit.undo.undo()
self.assertListEqual(_result, [1, 2])
self.assertTrue(res)
# Redo the repeated command
res = omni.kit.undo.redo()
self.assertListEqual(_result, [1, 2, 1, 2])
self.assertTrue(res)
# Repeat the command from C++
res = self.command_tests.test_repeat_command_from_cpp()
self.assertListEqual(_result, [1, 2, 1, 2, 1, 2])
self.assertTrue(res)
# Undo the repeated and original commands
res = omni.kit.undo.undo()
self.assertListEqual(_result, [1, 2, 1, 2])
self.assertTrue(res)
res = omni.kit.undo.undo()
self.assertListEqual(_result, [1, 2])
self.assertTrue(res)
res = omni.kit.undo.undo()
self.assertListEqual(_result, [])
self.assertTrue(res)
# Group multiple commands
omni.kit.undo.begin_group()
omni.kit.commands.execute("TestAppend", x=1, y=2)
omni.kit.commands.execute("TestAppend", x=3, y=4)
omni.kit.undo.end_group()
self.assertListEqual(_result, [1, 2, 3, 4])
# Repeat the grouped commands
res = omni.kit.undo.repeat()
self.assertListEqual(_result, [1, 2, 3, 4, 1, 2, 3, 4])
self.assertTrue(res)
# Undo the repeated grouped commands
res = omni.kit.undo.undo()
self.assertListEqual(_result, [1, 2, 3, 4])
self.assertTrue(res)
# Redo the repeated grouped commands
res = omni.kit.undo.redo()
self.assertListEqual(_result, [1, 2, 3, 4, 1, 2, 3, 4])
self.assertTrue(res)
# Repeat the grouped commands from C++
res = self.command_tests.test_repeat_command_from_cpp()
self.assertListEqual(_result, [1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4])
self.assertTrue(res)
# Undo the repeated and original grouped commands
res = omni.kit.undo.undo()
self.assertListEqual(_result, [1, 2, 3, 4, 1, 2, 3, 4])
self.assertTrue(res)
res = omni.kit.undo.undo()
self.assertListEqual(_result, [1, 2, 3, 4])
self.assertTrue(res)
res = omni.kit.undo.undo()
self.assertListEqual(_result, [])
self.assertTrue(res)
def test_change_setting_command(self):
# Set the default value of our draggable setting
test_setting_default_value = -1
test_setting_path = "/test/some/setting"
settings = carb.settings.get_settings()
settings.set_default(test_setting_path, test_setting_default_value)
self.assertEqual(settings.get(test_setting_path), test_setting_default_value)
# Execute a change setting command
test_setting_new_value = 9
res = omni.kit.commands.execute("ChangeSetting", path=test_setting_path, value=test_setting_new_value)
self.assertEqual(settings.get(test_setting_path), test_setting_new_value)
# Verify that undoing the change setting command resets the setting to the default value
omni.kit.undo.undo()
self.assertEqual(settings.get(test_setting_path), test_setting_default_value)
def test_change_draggable_setting_command(self):
# Set the default value of our draggable setting
test_draggable_setting_default_value = -1
test_draggable_setting_path = "/test/draggable/setting"
settings = carb.settings.get_settings()
settings.set_default(test_draggable_setting_path, test_draggable_setting_default_value)
self.assertEqual(settings.get(test_draggable_setting_path), test_draggable_setting_default_value)
# Execute a change draggable setting command
test_draggable_setting_new_value = 9
res = omni.kit.commands.execute("ChangeDraggableSetting", path=test_draggable_setting_path, value=test_draggable_setting_new_value)
self.assertEqual(settings.get(test_draggable_setting_path), test_draggable_setting_new_value)
# Verify that undoing the change draggable setting command does nothing
omni.kit.undo.undo()
self.assertEqual(settings.get(test_draggable_setting_path), test_draggable_setting_new_value)
def test_last_command(self):
# Set the current and default values of a test setting
test_setting_default_value = -1
test_setting_path = "/test/some/setting"
settings = carb.settings.get_settings()
settings.set(test_setting_path, test_setting_default_value)
settings.set_default(test_setting_path, test_setting_default_value)
self.assertEqual(settings.get(test_setting_path), test_setting_default_value)
# Execute a change draggable setting command
test_setting_new_value = 9
res = omni.kit.commands.execute("ChangeDraggableSetting", path=test_setting_path, value=test_setting_new_value)
self.assertEqual(settings.get(test_setting_path), test_setting_new_value)
# Verify that the 'last command' was set
last_command_setting_path = "/crashreporter/data/lastCommand"
last_command = settings.get(last_command_setting_path)
self.assertEqual(last_command, "ChangeDraggableSetting(path=/test/some/setting,value=9)")
# Execute a change setting command
test_setting_new_value = 99
res = omni.kit.commands.execute("ChangeSetting", path=test_setting_path, value=test_setting_new_value)
self.assertEqual(settings.get(test_setting_path), test_setting_new_value)
# Verify that the 'last command' was set
last_command = settings.get(last_command_setting_path)
self.assertEqual(last_command, "ChangeSetting(path=/test/some/setting,value=99)")
|
omniverse-code/kit/exts/omni.kit.widget.filebrowser/PACKAGE-LICENSES/omni.kit.widget.filebrowser-LICENSE.md | Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved.
NVIDIA CORPORATION and its licensors retain all intellectual property
and proprietary rights in and to this software, related documentation
and any modifications thereto. Any use, reproduction, disclosure or
distribution of this software and related documentation without an express
license agreement from NVIDIA CORPORATION is strictly prohibited. |
omniverse-code/kit/exts/omni.kit.widget.filebrowser/scripts/demo_filebrowser.py | # Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
import sys
import omni.ui as ui
import asyncio
import omni.client
from omni.kit.mainwindow import get_main_window
from omni.kit.widget.filebrowser import *
from functools import partial
class FileBrowserView:
SERVER_TYPE_FILESYSTEM = "fileSystem"
SERVER_TYPE_NUCLEUS = "nucleus"
def __init__(self, title: str, **kwargs):
self._title = title
self._filebrowser = None
self._item_menu = None
self._server_menu = None
self._style = self._init_style()
self._layout = kwargs.get("layout", LAYOUT_DEFAULT)
self._tooltip = kwargs.get("tooltip", False)
self._allow_multi_selection = kwargs.get("allow_multi_selection", True)
def build_ui(self):
""" """
main_window = get_main_window()
self._menu_bar = main_window.get_main_menu_bar()
self._menu_bar.set_style(self._style["MenuBar"])
self._menu_bar.visible = True
options = [
("Split Panes", LAYOUT_SPLIT_PANES, False),
("Single Pane Slim", LAYOUT_SINGLE_PANE_SLIM, False),
("Single Pane Wide", LAYOUT_SINGLE_PANE_WIDE, False),
("Grid View", LAYOUT_SPLIT_PANES, True),
]
with ui.VStack(spacing=10):
with ui.HStack(height=30):
collection = ui.RadioCollection()
for option in options:
button = ui.RadioButton(text=option[0], radio_collection=collection, width=120)
button.set_clicked_fn(partial(self._build_filebrowser, option[1], option[2]))
ui.Spacer()
self._frame = ui.Frame()
self._build_filebrowser(LAYOUT_DEFAULT)
asyncio.ensure_future(self._dock_window(self._title, ui.DockPosition.SAME))
def _build_filebrowser(self, layout: int, show_grid: bool = False):
if self._filebrowser:
self._filebrowser.destroy()
with self._frame:
self._filebrowser = FileBrowserWidget(
"Omniverse",
layout=layout,
tooltip=self._tooltip,
allow_multi_selection=self._allow_multi_selection,
show_grid_view=show_grid,
mouse_pressed_fn=lambda b, item: self._on_mouse_pressed(b, item),
)
# Initialize interface with this default list of connections
self.add_connection("C:", "C:")
self.add_connection("ov-content", "omniverse://ov-content")
def add_connection(self, name: str, path: str):
asyncio.ensure_future(self._add_connection(name, path))
def _init_style(self) -> dict:
style = {
"MenuBar": {
"background_color": 0xFF23211F,
"background_selected_color": 0x664F4D43,
"color": 0xFFAAAAAA,
"border_width": 0.5,
"border_color": 0xFF8A8777,
"padding": 8,
}
}
return style
def _on_mouse_pressed(self, button: ui.Button, item: FileBrowserItem):
if button == 1:
if self._filebrowser.is_root_of_model(item):
self._show_server_menu(item)
else:
self._show_item_menu(item)
def _show_server_menu(self, item: FileBrowserItem):
if not self._server_menu:
self._server_menu = ui.Menu("server-menu")
self._server_menu.clear()
with self._server_menu:
ui.MenuItem("Connection Menu")
self._server_menu.show()
def _show_item_menu(self, item: FileBrowserItem):
if not self._item_menu:
self._item_menu = ui.Menu("item-menu")
self._item_menu.clear()
with self._item_menu:
ui.MenuItem("Item Info")
ui.Separator()
ui.MenuItem(item.name)
ui.MenuItem(item.path)
self._item_menu.show()
def _refresh_ui(self, item: FileBrowserItem = None):
if self._filebrowser:
self._filebrowser.refresh_ui(item)
# ---------------------------------------------- Event Handlers ----------------------------------------------
async def _dock_window(self, window_title: str, position: ui.DockPosition, ratio: float = 1.0):
frames = 3
while frames > 0:
if ui.Workspace.get_window(window_title):
break
frames = frames - 1
await omni.kit.app.get_app().next_update_async()
window = ui.Workspace.get_window(window_title)
dockspace = ui.Workspace.get_window("DockSpace")
if window and dockspace:
window.dock_in(dockspace, position, ratio=ratio)
window.dock_tab_bar_visible = False
async def _add_connection(self, name: str, path: str):
try:
await self._stat_path(path)
except Exception as e:
self._warn(f"{e}\n")
else:
if path.startswith("omniverse://"):
model_creator = NucleusModel
else:
model_creator = FileSystemModel
# Append the new model of desired server type
server = model_creator(name, path)
self._filebrowser.add_model_as_subtree(server)
self._refresh_ui()
async def _stat_path(self, path: str, timeout: int = 3.0) -> omni.client.ListEntry:
""" Returns stats for path if valid """
if not path:
return False, None
path = path.replace("\\", "/")
try:
result, stats = await asyncio.wait_for(omni.client.stat_async(path), timeout=timeout)
except asyncio.TimeoutError:
raise RuntimeWarning(f"Error unable to stat '{path}': Timed out after {timeout} secs.")
except Exception as e:
raise RuntimeWarning(f"Error unable to stat '{path}': {e}")
if result != omni.client.Result.OK:
raise RuntimeWarning(f"Error unable to stat '{path}': {result}")
return stats
if __name__ == "__main__":
window_flags = ui.WINDOW_FLAGS_NO_SCROLLBAR
window = ui.Window("DemoFileBrowser", width=1000, height=500, flags=window_flags)
with window.frame:
view = FileBrowserView("DemoFileBrowser")
view.build_ui()
|
omniverse-code/kit/exts/omni.kit.widget.filebrowser/config/extension.toml | [package]
title = "Kit FileBrowser Widget"
version = "2.3.10"
category = "Internal"
description = "Filebrowser embeddable widget"
authors = ["NVIDIA"]
slackids = ["UQY4RMR3N"]
repository = ""
keywords = ["kit", "ui"]
readme = "docs/README.md"
changelog = "docs/CHANGELOG.md"
preview_image = "data/preview.png"
icon = "data/icon.png"
[dependencies]
"omni.ui" = {}
"omni.client" = {}
[[python.module]]
name = "omni.kit.widget.filebrowser"
[[python.scriptFolder]]
path = "scripts"
[[test]]
args = [
"--/app/window/dpiScaleOverride=1.0",
"--/app/window/scaleToMonitor=false",
"--no-window"
]
[documentation]
pages = [
"docs/Overview.md",
"docs/CHANGELOG.md",
]
|
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/zoom_bar.py | # Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
__all__ = ["ZoomBar"]
import carb.settings
import omni.ui as ui
from .style import UI_STYLES, ICON_PATH
# key is scale level and value is the actual scale value
SCALE_MAP = {0: 0.25, 1: 0.5, 2: 0.75, 3: 1, 4: 1.5, 5: 2.0}
class ZoomBar:
def __init__(self, **kwargs):
self._show_grid_view = kwargs.get("show_grid_view", True)
self._grid_view_scale = kwargs.get("grid_view_scale", 2)
self._on_toggle_grid_view_fn = kwargs.get("on_toggle_grid_view_fn", None)
self._on_scale_grid_view_fn = kwargs.get("on_scale_grid_view_fn", None)
settings = carb.settings.get_settings()
theme = settings.get_as_string("/persistent/app/window/uiStyle") or "NvidiaDark"
self._theme = theme
self._style = UI_STYLES[theme]
self._slider = None
self._layout_button = None
self._build_ui()
# Notify any potential listeners registered through the "_on_toggle_grid_view_fn" argument that the view has
# been enabled in the initial state depicted by the resolved `self._show_grid_view` property:
self._toggle_grid_view(self._show_grid_view)
def destroy(self):
self._on_toggle_grid_view_fn = None
self._on_scale_grid_view_fn = None
self._slider = None
self._layout_button = None
def _build_ui(self):
with ui.HStack(height=0, style=self._style):
ui.Spacer()
with ui.ZStack(width=0, style=self._style, content_clipping=True):
ui.Rectangle(height=20, style_type_name_override="ZoomBar")
with ui.HStack():
ui.Spacer(width=6)
self._slider = ui.IntSlider(min=0, max=5, width=150, style=self._style["ZoomBar.Slider"])
self._slider.model.add_value_changed_fn(self._scale_grid_view)
self._layout_button = ui.Button(
image_url=self._get_layout_icon(not self._show_grid_view),
width=16,
style_type_name_override="ZoomBar.Button",
clicked_fn=lambda: self._toggle_grid_view(not self._show_grid_view),
)
ui.Spacer(width=6)
ui.Spacer(width=16)
def _get_layout_icon(self, grid_view: bool) -> str:
if grid_view:
return f"{ICON_PATH}/{self._theme}/thumbnail.svg"
else:
return f"{ICON_PATH}/{self._theme}/list.svg"
def _scale_grid_view(self, model: ui.SimpleIntModel):
scale_level = model.get_value_as_int()
scale = SCALE_MAP.get(scale_level, 2)
if self._on_scale_grid_view_fn:
self._on_scale_grid_view_fn(scale)
# If currently displaying the "Grid" View, remember the scale level so it can be rehabilitated later when
# toggling back from the "List" View, for which the scale level is set to `0`:
if self._show_grid_view:
self._grid_view_scale = scale_level
def _toggle_grid_view(self, show_grid_view: bool):
self._layout_button.image_url = self._get_layout_icon(not show_grid_view)
self._show_grid_view = show_grid_view
# If showing the "Grid" View, restore the scale level previously set. Showing the "List" View otherwise sets the
# scale level to `0`:
if show_grid_view:
self._slider.model.set_value(self._grid_view_scale)
else:
self._slider.model.set_value(0)
if self._on_toggle_grid_view_fn:
self._on_toggle_grid_view_fn(show_grid_view)
|
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/date_format_menu.py | # Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
__all__ = ["DatetimeFormatMenu"]
import omni.ui as ui
import carb.settings
import omni.kit.app
from typing import Callable
from functools import partial
DATETIME_FORMAT_SETTING = "/persistent/app/datetime/format"
DATETIME_FORMATS = [
"MM/DD/YYYY",
"DD.MM.YYYY",
"DD-MM-YYYY",
"YYYY-MM-DD",
"YYYY/MM/DD",
"YYYY.MM.DD"
]
class DatetimeFormatMenu:
def __init__(
self,
value_changed_fn: Callable=None,
):
self._menu = ui.Menu()
self._menu_items = {}
self._value_changed_fn = value_changed_fn
self._update_setting = omni.kit.app.SettingChangeSubscription(
DATETIME_FORMAT_SETTING,
self._on_datetime_format_changed,
)
with self._menu:
self._build_dateformat_items()
def _on_datetime_format_changed(self, item, event_type):
if event_type == carb.settings.ChangeEventType.CHANGED:
format = carb.settings.get_settings().get(DATETIME_FORMAT_SETTING)
menu_item = self._menu_items.get(format, None)
if menu_item:
for item in self._menu_items.values():
item.checked = False
menu_item.checked = True
if self._value_changed_fn:
self._value_changed_fn()
def _build_dateformat_items(self):
def set_datetime_format(owner, format, menu_item):
for item in owner._menu_items.values():
if item != menu_item:
item.checked = False
if menu_item.checked:
if format != carb.settings.get_settings().get(DATETIME_FORMAT_SETTING):
carb.settings.get_settings().set(DATETIME_FORMAT_SETTING, format)
for format in DATETIME_FORMATS:
menu_item = ui.MenuItem(
format,
checkable=True,
checked=False,
direction=ui.Direction.RIGHT_TO_LEFT
)
menu_item.set_triggered_fn(partial(set_datetime_format, self, format, menu_item))
if format == carb.settings.get_settings().get(DATETIME_FORMAT_SETTING):
menu_item.checked = True
self._menu_items[format] = menu_item
@property
def visible(self):
return self._menu.visible
@visible.setter
def visible(self, value: bool):
self._menu.visible = value
def show_at(self, x, y):
self._menu.show_at(x, y)
def destroy(self):
"""Destructor"""
self._menu = None
self._menu_items = None
self._update_setting = None
self._value_changed_fn = None
def get_datetime_format():
format = carb.settings.get_settings().get(DATETIME_FORMAT_SETTING)
if format not in DATETIME_FORMATS:
# if not valid format, using current system format
return "%x"
return format.replace("MM", "%m").replace("DD", "%d").replace("YYYY", "%Y")
|
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/view.py | # Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
"""
An abstract View class, subclassed by TreeView and GridView
"""
import asyncio
import threading
import omni.kit.app
from typing import Callable
from abc import abstractmethod
from .model import FileBrowserItem, FileBrowserModel
__all__ = ["FileBrowserView"]
class FileBrowserView:
def __init__(self, model: FileBrowserModel):
self._widget = None
self._visible = True
self._futures = []
# Setting the property to setup the subscription
self.model = model
self._loop = asyncio.get_event_loop()
# Enables thread-safe reads/writes to shared data
self._mutex_lock: threading.Lock = threading.Lock()
self._refresh_pending = False
@abstractmethod
def build_ui(self):
pass
@property
def model(self):
return self._model
@model.setter
def model(self, model):
self._model = model
if self._model:
self._model_subscription = self._model.subscribe_item_changed_fn(self._on_item_changed)
else:
self._model_subscription = None
self._on_model_changed(self._model)
@property
def visible(self):
return self._visible
@visible.setter
def visible(self, visible: bool):
if self._widget:
self._widget.visible = visible
self._visible = visible
def set_root(self, item: FileBrowserItem):
if self._model:
self._model.root = item
@abstractmethod
def refresh_ui(self, item: FileBrowserItem = None):
pass
def _throttled_refresh_ui(self, item: FileBrowserItem = None, callback: Callable = None, throttle_frames: int = 1):
"""
Refreshes the view. Delays the redraw to a later frame so that multiple calls to this function
are queued up and handled in one go. For example, when multiple files are copied to the current
directory, it will trigger a refresh for each file. If there are many of them, it could swamp
the render queue with unnecessary redraws. By queueing up these tasks, we can limit the redraws
to once per frame.
"""
if not self._visible:
return
self._futures = list(filter(lambda f: not f.done(), self._futures))
if threading.current_thread() is threading.main_thread():
future = asyncio.ensure_future(
self._throttled_refresh_ui_async(item, callback, throttle_frames))
else:
future = asyncio.run_coroutine_threadsafe(
self._throttled_refresh_ui_async(item, callback, throttle_frames), self._loop)
self._futures.append(future)
async def _throttled_refresh_ui_async(self, item: FileBrowserItem, callback: Callable, throttle_frames: int = 1):
# If there's already a pending redraw, then skip.
with self._mutex_lock:
if self._refresh_pending:
return
else:
self._refresh_pending = True
# NOTE: Wait a beat to absorb adjacent redraw events so that we build the grid only once.
for _ in range(throttle_frames):
await omni.kit.app.get_app().next_update_async()
if callback:
callback(item)
with self._mutex_lock:
self._refresh_pending = False
@abstractmethod
def select_and_center(self, item: FileBrowserItem):
pass
@abstractmethod
def _on_selection_changed(self, selections: [FileBrowserItem]):
pass
@abstractmethod
def destroy(self):
for future in self._futures:
future.cancel()
self._futures.clear()
self._loop = None
self._mutex_lock = None
self._refresh_pending = False
def _on_item_changed(self, model, item):
"""Called by the model when something is changed"""
pass
def _on_model_changed(self, model):
"""Called by the model when something is changed"""
pass
|
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/filesystem_model.py | # Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
__all__ = ["FileSystemItem", "FileSystemItemFactory", "FileSystemModel"]
import os
import stat
import asyncio
import omni.client
from datetime import datetime
from typing import Callable, Any
from omni import ui
from .model import FileBrowserItem, FileBrowserItemFields, FileBrowserModel
from .style import ICON_PATH
from carb import log_warn
class FileSystemItem(FileBrowserItem):
def __init__(self, path: str, fields: FileBrowserItemFields, is_folder: bool = False):
super().__init__(path, fields, is_folder=is_folder)
async def populate_async(self, callback_async: Callable, timeout: float = 10.0) -> Any:
"""
Populates current item asynchronously if not already. Overrides base method.
Args:
callback_async (Callable): Function signature is void callback(result, children: [FileBrowserItem]),
where result is an Exception type upon error.
timeout (float): Time out duration on failed server connections. Default 10.0.
Returns:
Any: Result of executing callback.
"""
result = None
if not self.populated:
if self.is_folder:
try:
with os.scandir(self.path) as it:
self.children.clear()
entries = {entry.name: entry for entry in it}
for name in sorted(entries):
entry = entries[name]
if not FileSystemItem.keep_entry(entry):
continue
self.add_child(FileSystemItemFactory.create_entry_item(entry))
except asyncio.CancelledError:
# NOTE: Return early if operation cancelled, without marking as 'populated'.
return None
except PermissionError as e:
log_warn(f"Can't list files. Permission denied for {self.path}")
result = e
except Exception as e:
result = e
# NOTE: Mark this item populated even when there's an error so we don't repeatedly try.
self.populated = True
if callback_async:
try:
return await callback_async(result, self.children)
except asyncio.CancelledError:
return None
else:
return result
def on_list_change_event(self, event: omni.client.ListEvent, entry: omni.client.ListEntry) -> bool:
"""
Handles ListEvent changes, should update this item's children list with the corresponding ListEntry.
Args:
event (:obj:`omni.client.ListEvent`): One of of {UNKNOWN, CREATED, UPDATED, DELETED, METADATA, LOCKED, UNLOCKED}.
entry (:obj:`omni.client.ListEntry`): Updated entry as defined by omni.client.
"""
if not entry:
return False
item_changed = False
child_name = entry.relative_path
child_name = child_name[:-1] if child_name.endswith("/") else child_name
full_path = f"{self.path}/{entry.relative_path}"
if event == omni.client.ListEvent.CREATED:
if not child_name in self.children:
item_changed = True
self.add_child(FileSystemItemFactory.create_omni_entry_item(entry, full_path))
elif event == omni.client.ListEvent.DELETED:
self.del_child(child_name)
item_changed = True
elif event == omni.client.ListEvent.UPDATED:
child = self.children.get(child_name)
if child:
# Update file size
size_model = child.get_subitem_model(2)
size_model.set_value(FileBrowserItem.size_as_string(entry.size))
return item_changed
@staticmethod
def keep_entry(entry: os.DirEntry) -> bool:
if os.name == "nt":
# On Windows, test for hidden directories & files
try:
file_attrs = entry.stat().st_file_attributes
except:
return False
if file_attrs & stat.FILE_ATTRIBUTE_SYSTEM:
return False
elif os.name == "posix":
if entry.is_symlink():
try:
entry.stat()
except:
# NOTE: What accounts for the return value here?
return False
return True
@property
def readable(self) -> bool:
return (self._fields.permissions & omni.client.AccessFlags.READ) > 0
@property
def writeable(self) -> bool:
return (self._fields.permissions & omni.client.AccessFlags.WRITE) > 0
class FileSystemItemFactory:
@staticmethod
def create_group_item(name: str, path: str) -> FileSystemItem:
if not name:
return None
access = omni.client.AccessFlags.READ | omni.client.AccessFlags.WRITE
fields = FileBrowserItemFields(name, datetime.now(), 0, access)
item = FileSystemItem(path, fields, is_folder=True)
item._models = (ui.SimpleStringModel(item.name), datetime.now(), ui.SimpleStringModel(""))
return item
@staticmethod
def create_entry_item(entry: os.DirEntry) -> FileSystemItem:
if not entry:
return None
modified_time = datetime.fromtimestamp(entry.stat().st_mtime)
stats = entry.stat()
# OM-73238 Translate system access flags to omni.client flags
access = 0
if entry.stat().st_mode & stat.S_IRUSR:
access |= omni.client.AccessFlags.READ
if entry.stat().st_mode & stat.S_IWUSR:
access |= omni.client.AccessFlags.WRITE
fields = FileBrowserItemFields(entry.name, modified_time, stats.st_size, access)
item = FileSystemItem(entry.path, fields, is_folder=entry.is_dir())
size_model = ui.SimpleStringModel(FileBrowserItem.size_as_string(entry.stat().st_size))
item._models = (ui.SimpleStringModel(item.name), modified_time, size_model)
return item
@staticmethod
def create_omni_entry_item(entry: omni.client.ListEntry, path: str) -> FileSystemItem:
if not entry:
return None
name = entry.relative_path
name = name[:-1] if name.endswith("/") else name
modified_time = entry.modified_time
fields = FileBrowserItemFields(name, modified_time, entry.size, entry.access)
is_folder = (entry.flags & omni.client.ItemFlags.CAN_HAVE_CHILDREN) > 0
item = FileSystemItem(path, fields, is_folder=is_folder)
size_model = ui.SimpleStringModel(FileBrowserItem.size_as_string(entry.size))
item._models = (ui.SimpleStringModel(item.name), modified_time, size_model)
return item
class FileSystemModel(FileBrowserModel):
"""
A Filebrowser model class for navigating a the local filesystem in a tree view. Sub-classed from
:obj:`FileBrowserModel`.
Args:
name (str): Name of root item..
root_path (str): Root path. If None, then create empty model. Default "C:".
Keyword Args:
drop_fn (Callable): Function called to handle drag-n-drops. Function signature:
void drop_fn(dst_item: :obj:`FileBrowserItem`, src_item: :obj:`FileBrowserItem`)
filter_fn (Callable): This handler should return True if the given tree view item is visible,
False otherwise. Function signature: bool filter_fn(item: :obj:`FileBrowserItem`)
sort_by_field (str): Name of column by which to sort items in the same folder. Default "name".
sort_ascending (bool): Sort in ascending order. Default True.
"""
def __init__(self, name: str, root_path: str = "C:", **kwargs):
import carb.settings
super().__init__(**kwargs)
if not root_path:
return
if not root_path.endswith("/"):
root_path += "/"
self._root = FileSystemItemFactory.create_group_item(name, root_path)
theme = carb.settings.get_settings().get_as_string("/persistent/app/window/uiStyle") or "NvidiaDark"
self._root.icon = f"{ICON_PATH}/{theme}/hdd.svg"
|
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/style.py | # Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
import omni.ui as ui
from pathlib import Path
CURRENT_PATH = Path(__file__).parent.absolute()
ICON_PATH = CURRENT_PATH.parent.parent.parent.parent.joinpath("icons")
THUMBNAIL_PATH = CURRENT_PATH.parent.parent.parent.parent.joinpath("data").joinpath("thumbnails")
UI_STYLES = {}
UI_STYLES["NvidiaLight"] = {
"Rectangle::Splitter": {"background_color": 0xFFE0E0E0, "margin_width": 2},
"Rectangle::Splitter:hovered": {"background_color": 0xFFB0703B},
"Rectangle::Splitter:pressed": {"background_color": 0xFFB0703B},
"Splitter": {"background_color": 0xFFE0E0E0, "margin_width": 2},
"TreeView": {
"background_color": 0xFF535354,
"background_selected_color": 0xFF6E6E6E,
"secondary_color": 0xFFACACAC,
},
"TreeView:hovered": {"background_color": 0xFF6E6E6E},
"TreeView:selected": {"background_color": 0xFFBEBBAE},
"TreeView.Column": {"background_color": 0x0, "color": 0xFFD6D6D6, "margin": 0},
"TreeView.Header": {
"background_color": 0xFF535354,
"color": 0xFFD6D6D6,
"border_color": 0xFF707070,
"border_width": 0.5,
},
"TreeView.Header::name": {"margin": 3, "alignment": ui.Alignment.LEFT},
"TreeView.Header::date": {"margin": 3, "alignment": ui.Alignment.CENTER},
"TreeView.Header::size": {"margin": 3, "alignment": ui.Alignment.RIGHT},
"TreeView.Icon:selected": {"color": 0xFF535354},
"TreeView.Header.Icon": {"color": 0xFF8A8777},
"TreeView.Icon::default": {"color": 0xFF8A8777},
"TreeView.Icon::file": {"color": 0xFF8A8777},
"TreeView.Item": {"color": 0xFFD6D6D6},
"TreeView.Item:selected": {"color": 0xFF2A2825},
"TreeView.ScrollingFrame": {"background_color": 0xFF535354, "secondary_color": 0xFFE0E0E0},
"GridView.ScrollingFrame": {"background_color": 0xFF535354, "secondary_color": 0xFFE0E0E0},
"GridView.Grid": {"background_color": 0x0, "margin_width": 10},
"Card": {"background_color": 0x0, "margin": 8},
"Card:hovered": {"background_color": 0xFF6E6E6E, "border_color": 0xFF3A3A3A, "border_width": 0},
"Card:pressed": {"background_color": 0xFF6E6E6E, "border_color": 0xFF3A3A3A, "border_width": 0},
"Card:selected": {"background_color": 0xFFBEBBAE, "border_color": 0xFF8A8777, "border_width": 0},
"Card.Image": {
"background_color": 0xFFC9C9C9,
"color": 0xFFFFFFFF,
"corner_flag": ui.CornerFlag.TOP,
"alignment": ui.Alignment.CENTER,
"margin": 8,
},
"Card.Badge": {"background_color": 0xFFC9C9C9, "color": 0xFFFFFFFF},
"Card.Badge::shadow": {"background_color": 0xFFC9C9C9, "color": 0xDD444444},
"Card.Label": {
"background_color": 0xFFC9C9C9,
"color": 0xFFD6D6D6,
"font_size": 12,
"alignment": ui.Alignment.CENTER_TOP,
"margin_width": 8,
"margin_height": 2,
},
"Card.Label:checked": {"color": 0xFF23211F},
"ZoomBar": {"background_color": 0x0, "border_radius": 2},
"ZoomBar.Slider": {
"draw_mode": ui.SliderDrawMode.HANDLE,
"background_color": 0xFF23211F,
"secondary_color": 0xFF9D9D9D,
"color": 0x0,
"alignment": ui.Alignment.CENTER,
"padding": 0,
"margin": 5,
"font_size": 8,
},
"ZoomBar.Button": {"background_color": 0x0, "margin": 0, "padding": 0},
"ZoomBar.Button.Image": {"color": 0xFFFFFFFF, "alignment": ui.Alignment.CENTER},
"Recycle.Button.Label": {"color": 0xFF9E9E9E, "alignment": ui.Alignment.LEFT_CENTER},
"Recycle.Button.Image": {"image_url": "resources/glyphs/trash.svg", "background_color": 0xFF535354, "alignment": ui.Alignment.CENTER},
"Recycle.Button:hovered": {"background_color": 0xFF3A3A3A},
"RecycleFrame.Button": {"background_color": 0xFF23211F, "margin": 0, "padding": 0},
"RecycleFrame.Button:hovered": {"background_color": 0xFF3A3A3A},
"RecycleFrame.Button:checked": {"background_color": 0xFF3A3A3A},
}
UI_STYLES["NvidiaDark"] = {
"Splitter": {"background_color": 0x0, "margin_width": 0},
"Splitter:hovered": {"background_color": 0xFFB0703B},
"Splitter:pressed": {"background_color": 0xFFB0703B},
"TreeView.ScrollingFrame": {"background_color": 0xFF23211F},
"TreeView": {"background_color": 0xFF23211F, "background_selected_color": 0x663A3A3A},
"TreeView:selected": {"background_color": 0xFF8A8777},
"TreeView.Column": {"background_color": 0x0, "color": 0xFFADAC9F, "margin": 0},
"TreeView.Header": {"background_color": 0xFF343432, "color": 0xFF9E9E9E},
"TreeView.Icon": {"color": 0xFFFFFFFF, "padding": 0},
"TreeView.Icon::Cut": {"background_color": 0x0, "color": 0x88FFFFFF},
"TreeView.Icon::Cut:selected": {"background_color": 0x0, "color": 0x88FFFFFF},
"TreeView.Icon::shadow": {"background_color": 0x0, "color": 0xDD444444},
"TreeView.Icon::expand": {"color": 0xFFFFFFFF},
"TreeView.Icon:selected": {"color": 0xFFFFFFFF},
"TreeView.Item": {"color": 0xFF9E9E9E, "alignment": ui.Alignment.LEFT_CENTER},
"TreeView.Item:selected": {"color": 0xFF2A2825},
"TreeView.Item::Cut": {"color": 0x889E9E9E, "alignment": ui.Alignment.LEFT_CENTER},
"TreeView.Item::Cut:selected": {"color": 0x882A2825},
"GridView.ScrollingFrame": {"background_color": 0xFF23211F},
"GridView.Grid": {"background_color": 0x0, "margin_width": 10},
"Card": {"background_color": 0x0, "margin": 8},
"Card:hovered": {"background_color": 0xFF3A3A3A, "border_color": 0xFF3A3A3A, "border_width": 2},
"Card:pressed": {"background_color": 0xFF3A3A3A, "border_color": 0xFF42413F, "border_width": 2},
"Card:selected": {"background_color": 0xFF8A8777, "border_color": 0xFF8A8777, "border_width": 2},
"Card.Image": {
"background_color": 0x0,
"color": 0xFFFFFFFF,
"corner_flag": ui.CornerFlag.TOP,
"alignment": ui.Alignment.CENTER,
"margin": 8,
},
"Card.Image::Cut": {"color": 0x88FFFFFF},
"Card.Badge": {"background_color": 0x0, "color": 0xFFFFFFFF},
"Card.Badge::shadow": {"background_color": 0x0, "color": 0xDD444444},
"Card.Label": {
"background_color": 0x0,
"color": 0xFF9E9E9E,
"alignment": ui.Alignment.CENTER_TOP,
"margin_width": 8,
"margin_height": 2,
},
"Card.Label::Cut": {"color": 0x889E9E9E},
"Card.Label:checked": {"color": 0xFF23211F},
"Card.Label::Cut:checked": {"color": 0x8823211F},
"ZoomBar": {"background_color": 0xFF454545, "border_radius": 2},
"ZoomBar.Slider": {
"draw_mode": ui.SliderDrawMode.HANDLE,
"background_color": 0xDD23211F,
"secondary_color": 0xFF9E9E9E,
"color": 0x0,
"alignment": ui.Alignment.CENTER,
"padding": 0,
"margin": 3,
},
"ZoomBar.Button": {"background_color": 0x0, "margin": 0, "padding": 0},
"ZoomBar.Button.Image": {"color": 0xFFFFFFFF, "alignment": ui.Alignment.CENTER},
"Recycle.Button.Label": {"color": 0xFF9E9E9E, "alignment": ui.Alignment.LEFT_CENTER},
"Recycle.Button": {"background_color": 0x0, "margin": 0, "padding": 0},
"Recycle.Button.Image": {"image_url": "resources/glyphs/trash.svg","background_color": 0x0, "color": 0xFF9E9E9E, "alignment": ui.Alignment.CENTER},
"Recycle.Button.Image:hovered": {"background_color": 0x0,"color": 0xFFFFFFFF},
"Recycle.Button.Image:checked": {"background_color": 0x0,"color": 0xFFFFFFFF},
"Recycle.Rectangle": {"background_color": 0xFF23211F, "margin": 0, "padding": 0},
"RecycleFrame.Button": {"background_color": 0x0, "margin": 0, "padding": 0},
"RecycleFrame.Button:hovered": {"background_color": 0xFF3A3A3A},
"RecycleFrame.Button:checked": {"background_color": 0xFF3A3A3A},
"RecycleFrame.Button.Label": {"alignment": ui.Alignment.LEFT},
"RecycleView.Frame": {"background_color": 0x0},
}
|
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/tree_view.py | # Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
"""
A generic Tree View Widget for File Systems
"""
import asyncio
import carb
from omni import ui
from typing import List
from typing import Tuple
from functools import partial
from datetime import datetime
from carb import log_warn
from .view import FileBrowserView
from .model import FileBrowserItem, FileBrowserItemFields, FileBrowserModel
from .style import UI_STYLES, ICON_PATH
from .abstract_column_delegate import ColumnItem
from .column_delegate_registry import ColumnDelegateRegistry
from .date_format_menu import DatetimeFormatMenu
from . import ALERT_WARNING, ALERT_ERROR
from .clipboard import is_path_cut
__all__ = ["AwaitWithFrame", "FileBrowserTreeView", "FileBrowserTreeViewDelegate"]
class AwaitWithFrame:
"""
A future-like object that runs the given future and makes sure it's
always in the given frame's scope. It allows for creating widgets
asynchronously.
"""
def __init__(self, frame: ui.Frame, future: asyncio.Future):
self._frame = frame
self._future = future
def __await__(self):
# create an iterator object from that iterable
iter_obj = iter(self._future.__await__())
# infinite loop
while True:
try:
with self._frame:
yield next(iter_obj)
except StopIteration:
break
except Exception as e:
log_warn(f"Error rendering frame: {str(e)}")
break
self._frame = None
self._future = None
class FileBrowserTreeView(FileBrowserView):
def __init__(self, model: FileBrowserModel, **kwargs):
import carb.settings
self._tree_view = None
self._delegate = None
super().__init__(model)
self._headers = FileBrowserItemFields._fields
theme = carb.settings.get_settings().get_as_string("/persistent/app/window/uiStyle") or "NvidiaDark"
use_default_style = carb.settings.get_settings().get_as_string("/persistent/app/window/useDefaultStyle") or False
if use_default_style:
self._style = {}
else:
self._style = UI_STYLES[theme]
self._root_visible = kwargs.get("root_visible", True)
self._header_visible = kwargs.get("header_visible", True)
self._allow_multi_selection = kwargs.get("allow_multi_selection", True)
self._selection_changed_fn = kwargs.get("selection_changed_fn", None)
self._mouse_pressed_fn = kwargs.get("mouse_pressed_fn", None)
self._mouse_double_clicked_fn = kwargs.get("mouse_double_clicked_fn", None)
self._treeview_identifier = kwargs.get('treeview_identifier', None)
# Callback when the tag registry is changed
self._column_delegate_sub = ColumnDelegateRegistry().subscribe_delegate_changed(
self._on_column_delegate_changed
)
kwargs["mouse_pressed_fn"] = self._on_mouse_pressed
kwargs["mouse_double_clicked_fn"] = self._on_mouse_double_clicked
kwargs["column_clicked_fn"] = lambda column_id: self._on_column_clicked(column_id)
kwargs["datetime_format_changed_fn"] = self._on_datetime_format_changed
kwargs["sort_by_column"] = self._headers.index(self._model.sort_by_field)
kwargs["sort_ascending"] = self._model.sort_ascending
kwargs["builtin_column_count"] = self._model.builtin_column_count
self._delegate = FileBrowserTreeViewDelegate(self._headers, theme, **kwargs)
self._widget = ui.ScrollingFrame(
horizontal_scrollbar_policy=ui.ScrollBarPolicy.SCROLLBAR_ALWAYS_OFF,
vertical_scrollbar_policy=ui.ScrollBarPolicy.SCROLLBAR_AS_NEEDED,
mouse_pressed_fn=partial(self._on_mouse_pressed, None),
mouse_double_clicked_fn=partial(self._on_mouse_double_clicked, None),
style_type_name_override="TreeView.ScrollingFrame",
)
def build_ui(self):
# Tree View
with self._widget:
selection_changed_fn = lambda selections: self._on_selection_changed(selections)
self._tree_view = ui.TreeView(
self._model,
delegate=self._delegate,
root_visible=self._root_visible,
header_visible=self._header_visible,
selection_changed_fn=selection_changed_fn,
columns_resizable=True,
)
if self._treeview_identifier:
self._tree_view.identifier = self._treeview_identifier
# It should set the column widths and pass tag delegated to the main delegate
self._on_column_delegate_changed()
@property
def tree_view(self):
return self._tree_view
@property
def selections(self):
if self._tree_view:
return self._tree_view.selection
return []
def refresh_ui(self, item: FileBrowserItem = None):
"""Throttle the refreshes so that the UI can keep up with multiple refresh directives in succession."""
def update_view(item: FileBrowserItem):
if self._tree_view:
self._tree_view.dirty_widgets()
if self._model:
# NOTE: The following action is not publicized but is required for a proper redraw
self._model._item_changed(item)
self._throttled_refresh_ui(item=item, callback=update_view, throttle_frames=2)
def is_expanded(self, item: FileBrowserItem) -> bool:
if self._tree_view and item:
return self._tree_view.is_expanded(item)
return False
def set_expanded(self, item: FileBrowserItem, expanded: bool, recursive: bool = False):
"""
Sets the expansion state of the given item.
Args:
item (:obj:`FileBrowserItem`): The item to effect.
expanded (bool): True to expand, False to collapse.
recursive (bool): Apply state recursively to descendent nodes. Default False.
"""
if self._tree_view and item:
self._tree_view.set_expanded(item, expanded, recursive)
def select_and_center(self, item: FileBrowserItem):
if not self._visible:
return
item = item or self._model.root
if not item:
return
def set_expanded_recursive(item: FileBrowserItem):
if not item:
return
set_expanded_recursive(item.parent)
self.set_expanded(item, True)
set_expanded_recursive(item)
self._tree_view.selection = [item]
self.refresh_ui()
def _on_mouse_pressed(self, item: FileBrowserItem, x, y, button, key_mod):
if self._mouse_pressed_fn:
self._mouse_pressed_fn(button, key_mod, item, x=x, y=y)
def _on_mouse_double_clicked(self, item: FileBrowserItem, x, y, button, key_mod):
if self._mouse_double_clicked_fn:
self._mouse_double_clicked_fn(button, key_mod, item, x=x, y=y)
def _on_selection_changed(self, selections: [FileBrowserItem]):
if not self._allow_multi_selection:
if selections:
selections = selections[-1:]
self._tree_view.selection = selections
if self._model:
self._model.drag_mime_data = [sel.path for sel in selections]
if self._selection_changed_fn:
self._selection_changed_fn(selections)
def _on_column_clicked(self, column_id: int):
column_id = min(column_id, len(FileBrowserItemFields._fields) - 1)
if column_id == self._delegate.sort_by_column:
self._delegate.sort_ascending = not self._delegate.sort_ascending
else:
self._delegate.sort_by_column = column_id
if self._model:
self._model.sort_by_field = self._headers[column_id]
self._model.sort_ascending = self._delegate.sort_ascending
self.refresh_ui()
def _on_datetime_format_changed(self):
self.refresh_ui()
def _on_item_changed(self, model, item):
"""Called by the model when something is changed"""
if self._delegate and item is None:
self._delegate.clear_futures()
def _on_model_changed(self, model):
"""Called by super when the model is changed"""
if model and self._tree_view:
self._tree_view.model = model
if self._delegate:
self._delegate.clear_futures()
def _on_column_delegate_changed(self):
"""Called by ColumnDelegateRegistry"""
# Single column should fill all available space
if not self._model.single_column:
column_delegate_names = ColumnDelegateRegistry().get_column_delegate_names()
column_delegate_types = [ColumnDelegateRegistry().get_column_delegate(name) for name in column_delegate_names]
# Create the tag delegates
column_delegates = [delegate_type() for delegate_type in column_delegate_types]
self._delegate.set_column_delegates(column_delegates)
# Set column widths
# OM-30768: Make file-name dominant and push with left list view separator
self._tree_view.column_widths = [ui.Fraction(.75), ui.Fraction(0.15), ui.Fraction(0.1)] + [
d.initial_width for d in column_delegates
]
else:
self._tree_view.column_widths = [ui.Fraction(1)]
# Update the widget
self._model._item_changed(None)
def scroll_top(self):
"""Scrolls the widget to top"""
if self._widget:
# Scroll to top upon refresh
self._widget.scroll_y = 0.0
def destroy(self):
super().destroy()
if self._model:
self._model.destroy()
self._model = None
if self._tree_view:
self._tree_view.destroy()
self._tree_view = None
if self._widget:
self._widget.destroy()
self._widget = None
if self._delegate:
self._delegate.destroy()
self._delegate = None
self._headers = None
self._style = None
self._selection_changed_fn = None
self._mouse_pressed_fn = None
self._mouse_double_clicked_fn = None
self._column_delegate_sub = None
class FileBrowserTreeViewDelegate(ui.AbstractItemDelegate):
def __init__(self, headers: Tuple, theme: str, **kwargs):
super().__init__()
self._headers = headers
self._theme = theme
use_default_style = carb.settings.get_settings().get_as_string("/persistent/app/window/useDefaultStyle") or False
if use_default_style:
self._style = {}
else:
self._style = UI_STYLES[theme]
self._hide_files = not kwargs.get("files_visible", True)
self._tooltip = kwargs.get("tooltip", False)
self._mouse_pressed_fn = kwargs.get("mouse_pressed_fn", None)
self._mouse_double_clicked_fn = kwargs.get("mouse_double_clicked_fn", None)
self._column_clicked_fn = kwargs.get("column_clicked_fn", None)
self._datetime_format_changed_fn = kwargs.get("datetime_format_changed_fn", None)
self._sort_by_column = kwargs.get("sort_by_column", 0)
self._sort_ascending = kwargs.get("sort_ascending", True)
self._builtin_column_count = kwargs.get("builtin_column_count", 1)
self._column_delegates = []
self._icon_provider = kwargs.get("icon_provider", None)
# The futures that are created by column delegates. We need to store
# them to cancel when the model is changed.
self._column_futures: List["Future"] = []
self._date_format_menu = None
def destroy(self):
self.clear_futures()
self._headers = None
self._style = None
self._mouse_pressed_fn = None
self._mouse_double_clicked_fn = None
self._column_clicked_fn = None
self._column_delegates = None
self._icon_provider = None
if self._date_format_menu:
self._date_format_menu.destroy()
self._date_format_menu = None
def clear_futures(self):
"""Stop and destroy all working futures"""
for future in self._column_futures:
if not future.done():
future.cancel()
self._column_futures = []
@property
def sort_by_column(self) -> int:
return self._sort_by_column
@sort_by_column.setter
def sort_by_column(self, column_id: int):
self._sort_by_column = column_id
@property
def sort_ascending(self) -> bool:
return self._sort_ascending
@sort_ascending.setter
def sort_ascending(self, value: bool):
self._sort_ascending = value
def _on_date_format_clicked(self):
if not self._date_format_menu:
self._date_format_menu = DatetimeFormatMenu(self._datetime_format_changed_fn)
self._date_format_menu.visible = True
self._date_format_menu.show_at(
self._date_format_button.screen_position_x,
self._date_format_button.screen_position_y+30
)
def build_header(self, column_id: int):
if column_id >= self._builtin_column_count:
# Additional columns from the extensions.
self._column_delegates[column_id - self._builtin_column_count].build_header()
return
def on_column_clicked(column_id):
if self._column_clicked_fn:
self._column_clicked_fn(column_id)
with ui.ZStack(style=self._style):
with ui.HStack():
ui.Spacer(width=4)
ui.Label(self._headers[column_id].capitalize(), height=20, style_type_name_override="TreeView.Header")
# Invisible click area fills entire header frame
if self._headers[column_id] == "date":
with ui.HStack():
button = ui.Button(" ", height=20, style_type_name_override="TreeView.Column")
self._date_format_button = ui.Button(" ", width=30, height=20, style_type_name_override="TreeView.Column")
self._date_format_button.set_clicked_fn(lambda: self._on_date_format_clicked())
else:
button = ui.Button(" ", height=20, style_type_name_override="TreeView.Column")
if column_id == self._sort_by_column:
with ui.HStack():
ui.Spacer()
icon = (
f"{ICON_PATH}/{self._theme}/arrow_up.svg"
if self._sort_ascending
else f"{ICON_PATH}/{self._theme}/arrow_down.svg"
)
ui.ImageWithProvider(icon, width=30, style_type_name_override="TreeView.Column")
if self._headers[column_id] == "date":
icon_date = (
f"{ICON_PATH}/{self._theme}/date_format.svg"
)
ui.ImageWithProvider(icon_date, width=30, style_type_name_override="TreeView.Column")
elif self._headers[column_id] == "date":
with ui.HStack():
ui.Spacer()
icon_date = (
f"{ICON_PATH}/{self._theme}/date_format.svg"
)
ui.ImageWithProvider(icon_date, width=30, style_type_name_override="TreeView.Column")
button.set_clicked_fn(lambda: on_column_clicked(column_id))
def build_branch(self, model: FileBrowserModel, item: FileBrowserItem, column_id: int, level: int, expanded: bool):
"""Create a branch widget that opens or closes subtree"""
def get_branch_icon(item: FileBrowserItem, expanded: bool) -> Tuple[str, str]:
icon = "minus.svg" if expanded else "plus.svg"
tooltip = ""
if item.alert:
sev, tooltip = item.alert
if sev == ALERT_WARNING:
icon = "warn.svg"
elif sev == ALERT_ERROR:
icon = "error.svg"
else:
icon = "info.svg"
return f"{ICON_PATH}/{self._theme}/{icon}", tooltip
item_or_root = item or model.root
if not item_or_root or not isinstance(item_or_root, FileBrowserItem):
# Makes sure item has expected type, else may crash the process (See OM-34661).
return
if column_id == 0:
with ui.HStack(width=20 * (level + 1), height=0):
ui.Spacer()
# don't create branch icon for unexpandable items
if item_or_root.is_folder and item_or_root.expandable:
# Draw the +/- icon
icon, tooltip = get_branch_icon(item_or_root, expanded)
ui.ImageWithProvider(
icon, tooltip=tooltip, name="expand", width=10, height=10, style_type_name_override="TreeView.Icon"
)
def build_widget(self, model: FileBrowserModel, item: FileBrowserItem, column_id: int, level: int, expanded: bool):
"""Create a widget per item"""
item_or_root = item or model.root
if not item_or_root or not isinstance(item_or_root, FileBrowserItem):
# Makes sure item has expected type, else may crash the process (See OM-34661).
return
if column_id >= self._builtin_column_count:
# Additional columns from the extensions.
# Async run the delegate. The widget can be created later.
future = self._column_delegates[column_id - self._builtin_column_count].build_widget(
ColumnItem(item_or_root.path)
)
self._column_futures.append(asyncio.ensure_future(AwaitWithFrame(ui.Frame(), future)))
return
if self._hide_files and not item_or_root.is_folder and item_or_root.hideable:
# Don't show file items
return
value_model = model.get_item_value_model(item_or_root, column_id)
if not value_model:
return
style_variant = self._get_style_variant(item_or_root)
# File Name Column
if column_id == 0:
def mouse_pressed_fn(item: FileBrowserItem, *args):
if self._mouse_pressed_fn:
self._mouse_pressed_fn(item, *args)
def mouse_double_clicked_fn(item: FileBrowserItem, *args):
if self._mouse_double_clicked_fn:
self._mouse_double_clicked_fn(item, *args)
with ui.HStack(height=20,
mouse_pressed_fn=partial(mouse_pressed_fn, item_or_root),
mouse_double_clicked_fn=partial(mouse_double_clicked_fn, item_or_root)):
ui.Spacer(width=2)
self._draw_item_icon(item_or_root, expanded)
ui.Spacer(width=5)
ui.Label(
value_model.get_value_as_string(),
tooltip=item_or_root.path if self._tooltip else "",
tooltip_offset=22,
style_type_name_override="TreeView.Item",
name=style_variant,
)
# Date Column
elif column_id == 1:
with ui.HStack():
ui.Spacer(width=4)
if isinstance(value_model, datetime):
ui.Label(
FileBrowserItem.datetime_as_string(value_model),
style_type_name_override="TreeView.Item", name=style_variant)
elif isinstance(value_model, str):
ui.Label(value_model.get_value_as_string(), style_type_name_override="TreeView.Item", name=style_variant)
# Size Column
elif column_id == 2:
if not item_or_root.is_folder:
with ui.HStack():
ui.Spacer(width=4)
ui.Label(value_model.get_value_as_string(), style_type_name_override="TreeView.Item", name=style_variant)
def set_column_delegates(self, delegates):
"""Add custom columns"""
self._column_delegates = delegates
def _get_style_variant(self, item: FileBrowserItem):
return "Cut" if is_path_cut(item.path) else ""
def _draw_item_icon(self, item: FileBrowserItem, expanded: bool):
if not item:
return
style_variant = self._get_style_variant(item)
icon = item.icon
if not icon and self._icon_provider:
icon = self._icon_provider(item, expanded)
if not icon:
if item and not item.is_folder:
icon = f"{ICON_PATH}/{self._theme}/file.svg"
else:
icon = (
f"{ICON_PATH}/{self._theme}/folder_open.svg"
if expanded
else f"{ICON_PATH}/{self._theme}/folder.svg"
)
with ui.ZStack(width=0):
if icon:
# Draw the icon
with ui.HStack():
ui.Spacer(width=4)
ui.ImageWithProvider(icon, width=18, height=18, style_type_name_override="TreeView.Icon", name=style_variant)
if not item.writeable:
# Draw the lock
lock_icon = f"{ICON_PATH}/{self._theme}/lock.svg"
with ui.Placer(stable_size=True, offset_x=-1, offset_y=1):
with ui.HStack():
ui.ImageWithProvider(lock_icon, width=17, height=17, style_type_name_override="TreeView.Icon", name="shadow")
ui.Spacer()
with ui.Placer(stable_size=True, offset_x=-2, offset_y=1):
with ui.HStack():
ui.ImageWithProvider(lock_icon, width=17, height=17, style_type_name_override="TreeView.Icon", name=style_variant)
ui.Spacer()
|
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/grid_view.py | # Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
"""
A generic GridView Widget for File Systems
"""
__all__ = ["FileBrowserGridView", "FileBrowserGridViewDelegate"]
import asyncio
import carb
import omni.kit.app
from typing import Dict, List, Optional, Callable
from functools import partial
from omni import ui
from carb import events, log_warn
from carb.input import KEYBOARD_MODIFIER_FLAG_CONTROL, KEYBOARD_MODIFIER_FLAG_SHIFT
from .view import FileBrowserView
from .model import FileBrowserItem, FileBrowserModel, FileBrowserUdimItem
from .style import UI_STYLES
from .card import FileBrowserItemCard
from .thumbnails import find_thumbnails_for_files_async
from . import THUMBNAILS_GENERATED_EVENT
from .clipboard import is_path_cut
class FileBrowserGridView(FileBrowserView):
def __init__(self, model: FileBrowserModel, **kwargs):
self._delegate = None
super().__init__(model)
theme = carb.settings.get_settings().get_as_string("/persistent/app/window/uiStyle") or "NvidiaDark"
use_default_style = carb.settings.get_settings().get_as_string("/persistent/app/window/useDefaultStyle") or False
if use_default_style:
self._style = {}
else:
self._style = UI_STYLES[theme]
self._allow_multi_selection = kwargs.get("allow_multi_selection", True)
self._selection_changed_fn = kwargs.get("selection_changed_fn", None)
self._widget = ui.ScrollingFrame(
horizontal_scrollbar_policy=ui.ScrollBarPolicy.SCROLLBAR_ALWAYS_OFF,
vertical_scrollbar_policy=ui.ScrollBarPolicy.SCROLLBAR_AS_NEEDED,
style_type_name_override="GridView.ScrollingFrame",
)
self._delegate = FileBrowserGridViewDelegate(self._widget, theme, **kwargs)
self.build_ui()
@property
def selections(self):
if self._delegate:
return self._delegate.selections
return []
@selections.setter
def selections(self, selections):
if self._delegate:
self._delegate.selections = selections or []
def build_ui(self, restore_selections: Optional[List[FileBrowserItem]] = None):
if self._delegate:
self._delegate.build_grid(self.model)
self.refresh_ui(selections=restore_selections)
def scale_view(self, scale: float):
if self._delegate:
self._delegate.scale = scale
def refresh_ui(self, item: Optional[FileBrowserItem] = None, selections: Optional[List[FileBrowserItem]] = None):
"""Throttle the refreshes so that the UI can keep up with multiple refresh directives in succession."""
if not self._delegate:
return
def apply_selections(selections):
self.selections = selections
def refresh_ui_callback(selections):
self._delegate.update_grid(self.model)
# OM-70157: Switching between List/different Grid View sizes shouldn't reset user selections
if selections:
self.select_and_center(selections[0], callback=lambda _: apply_selections(selections))
self._throttled_refresh_ui(
item=item,
callback=lambda _: refresh_ui_callback(selections),
throttle_frames=2)
def select_and_center(self, item: FileBrowserItem, callback: Optional[Callable[[FileBrowserItem], None]] = None):
if not self._visible or not item:
return
self.selections = [item]
# OM-70154: add the ability to center the selected item in file browser grid view
# calculate the scroll ratio by item index
items = self.model.get_item_children(None)
# This should not happen, but add it here as a fail-safe
if item not in items:
carb.log_warn(f"Failed to select and center item [ {item.path} ] in file browser grid view.")
return
item_index = items.index(item)
scroll_ratio = float((item_index + 1) / len(items))
asyncio.ensure_future(
self._delegate.center_selection_async(
item, scroll_frame=self._widget, scroll_ratio=scroll_ratio, refresh_interval=3, callback=callback))
def _on_selection_changed(self, selections: List[FileBrowserItem]):
if not self._allow_multi_selection:
if selections:
selections = selections[-1:]
self._widget.selection = selections
if self._selection_changed_fn:
self._selection_changed_fn(selections)
def _on_item_changed(self, model, _):
self.refresh_ui()
def _on_model_changed(self, model):
"""Called by super when the model is changed"""
self.build_ui()
def scroll_top(self):
"""Scrolls the widget to top"""
# Scroll to top upon refresh
self._widget.scroll_y = 0.0
def destroy(self):
super().destroy()
if self._delegate:
self._delegate.destroy()
self._delegate = None
if self._widget:
self._widget.destroy()
self._widget = None
self._style = None
self._selection_changed_fn = None
class FileBrowserGridViewDelegate:
def __init__(self, widget: ui.Widget, theme: str, **kwargs):
self._widget: ui.Widget = widget
self._grid: ui.VGrid = None
self._cards: Dict[str, FileBrowserItemCard] = {}
self._card_paths: List[str] = []
self._custom_thumbnails: Dict[str, str] = {}
self._selections = []
self._pending_selections = []
self._style = UI_STYLES[theme]
self._tooltip = kwargs.get("tooltip", False)
self._mouse_pressed_fn = kwargs.get("mouse_pressed_fn", None)
self._mouse_double_clicked_fn = kwargs.get("mouse_double_clicked_fn", None)
self._selection_changed_fn = kwargs.get("selection_changed_fn", None)
self._drop_fn = kwargs.get("drop_fn", None)
self._thumbnail_provider = kwargs.get("thumbnail_provider", None)
self._badges_provider = kwargs.get("badges_provider", None)
self._treeview_identifier = kwargs.get("treeview_identifier", None)
self._testing = kwargs.get("testing", False)
self._card_width = 120
self._card_height = 120
self._scale = 1
self._update_grid_future = None
self._thumbnails_generated_subscription = None
self._was_dragging = False
# Monitor for new thumbnails being generated
event_stream = omni.kit.app.get_app().get_message_bus_event_stream()
self._thumbnails_generated_subscription = event_stream.create_subscription_to_pop_by_type(
THUMBNAILS_GENERATED_EVENT, self.update_cards_on_thumbnails_generated, name="filebrowser grid_view")
@property
def scale(self) -> float:
return self._scale
@scale.setter
def scale(self, scale: float):
self._scale = scale
@property
def selections(self) -> List[FileBrowserItem]:
return [card.item for card in self._selections]
@selections.setter
def selections(self, selections: List[FileBrowserItem]):
self._pending_selections = []
if self._cards:
# grid been build, set selection
cards = [self._cards[item.path] for item in selections if item.path in self._cards]
self.clear_selections()
self.extend_selections(cards)
else:
# grid has not been build yet, set pending_selection
self._pending_selections = selections
def build_grid(self, model: FileBrowserModel):
self.clear_selections()
for _, card in self._cards.items():
card.destroy()
self._cards.clear()
self._card_paths.clear()
with self._widget:
with ui.ZStack():
with ui.VStack():
if self._grid:
self._grid = None
self._grid = ui.VGrid(
column_width=self._scale * self._card_width,
row_height=self._scale * self._card_height + 20,
mouse_pressed_fn=partial(self._on_mouse_pressed, model, None),
mouse_double_clicked_fn=partial(self._on_mouse_double_clicked, None),
style_type_name_override="GridView.Grid",
content_clipping=True,
)
if self._treeview_identifier:
self._grid.identifier = self._treeview_identifier
ui.Spacer(height=30)
# OM-70157: Since we cannot clip the mouse event for the button in Zoombar for the VGrid, we have to add a invisibleButton here, whose clicked_fn
# will not be triggered if the ZoomBar switch layout button is on top of it; this way it will not clear out the selections when the user click
# on the layout switch button when it is on top of the VGrid.
def grid_clicked(*args, **kwargs):
self._on_mouse_released(model, None, None, None, 0, 0)
ui.InvisibleButton(clicked_fn=grid_clicked)
def update_grid(self, model: FileBrowserModel):
"""Generates a grid of cards and renders them with custom thumbnails"""
if not self._grid:
return
if model:
children = model.get_item_children(None)
else:
return
# make sure the grid not rebuild more than once
rebuilt_grid = False
for path in self._cards:
# If items got deleted then re-build the grid
if path not in [c.path for c in children]:
self.build_grid(model)
rebuilt_grid = True
break
# update card style if path in cut clipboard
if is_path_cut(path):
self._cards[path].apply_cut_style()
else:
self._cards[path].remove_cut_style()
for item in children:
# Add cards for any new children
if item.item_changed :
item.item_changed = False
if not rebuilt_grid:
self.build_grid(model)
rebuilt_grid = True
with self._grid:
for item in children:
# Add cards for any new children
# OM-91073: check paths to prevent build card more than once in sometimes
# not use the self._cards because it not create immediately in frame's build_fn
# so we need store and check the card path directly
if item.path in self._card_paths:
continue
def __build_card(file_item):
self._cards[file_item.path] = self.build_card(model, file_item)
self._card_paths.append(item.path)
if self._testing:
# In testing mode, forces cards to immediately be built and made available
with ui.Frame():
self._cards[item.path] = self.build_card(model, item)
else:
# OM-63433: Use content_clipping to speed up item display in file picker
ui.Frame(content_clipping=True, build_fn=lambda i=item: __build_card(i))
async def refresh_thumbnails(model: FileBrowserModel):
# Get custom thumbnails for parent folder and synchronously render them if they exist
if model and model.root:
self._custom_thumbnails = await model.root.get_custom_thumbnails_for_folder_async()
try:
await self.refresh_thumbnails_async(list(self._cards))
except asyncio.CancelledError:
return
# selections was set before cards created, update now
if self._pending_selections:
cards = [self._cards[item.path] for item in self._pending_selections if item.path in self._cards]
self._pending_selections = []
self.clear_selections()
self.extend_selections(cards)
# Store away future so that it can be cancelled, e.g. when switching directories
if self._update_grid_future and not self._update_grid_future.done():
self._update_grid_future.cancel()
self._update_grid_future = asyncio.ensure_future(refresh_thumbnails(model))
def update_cards_on_thumbnails_generated(self, event: events.IEvent):
"""When new thumbnails are generated, re-renders associated cards"""
if event.type != THUMBNAILS_GENERATED_EVENT:
return
try:
payload = event.payload.get_dict()
urls = payload.get('paths', [])
except Exception as e:
log_warn(f"Failed to retrieve payload from generated thumbnails event: {str(e)}")
return
async def refresh_thumbnails(urls: str):
# Get custom thumbnails for given urls. Don't try to generate (again) if not found.
self._custom_thumbnails.update(await find_thumbnails_for_files_async(urls, generate_missing=False))
try:
await self.refresh_thumbnails_async(urls)
except asyncio.CancelledError:
return
refresh_urls = [url for url in urls if url in self._cards]
if refresh_urls:
# Execute and forget
asyncio.ensure_future(refresh_thumbnails(refresh_urls))
def build_card(self, model: FileBrowserModel, item: FileBrowserItem) -> FileBrowserItemCard:
"""Create a widget per item"""
if not item:
return
if isinstance(item, FileBrowserUdimItem):
custom_thumbnail = self._custom_thumbnails.get(item.repr_path)
else:
custom_thumbnail = self._custom_thumbnails.get(item.path)
card = FileBrowserItemCard(
item,
width=self._scale * self._card_width,
height=self._scale * self._card_height,
mouse_pressed_fn=partial(self._on_mouse_pressed, model),
mouse_released_fn=partial(self._on_mouse_released, model),
mouse_double_clicked_fn=self._on_mouse_double_clicked,
drag_fn=self._on_drag,
drop_fn=self._drop_fn,
get_thumbnail_fn=self._thumbnail_provider,
get_badges_fn=self._badges_provider,
custom_thumbnail=custom_thumbnail,
timeout=model._timeout if model else 10.0,
)
return card
async def refresh_thumbnails_async(self, urls: str):
if not self._custom_thumbnails:
return
tasks = []
for url in urls:
card = self._cards.get(url, None)
item = card.item
if isinstance(item, FileBrowserUdimItem):
custom_thumbnail = self._custom_thumbnails.get(item.repr_path)
else:
custom_thumbnail = self._custom_thumbnails.get(item.path)
if card and custom_thumbnail:
tasks.append(card.refresh_thumbnail_async(custom_thumbnail))
if tasks:
try:
await asyncio.gather(*tasks, return_exceptions=True)
except Exception as e:
carb.log_error(f"Failed to refresh thumbnails: {e}")
except asyncio.CancelledError:
return
def _on_mouse_pressed(self, model: FileBrowserModel, card: FileBrowserItemCard, x, y, b, key_mod):
if self._mouse_pressed_fn:
self._mouse_pressed_fn(b, key_mod, card.item if card else None, x=x, y=y)
def _on_mouse_released(self, model: FileBrowserModel, card: FileBrowserItemCard, x, y, b, key_mod):
# Don't cancel selections
# FIXME: mouse release event will be triggered for both card and grid. It
# needs to check card to make sure mouse release event from grid will not influence selections.
if self._was_dragging:
if card:
self._was_dragging = False
return
if b == 0:
# Update selection list on left mouse clicks
if key_mod & KEYBOARD_MODIFIER_FLAG_CONTROL:
if card in self._selections:
self.remove_selection(card)
else:
self.add_selection(card)
elif key_mod & KEYBOARD_MODIFIER_FLAG_SHIFT:
if not self._selections:
self.add_selection(card)
elif card:
last_selection = self._selections[-1].item
current_selection = card.item
children = model.get_item_children(None)
# Note: Search items may re-generate frame to frame, so find by path rather than by object ref
last_selection_index = next((i for i, item in enumerate(children) if item.path == last_selection.path), -1)
current_selection_index = next((i for i, item in enumerate(children) if item.path == current_selection.path), -1)
if last_selection_index >= 0 and current_selection_index >=0:
first_index = min(last_selection_index, current_selection_index)
last_index = max(last_selection_index, current_selection_index)
self.clear_selections()
selection_indices = range(first_index, last_index+1)
# OM-72965: only add selection in reverse order if current selection is after last selection, so
# that the last element in selection remains the oldest (similar to file explorer)
if current_selection_index > last_selection_index:
selection_indices = reversed(selection_indices)
for i in selection_indices:
card = self._cards.get(children[i].path)
self.add_selection(card)
else:
self.clear_selections()
self.add_selection(card)
if self._selection_changed_fn:
self._selection_changed_fn(self.selections)
def _on_mouse_double_clicked(self, card: FileBrowserItemCard, x, y, b, key_mod):
if self._mouse_double_clicked_fn:
self._mouse_double_clicked_fn(b, key_mod, card.item if card else None, x=x, y=y)
def _on_drag(self, card: FileBrowserItemCard, thumbnail: str):
self._was_dragging = True
result: List[str] = []
if card not in self._selections:
return card.on_drag()
with ui.VStack():
for card in self._selections:
result.append(card.on_drag())
return "\n".join(result)
def clear_selections(self):
for selection in self._selections:
selection.selected = False
self._selections.clear()
def extend_selections(self, cards: List[FileBrowserItemCard]):
for card in cards:
self.add_selection(card)
def add_selection(self, card: FileBrowserItemCard):
if card and card not in self._selections:
card.selected = True
self._selections.append(card)
def remove_selection(self, card: FileBrowserItemCard):
if card and card in self._selections:
card.selected = False
self._selections.remove(card)
async def center_selection_async(
self,
selection : FileBrowserItem,
scroll_frame=None, scroll_ratio=0.0,
refresh_interval=2,
callback: Optional[Callable[[FileBrowserItem], None]] = None
):
# OM-70154: add the ability to center the selected item in file browser grid view
async def _wait_for_ui_build(refresh_interval=refresh_interval):
for _ in range(refresh_interval):
await omni.kit.app.get_app().next_update_async()
await _wait_for_ui_build()
cards = list(self._cards.values())
if not cards:
return
card_height = cards[0]._widget.computed_content_height
card = self._cards.get(selection.path)
if not scroll_frame and not card:
return
# card is not built yet, need to scroll to the y position in the scrolling frame to trigger card build
if not card:
# scroll one line to trigger calculation for scroll_y_max
scroll_frame.scroll_y = card_height
await _wait_for_ui_build()
# scroll to the card by using the item index ratio
if scroll_ratio > 0:
scroll_frame.scroll_y = scroll_ratio * scroll_frame.scroll_y_max - card_height * 0.5
await _wait_for_ui_build()
card = self._cards.get(selection.path)
if card:
card._widget.scroll_here()
self.add_selection(card)
if callback:
callback(selection)
def destroy(self):
self._grid = None
self._cards.clear()
self._card_paths.clear()
self._custom_thumbnails.clear()
self._selections.clear()
if self._update_grid_future and not self._update_grid_future.done():
self._update_grid_future.cancel()
self._update_grid_future = None
self._thumbnails_generated_subscription = None
self._style = None
self._mouse_pressed_fn = None
self._mouse_double_clicked_fn = None
self._selection_changed_fn = None
self._drop_fn = None
self._thumbnail_provider = None
self._badges_provider = None
|
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/__init__.py | # Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
"""
The basic UI widget and set of supporting classes for navigating the filesystem through a tree view.
The filesystem can either be from your local machine or the Omniverse server.
Example:
.. code-block:: python
With just a few lines of code, you can create a powerful, flexible tree view widget that you
can embed into your view.
filebrowser = FileBrowserWidget(
"Omniverse",
layout=SPLIT_PANES,
mouse_pressed_fn=on_mouse_pressed,
selection_changed_fn=on_selection_changed,
drop_fn=drop_handler,
filter_fn=item_filter_fn,
)
Module Constants:
layout: {LAYOUT_SINGLE_PANE_SLIM, LAYOUT_SINGLE_PANE_WIDE, LAYOUT_SPLIT_PANES, LAYOUT_DEFAULT}
"""
LAYOUT_SINGLE_PANE_SLIM = 1
LAYOUT_SINGLE_PANE_WIDE = 2
LAYOUT_SPLIT_PANES = 3
LAYOUT_SINGLE_PANE_LIST = 4
LAYOUT_DEFAULT = 3
TREEVIEW_PANE = 1
LISTVIEW_PANE = 2
import carb.events
CONNECTION_ERROR_EVENT: int = carb.events.type_from_string("omni.kit.widget.filebrowser.CONNECTION_ERROR")
MISSING_IMAGE_THUMBNAILS_EVENT: int = carb.events.type_from_string("omni.services.thumbnails.MISSING_IMAGE_THUMBNAILS")
THUMBNAILS_GENERATED_EVENT: int = carb.events.type_from_string("omni.services.thumbnails.THUMBNAILS_GENERATED")
ALERT_INFO = 1
ALERT_WARNING = 2
ALERT_ERROR = 3
from .widget import FileBrowserWidget
from .card import FileBrowserItemCard
from .model import FileBrowserModel, FileBrowserItem, FileBrowserUdimItem, FileBrowserItemFactory
from .filesystem_model import FileSystemModel, FileSystemItem
from .nucleus_model import NucleusModel, NucleusItem, NucleusConnectionItem
from .column_delegate_registry import ColumnDelegateRegistry
from .abstract_column_delegate import ColumnItem
from .abstract_column_delegate import AbstractColumnDelegate
from .thumbnails import find_thumbnails_for_files_async, list_thumbnails_for_folder_async
from .clipboard import save_items_to_clipboard, get_clipboard_items, is_clipboard_cut, is_path_cut, clear_clipboard
|
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/card.py | # Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
"""
Base Model classes for the filebrowser entity.
"""
__all__ = ["FileBrowserItemCard"]
import carb
from typing import Optional
from functools import partial
from omni import ui
from .clipboard import is_path_cut
from .model import FileBrowserItem
from .style import UI_STYLES, THUMBNAIL_PATH, ICON_PATH
from . import ALERT_WARNING, ALERT_ERROR
class FileBrowserItemCard(ui.Widget):
def __init__(self, item: FileBrowserItem, **kwargs):
import carb.settings
self._item = item
self._widget = None
self._rectangle = None
self._image_frame = None
self._image_buffer = None
self._image_buffer_thumbnail = None
self._overlay_frame = None
self._back_buffer = None
self._back_buffer_thumbnail = None
self._label = None
self._selected = False
self._theme = carb.settings.get_settings().get_as_string("/persistent/app/window/uiStyle") or "NvidiaDark"
use_default_style = carb.settings.get_settings().get_as_string("/persistent/app/window/useDefaultStyle") or False
if use_default_style:
self._style = {}
else:
self._style = kwargs.get("style", UI_STYLES[self._theme])
self._width = kwargs.get("width", 60)
self._height = kwargs.get("height", 60)
self._mouse_pressed_fn = kwargs.get("mouse_pressed_fn", None)
self._mouse_released_fn = kwargs.get("mouse_released_fn", None)
self._mouse_double_clicked_fn = kwargs.get("mouse_double_clicked_fn", None)
self._drop_fn = kwargs.get("drop_fn", None)
self._get_thumbnail_fn = kwargs.get("get_thumbnail_fn", None)
self._get_badges_fn = kwargs.get("get_badges_fn", None)
self._custom_thumbnail = kwargs.get("custom_thumbnail", None)
self._timeout = kwargs.get("timeout", 10.0)
super().__init__()
self._drag_fn = kwargs.get("drag_fn", None)
if self._drag_fn:
self._drag_fn = partial(self._drag_fn, self)
else:
# If nothing is set, use the default one
self._drag_fn = self.on_drag
self._tooltip = f"Path: {item.path}\n"
self._tooltip += f"Size: {FileBrowserItem.size_as_string(item.fields.size)}\n"
self._tooltip += f"Modified: {FileBrowserItem.datetime_as_string(item.fields.date)}"
self._cached_thumbnail: Optional[str] = None
self._build_ui()
@property
def item(self) -> FileBrowserItem:
return self._item
@property
def selected(self) -> bool:
return self._selected
@selected.setter
def selected(self, value: bool):
self._rectangle.selected = value
self._label.checked = value
self._selected = value
def apply_cut_style(self):
for widget in (self._back_buffer_thumbnail, self._image_buffer_thumbnail, self._label):
if widget:
widget.name = "Cut"
def remove_cut_style(self):
for widget in (self._back_buffer_thumbnail, self._image_buffer_thumbnail, self._label):
if widget:
widget.name = ""
def _build_ui(self):
if not self._item:
return
def on_mouse_pressed(card: "FileBrowserItemCard", *args):
if self._mouse_pressed_fn:
self._mouse_pressed_fn(card, *args)
def on_mouse_released(card: "FileBrowserItemCard", *args):
if self._mouse_released_fn:
self._mouse_released_fn(card, *args)
def on_mouse_double_clicked(card: "FileBrowserItemCard", *args):
if self._mouse_double_clicked_fn:
self._mouse_double_clicked_fn(card, *args)
def mouse_hovered_fn(hovered: bool):
self._label.selected = hovered
self._widget = ui.ZStack(width=0, height=0, style=self._style)
with self._widget:
self._rectangle = ui.Rectangle(
mouse_pressed_fn=partial(on_mouse_pressed, self),
mouse_released_fn=partial(on_mouse_released, self),
mouse_double_clicked_fn=partial(on_mouse_double_clicked, self),
style_type_name_override="Card",
)
self._rectangle.set_mouse_hovered_fn(mouse_hovered_fn)
with ui.VStack(spacing=0):
with ui.ZStack():
thumbnail = self._custom_thumbnail or self._get_thumbnail(self._item)
self._image_frame = ui.Frame(
width=self._width,
height=self._height,
drag_fn=lambda: self.on_drag(thumbnail),
accept_drop_fn=lambda url: self._item.is_folder,
drop_fn=lambda event: self._on_drop(event),
)
self._overlay_frame = ui.Frame(
width=self._width,
height=self._height,
)
self.draw_thumbnail(self._custom_thumbnail)
self.draw_badges()
with ui.HStack(height=40):
# Note: This Placer nudges the label closer to the image. The inherent
# margin would otherwise create a less pleasing separation.
with ui.Placer(stable_size=True, offset_x=0, offset_y=-8):
self._label = ui.Label(
self._item.name,
style_type_name_override="Card.Label",
word_wrap=True,
elided_text=True if self._theme == "NvidiaDark" else False,
tooltip=self._tooltip,
)
ui.Spacer()
# add cut style if path is in cut clipboard on build
if is_path_cut(self._item.path):
self.apply_cut_style()
def _get_thumbnail(self, item: FileBrowserItem) -> str:
thumbnail = None
if self._get_thumbnail_fn:
thumbnail = self._get_thumbnail_fn(item)
if not thumbnail:
# Set to default thumbnails
if self._item.is_folder:
thumbnail = f"{THUMBNAIL_PATH}/folder_256.png"
else:
thumbnail = f"{THUMBNAIL_PATH}/file_256.png"
return thumbnail
def on_drag(self, thumbnail: Optional[str] = None):
with ui.VStack():
if not thumbnail and self._cached_thumbnail:
thumbnail = self._cached_thumbnail
elif not thumbnail:
if self._item.is_folder:
thumbnail = f"{THUMBNAIL_PATH}/folder_256.png"
else:
thumbnail = f"{THUMBNAIL_PATH}/file_256.png"
ui.Image(thumbnail, width=32, height=32)
ui.Label(self._item.path)
return self._item.path
def _on_drop(self, event: ui.WidgetMouseDropEvent):
if self._drop_fn:
self._drop_fn(self._item, event.mime_data)
async def draw_thumbnail_async(self, thumbnail: str):
self.draw_thumbnail(thumbnail)
if is_path_cut(self._item.path):
self.apply_cut_style()
def draw_thumbnail(self, thumbnail: str):
"""Asynchronously redraws thumbnail with the given file"""
def on_image_progress(frame: ui.Frame, thumbnail_image: ui.Image, progress: float):
"""Called when the image loading progress is changed."""
if progress != 1.0:
# We only need to catch the moment when the image is loaded.
return
# Hide the icon on the background.
if frame:
frame.visible = False
# Remove the callback to avoid circular references.
thumbnail_image.set_progress_changed_fn(None)
if thumbnail:
self._cached_thumbnail = thumbnail
with self._image_frame:
if not self._image_buffer:
self._image_buffer = ui.ZStack()
with self._image_buffer:
self._back_buffer = ui.Frame()
with self._back_buffer:
default_thumbnail = self._get_thumbnail(self._item)
self._back_buffer_thumbnail = ui.ImageWithProvider(
default_thumbnail,
fill_policy=ui.IwpFillPolicy.IWP_PRESERVE_ASPECT_FIT,
style_type_name_override="Card.Image",
)
self._image_frame.set_drag_fn(lambda: self._drag_fn(default_thumbnail))
if not thumbnail:
return
with self._image_buffer:
front_buffer = ui.Frame()
with front_buffer:
# NOTE: Ideally, we could use ui.ImageProvider here for consistency. However, if that
# method doesn't allow loading images from "omniverse://".
thumbnail_image = ui.Image(
thumbnail,
fill_policy=ui.FillPolicy.PRESERVE_ASPECT_FIT,
style_type_name_override="Card.Image",
)
thumbnail_image.set_progress_changed_fn(partial(on_image_progress, self._back_buffer, thumbnail_image))
self._image_buffer_thumbnail = thumbnail_image
self._image_frame.set_drag_fn(lambda: self._drag_fn(thumbnail))
self._back_buffer = None
def draw_badges(self):
if not self._item or not self._get_badges_fn:
return
badges = self._get_badges_fn(self._item)
if self._item.alert:
sev, msg = self._item.alert
if sev == ALERT_WARNING:
badges.append((f"{ICON_PATH}/{self._theme}/warn.svg", msg))
elif sev == ALERT_ERROR:
badges.append((f"{ICON_PATH}/{self._theme}/error.svg", msg))
else:
badges.append((f"{ICON_PATH}/{self._theme}/info.svg", msg))
if not badges:
return
size = 14
margin_width = 6
margin_height = 8
shadow_offset = 1
with self._overlay_frame:
# First, the shadows
with ui.ZStack():
with ui.VStack():
ui.Spacer()
with ui.HStack(height=size, spacing=2):
ui.Spacer()
for badge in badges:
icon, _ = badge
ui.ImageWithProvider(
icon,
width=size,
name="shadow",
fill_policy=ui.IwpFillPolicy.IWP_PRESERVE_ASPECT_FIT,
style_type_name_override="Card.Badge",
)
ui.Spacer(width=margin_width - shadow_offset)
ui.Spacer(height=margin_height - shadow_offset)
# Then, the image itself
with ui.VStack():
ui.Spacer()
with ui.HStack(height=size, spacing=2):
ui.Spacer()
for badge in badges:
icon, tooltip = badge
ui.ImageWithProvider(
icon,
tooltip=tooltip,
width=size,
fill_policy=ui.IwpFillPolicy.IWP_PRESERVE_ASPECT_FIT,
style_type_name_override="Card.Badge",
)
ui.Spacer(width=margin_width)
ui.Spacer(height=margin_height)
async def refresh_thumbnail_async(self, thumbnail: str):
try:
await self.draw_thumbnail_async(thumbnail)
except Exception as exc:
carb.log_error(f"Failed to redraw thumbnail {exc}")
def destroy(self):
self._item = None
self._label = None
self._image_frame = None
self._overlay_frame = None
self._image_buffer = None
self._image_buffer_thumbnail = None
self._back_buffer = None
self._back_buffer_thumbnail = None
self._rectangle = None
self._widget = None
|
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/model.py | # Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
__all__ = ["FileBrowserItem", "FileBrowserItemFactory", "FileBrowserModel"]
import os
import asyncio
import omni.client
import omni.kit.app
import threading
from typing import List, Dict, Tuple, Union, Callable, Any
from datetime import datetime
from collections import OrderedDict
from omni import ui
from carb import log_warn
from omni.kit.helper.file_utils import asset_types
from .thumbnails import list_thumbnails_for_folder_async
from .column_delegate_registry import ColumnDelegateRegistry
from .date_format_menu import get_datetime_format
from . import CONNECTION_ERROR_EVENT
from collections import namedtuple
FileBrowserItemFields = namedtuple("FileBrowserItemFields", "name date size permissions")
compiled_regex = None
# A hacky way to get the number of fields in FileBrowserItemFields. Otherwise we need to set hardcoded "3".
BUILTIN_COLUMNS = len(dir(FileBrowserItemFields)) - len(dir(namedtuple("_", "")))
class NoLock(object):
def __init__(self):
pass
def __enter__(self):
return self
def __exit__(self, exc_type, exc_value, traceback):
pass
class FileBrowserItem(ui.AbstractItem):
"""
Base class for the Filebrowser tree view Item. Should be sub-classed to implement specific filesystem
behavior. The Constructor should not be called directly. Instead there are factory methods available
for creating instances when needed.
"""
# flags for item display
expandable = True # whether this type of FileBrowserItem is expandable
hideable = True # whether this type of FileBrowserItem is hideable
def __init__(self, path: str, fields: FileBrowserItemFields, is_folder: bool = False, is_deleted: bool = False):
super().__init__()
self._path = path.replace("\\", "/")
self._fields = fields # Raw field values
self._models = () # Formatted values for display
self._parent = None
self._children = OrderedDict()
self._is_folder = is_folder
self._is_deleted = is_deleted
self._populated = False
self._is_udim_file = False
self._populate_func = None
self._populate_future = None
self._enable_sorting = True # Enables children to be sorted
self._icon = None
self._alert: Tuple[int, str] = None
self._item_changed = False
# Enables thread-safe reads/writes to shared data, e.g. children dict
self._mutex_lock: threading.Lock = threading.Lock() if is_folder else NoLock()
@property
def name(self) -> str:
"""str: Item name."""
return getattr(self._fields, "name", "")
@property
def path(self) -> str:
"""str: Full path name."""
return self._path
@property
def fields(self) -> FileBrowserItemFields:
""":obj:`FileBrowserItemFields`: A subset of the item's stats stored as a string tuple."""
return self._fields
@property
def models(self) -> Tuple:
"""Tuple[:obj:`ui.AbstractValueModel`]: The columns of this item."""
return self._models
@property
def parent(self) -> object:
""":obj:`FileBrowserItem`: Parent of this item."""
return self._parent
@property
def children(self) -> OrderedDict:
"""dict[:obj:`FileBrowserItem`]: Children of this item. Does not populate the item if not already populated."""
children = {}
with self._mutex_lock:
for name, child in self._children.items():
children[name] = child
return children
@property
def is_folder(self) -> bool:
"""bool: True if this item is a folder."""
return self._is_folder
@property
def item_changed (self) -> bool:
"""bool: True if this item is has been restore/delete aready."""
return self._item_changed
@item_changed .setter
def item_changed (self, value: bool):
self._item_changed = value
@property
def is_deleted(self) -> bool:
"""bool: True if this item is a deleted folder/file."""
return self._is_deleted
@is_deleted.setter
def is_deleted(self, value: bool):
self._is_deleted = value
@property
def populated(self) -> bool:
"""bool: Gets/Sets item populated state."""
return self._populated
@populated.setter
def populated(self, value: bool):
self._populated = value
@property
def is_udim_file(self) -> bool:
"""bool: Gets/Sets item udim_file state."""
return self._is_udim_file
@is_udim_file.setter
def is_udim_file(self, value: bool):
self._is_udim_file = value
@property
def enable_sorting(self) -> bool:
"""bool: True if item's children are sortable."""
return self._enable_sorting
@property
def icon(self) -> str:
"""str: Gets/sets path to icon file."""
return self._icon
@icon.setter
def icon(self, icon: str):
self._icon = icon
@property
def readable(self) -> bool:
return True
@property
def writeable(self) -> bool:
return True
@property
def alert(self) -> Tuple[int, str]:
return self._alert
@alert.setter
def alert(self, alert: Tuple[int, str]):
self._alert = alert
@property
def expandable(self) -> bool:
"""whether this FileBrowserItem is expandable. Override to change behavior"""
return True
@property
def hideable(self) -> bool:
"""whether this FileBrowserItem is hideable. Override to change behavior"""
return True
async def on_populated_async(self, result=None, children=None, callback=None):
if isinstance(result, Exception) and not isinstance(result, asyncio.CancelledError):
log_warn(f"Error populating '{self.path}': {str(result)}")
else:
# add udim placeholders
FileBrowserUdimItem.populate_udim(self)
if callback:
callback(children)
def get_subitem_model(self, index: int) -> object:
"""
Returns ith column of this item.
Returns:
:obj:`AbstractValueModel`
"""
if self._models and index < len(self._models):
return self._models[index]
return None
def populate_with_callback(self, callback: Callable, timeout: float = 10.0):
"""
Populates this item if not already populated. When done, executes callback.
Args:
callback (Callable): Function signature is void callback(children: [FileBrowserItem]).
timeout (float): Time out duration on failed server connections. Default 10.0.
"""
if self._populate_future and not self._populate_future.done():
# If there is an ongoing task for populating this folder
# Just add the call back instead of cancel it.
# populate_with_callback is only called by get_item_children
# the callback only need one place holder parameter, so could use here.
# simply cancel the furture cause the expand invalid, see OM-35385
self._populate_future.add_done_callback(callback)
else:
self._populate_future = asyncio.ensure_future(self.populate_async(lambda result, children: self.on_populated_async(result, children, callback), timeout=timeout))
async def populate_async(self, callback_async: Callable = None, timeout: float = 10.0) -> Any:
"""
Populates current item asynchronously if not already. Override this method to customize for specific
file systems.
Args:
callback_async (Callable): Function signature is void callback(result, children: [FileBrowserItem]),
where result is an Exception type upon error.
timeout (float): Time out duration on failed server connections. Default 10.0.
Returns:
Any: Result of executing callback.
"""
if not self._populated:
for _, child in self._children.items():
child._parent = self
self._populated = True
result = None
if callback_async:
return await callback_async(result, self.children)
else:
return result
def on_list_change_event(self, event: omni.client.ListEvent, entry: omni.client.ListEntry) -> bool:
"""
Virtual method to be implemented by sub-class. When called with a ListEvent, should update
this item's children list with the corresponding ListEntry.
Args:
event (:obj:`omni.client.ListEvent`): One of of {UNKNOWN, CREATED, UPDATED, DELETED, METADATA, LOCKED, UNLOCKED}.
entry (:obj:`omni.client.ListEntry`): Updated entry as defined by omni.client.
"""
return True
def add_child(self, item: object):
"""
Adds item as child.
Args:
item (:obj:`FileBrowserItem`): Child item.
"""
with self._mutex_lock:
if item:
self._children[item.name] = item
item._parent = self
def del_child(self, item_name: str):
"""
Deletes child item by name.
Args:
item_name (str): Name of child item.
"""
with self._mutex_lock:
if item_name in self._children:
# Note: Pop (instead of del) item here so as not to destory it. Let garbage collection clean it up when
# all references are released. Otherwise may result in a race condition (See OM-34661).
self._children.pop(item_name)
async def get_custom_thumbnails_for_folder_async(self) -> Dict:
"""
Returns the thumbnail dictionary for this (folder) item.
Returns:
Dict: With children url's as keys, and url's to thumbnail files as values.
"""
# If item is 'None' them interpret as root node
if self.is_folder:
return await list_thumbnails_for_folder_async(self.path)
return {}
@staticmethod
def size_as_string(value: int) -> str:
one_kb = 1024.0
one_mb = 1024.0 * one_kb
one_gb = 1024.0 * one_mb
return (
f"{value/one_gb:.2f} GB" if value > one_gb else (
f"{value/one_mb:.2f} MB" if value > one_mb else f"{value/one_kb:.2f} KB"
)
)
@staticmethod
def datetime_as_string(value: datetime) -> str:
return value.strftime(f"{get_datetime_format()} %I:%M%p")
class FileBrowserUdimItem(FileBrowserItem):
def __init__(self, path: str, fields: FileBrowserItemFields, range_start: int, range_end: int, repr_frame: int = None):
super().__init__(path, fields, is_folder=False)
self._range_start = range_start
self._range_end = range_end
self._repr_frame = repr_frame
@property
def repr_path(self) -> str:
"""str: Full thumbnail path name."""
url_parts = self._path.split(".<UDIM>.")
if self._repr_frame and len(url_parts) == 2:
return f"{url_parts[0]}.{self._repr_frame}.{url_parts[1]}"
else:
return self._path
@staticmethod
def populate_udim(parent: FileBrowserItem):
udim_added_items = {}
for _, item in parent._children.items():
if not item.is_folder and asset_types.is_asset_type(item.path, asset_types.ASSET_TYPE_IMAGE):
udim_full_path, udim_index = FileBrowserUdimItem.get_udim_sequence(item.path)
if udim_full_path:
if not udim_full_path in udim_added_items:
udim_added_items[udim_full_path] = {"placeholder": udim_full_path, "range": [udim_index], "items": [item]}
else:
udim_added_items[udim_full_path]["range"].append(udim_index)
udim_added_items[udim_full_path]["items"].append(item)
for udim in udim_added_items:
range = udim_added_items[udim]["range"]
udim_full_path = udim_added_items[udim]["placeholder"]
udim_name = os.path.basename(udim_full_path)
for item in udim_added_items[udim]["items"]:
item.is_udim_file = True
# get 1st udim item to use for thumbnail
item = FileBrowserItemFactory.create_udim_item(udim_name, udim_full_path, range[0], range[-1], range[0])
parent.add_child(item)
@staticmethod
def get_udim_sequence(full_path: str):
import re
global compiled_regex
if compiled_regex == None:
types = '|'.join([t[1:] for t in asset_types.asset_type_exts(asset_types.ASSET_TYPE_IMAGE)])
numbers = "[0-9][0-9][0-9][0-9]"
compiled_regex = re.compile(r'([\w.-]+)(.)('+numbers+')\.('+types+')$')
udim_name = compiled_regex.sub(r"\1\2<UDIM>.\4", full_path)
if udim_name and udim_name != full_path:
udim_index = compiled_regex.sub(r"\3", os.path.basename(full_path))
return udim_name, udim_index
return None, None
class FileBrowserItemFactory:
@staticmethod
def create_group_item(name: str, path: str) -> FileBrowserItem:
if not name:
return None
fields = FileBrowserItemFields(name, datetime.now(), 0, 0)
item = FileBrowserItem(path, fields, is_folder=True)
item._models = (ui.SimpleStringModel(item.name), datetime.now(), ui.SimpleStringModel(""))
item._enable_sorting = False
return item
@staticmethod
def create_dummy_item(name: str, path: str) -> FileBrowserItem:
if not name:
return None
fields = FileBrowserItemFields(name, datetime.now(), 0, 0)
item = FileBrowserItem(path, fields, is_folder=False)
item._models = (ui.SimpleStringModel(item.name), datetime.now(), ui.SimpleStringModel(""))
return item
@staticmethod
def create_udim_item(name: str, path: str, range_start: int, range_end: int, repr_frame: int):
modified_time = datetime.now()
fields = FileBrowserItemFields(name, modified_time, 0, omni.client.AccessFlags.READ)
item = FileBrowserUdimItem(path, fields, range_start, range_end, repr_frame=repr_frame)
item._models = (ui.SimpleStringModel(f"{name} [{range_start}-{range_end}]"), modified_time, ui.SimpleStringModel("N/A"))
return item
class FileBrowserModel(ui.AbstractItemModel):
"""
Base class for the Filebrowser tree view Model. Should be sub-classed to implement specific filesystem
behavior.
Args:
name (str): Name of root item. If None given, then create an initally empty model.
Keyword Args:
drop_fn (Callable): Function called to handle drag-n-drops. Function signature:
void drop_fn(dst_item: :obj:`FileBrowserItem`, src_item: :obj:`FileBrowserItem`)
filter_fn (Callable): This handler should return True if the given tree view item is visible,
False otherwise. Function signature: bool filter_fn(item: :obj:`FileBrowserItem`)
sort_by_field (str): Name of column by which to sort items in the same folder. Default "name".
sort_ascending (bool): Sort in ascending order. Default True.
"""
_main_loop = asyncio.get_event_loop()
def __init__(self, name: str = None, root_path: str = "", **kwargs):
super().__init__()
if name:
self._root = FileBrowserItemFactory.create_group_item(name, root_path)
else:
self._root = None
# By default, display these number of columns
self._single_column = False
self._show_udim_sequence = False
self._drop_fn = kwargs.get("drop_fn", None)
self._filter_fn = kwargs.get("filter_fn", None)
self._sort_by_field = kwargs.get("sort_by_field", "name")
self._sort_ascending = kwargs.get("sort_ascending", True)
self._timeout = kwargs.get("timeout", 10.0)
self._list_change_subscription = None
self._loop = self._main_loop
# Enables thread-safe reads/writes to shared data
self._pending_item_changed: List = []
self._mutex_lock: threading.Lock = threading.Lock()
self._drag_mime_data = None
self._pending_drop_items: List = []
@property
def show_udim_sequence(self):
return self._show_udim_sequence
@show_udim_sequence.setter
def show_udim_sequence(self, value: bool):
self._show_udim_sequence = value
@property
def root(self) -> FileBrowserItem:
""":obj:`FileBrowserItem`: Gets/sets the root item of this model."""
return self._root
@root.setter
def root(self, item: FileBrowserItem):
self._root = item
self._item_changed(None)
@property
def sort_by_field(self) -> str:
""":obj:`FileBrowserItem`: Gets/sets the sort-by field name."""
return self._sort_by_field
@sort_by_field.setter
def sort_by_field(self, field: str):
self._sort_by_field = field
@property
def sort_ascending(self) -> bool:
""":obj:`FileBrowserItem`: Gets/sets the sort ascending state."""
return self._sort_ascending
@sort_ascending.setter
def sort_ascending(self, value: bool):
self._sort_ascending = value
def set_filter_fn(self, filter_fn: Callable[[str], bool]):
self._filter_fn = filter_fn
def copy_presets(self, model: 'FileBrowserModel'):
# By default, display these number of columns
if self._drop_fn is None:
self._drop_fn = model._drop_fn
if self._filter_fn is None:
self._filter_fn = model._filter_fn
self._single_column = model._single_column
self._sort_by_field = model._sort_by_field
self._sort_ascending = model._sort_ascending
def get_item_children(self, item: FileBrowserItem) -> [FileBrowserItem]:
"""
Returns the list of items that are nested to the given parent item.
Args:
item (:obj:`FileBrowserItem`): Parent item.
Returns:
list[:obj:`FileBrowserItem`]
"""
# If item is 'None' them interpret as root node
item_or_root = item or self._root
if not item_or_root or not item_or_root.is_folder:
return []
if item_or_root.children:
children = list(item_or_root.children.values())
if item_or_root.enable_sorting and self._sort_by_field in FileBrowserItemFields._fields:
# Skip root level but otherwise, sort by specified field
def get_value(item: FileBrowserItem):
value = getattr(item.fields, self._sort_by_field)
return value.lower() if isinstance(value, str) else value
children = sorted(children, key=get_value, reverse=not self._sort_ascending)
# List folders before files
children = [
item
for item, is_folder in [(c, f) for f in [True, False] for c in children]
if item.is_folder == is_folder
]
if self._filter_fn:
children = self.filter_items(children)
else:
children = []
if not item_or_root.populated:
# If item not yet populated, then do it asynchronously. Force redraw when done. Note: When notifying
# the TreeView with item_changed events, it's important to pass 'None' for the root node.
item_or_root.populate_with_callback(lambda _: self._delayed_item_changed(item), timeout=self._timeout)
return children
def filter_items(self, items: List[FileBrowserItem]) -> List[FileBrowserItem]:
results = []
for item in items:
if item.is_folder == False:
if (self._show_udim_sequence and item.is_udim_file) or \
(not self._show_udim_sequence and isinstance(item, FileBrowserUdimItem)):
continue
if self._filter_fn and self._filter_fn(item):
results.append(item)
return results
def get_item_value_model_count(self, item: FileBrowserItem) -> int:
"""
Returns the number of columns this model item contains.
Args:
item (:obj:`FileBrowserItem`): The item in question.
Returns:
int
"""
if self._single_column:
return 1
if item is None:
return self.builtin_column_count + len(ColumnDelegateRegistry().get_column_delegate_names())
return len(item._models)
def get_item_value_model(self, item: FileBrowserItem, index: int) -> object:
"""
Get the value model associated with this item.
Args:
item (:obj:`FileBrowserItem`): The item in question.
Returns:
:obj:`AbstractValueModel`
"""
if not item:
item = self._root
if item:
return item.get_subitem_model(index)
else:
return None
def auto_refresh_item(self, item: FileBrowserItem, throttle_frames: int = 4):
"""
Watches the given folder and updates the children list as soon as its contents are changed.
Args:
item (:obj:`FileBrowserItem`): The folder item to watch.
throttle_frames: Number of frames to throttle the UI refresh.
"""
# If item is 'None' them interpret as root node
item_or_root = item or self._root
if not item_or_root or not item_or_root.is_folder:
return
self._list_change_subscription = omni.client.list_subscribe_with_callback(
item_or_root.path, None,
lambda result, event, entry: self.on_list_change_event(item_or_root, result, event, entry, throttle_frames=throttle_frames))
def sync_up_item_changes(self, item: FileBrowserItem):
"""
Scans given folder for missed changes; processes any changes found.
Args:
item (:obj:`FileBrowserItem`): The folder item to watch.
"""
item_or_root = item or self._root
if not item_or_root or not item_or_root.is_folder:
return
async def sync_up_item_changes_async(item: FileBrowserItem):
if not item.is_folder:
return
entries = []
try:
include_deleted_option = omni.client.ListIncludeOption.INCLUDE_DELETED_FILES
result, entries = await asyncio.wait_for(omni.client.list_async(item.path, include_deleted_option=include_deleted_option), timeout=self._timeout)
except Exception as e:
log_warn(f"Can't list directory '{item.path}': {str(e)}")
return
else:
if result != omni.client.Result.OK:
result = RuntimeWarning(f"Error listing directory '{item.path}': {result}")
# Emit notification event
event_stream = omni.kit.app.get_app().get_message_bus_event_stream()
event_stream.push(CONNECTION_ERROR_EVENT, payload={"url": item.path, "exception": result})
return
children = item.children
for entry in entries:
if entry.relative_path not in children:
# Entry was added
self.on_list_change_event(item, result, omni.client.ListEvent.CREATED, entry)
entry_names = [entry.relative_path for entry in entries]
for name in children:
if name not in entry_names:
if asset_types.is_udim_sequence(name):
continue
# Entry was deleted
MockListEntry = namedtuple("MockListEntry", "relative_path")
entry = MockListEntry(name)
self.on_list_change_event(item, result, omni.client.ListEvent.DELETED, entry)
asyncio.ensure_future(sync_up_item_changes_async(item_or_root))
def on_list_change_event(self, item: FileBrowserItem,
result: omni.client.Result, event: omni.client.ListEvent, entry: omni.client.ListEntry,
throttle_frames: int = 4):
"""
Processes change events for the given folder.
Args:
item (:obj:`FileBrowserItem`): The folder item.
result (omni.client.Result): Set by omni.client upon listing the folder.
event (omni.client.ListEvent): Event type.
throttle_frames: Number of frames to throttle the UI refresh.
"""
if item and result == omni.client.Result.OK:
item_changed = item.on_list_change_event(event, entry)
# Limit item changed to these events (See OM-29866: Kit crashes during live sync due to auto refresh)
if item_changed:
# There may be many change events issued at once. To scale properly, we queue up the changes over a
# few frames before triggering a single redraw of the UI.
self._delayed_item_changed(item, throttle_frames=throttle_frames)
def _delayed_item_changed(self, item: FileBrowserItem, throttle_frames: int = 1):
"""
Produces item changed event after skipping a beat. This is necessary for guaranteeing that async updates
are properly recognized and generate their own redraws.
Args:
item (:obj:`FileBrowserItem`): The item in question.
"""
async def item_changed_async(item: FileBrowserItem, throttle_frames: int):
with self._mutex_lock:
if item in self._pending_item_changed:
return
else:
self._pending_item_changed.append(item)
# NOTE: Wait a few beats to absorb nearby change events so that we process the changes in one chunk.
for _ in range(throttle_frames):
await omni.kit.app.get_app().next_update_async()
self._item_changed(item)
with self._mutex_lock:
try:
self._pending_item_changed.remove(item)
except Exception:
pass
if threading.current_thread() is threading.main_thread():
asyncio.ensure_future(item_changed_async(item, throttle_frames))
else:
asyncio.run_coroutine_threadsafe(item_changed_async(item, throttle_frames), self._loop)
@property
def single_column(self):
"""The panel on the left side works in one-column mode"""
return self._single_column
@single_column.setter
def single_column(self, value: bool):
"""Set the one-column mode"""
self._single_column = not not value
self._item_changed(None)
@property
def builtin_column_count(self):
"""Return the number of available columns without tag delegates"""
return 3
@property
def drag_mime_data(self):
return self._drag_mime_data
@drag_mime_data.setter
def drag_mime_data(self, data: Union[str, List[str]]):
if isinstance(data, List):
self._drag_mime_data = "\n".join(data)
else:
self._drag_mime_data = data
def get_drag_mime_data(self, item: FileBrowserItem):
"""Returns Multipurpose Internet Mail Extensions (MIME) data for be able to drop this item somewhere"""
if self._drag_mime_data:
return self._drag_mime_data
return (item or self._root).path
def drop_accepted(self, dst_item: FileBrowserItem, src_item: FileBrowserItem) -> bool:
"""
Reimplemented from AbstractItemModel. Called to highlight target when drag and drop.
Returns True if destination item is able to accept a drop. This function can be
overriden to implement a different behavior.
Args:
dst_item (:obj:`FileBrowserItem`): Target item.
src_item (:obj:`FileBrowserItem`): Source item.
Returns:
bool
"""
if dst_item and dst_item.is_folder:
# Returns True if item is a folder.
return True
return False
def drop(self, dst_item: FileBrowserItem, source: Union[str, FileBrowserItem]):
"""
Invokes user-supplied function to handle dropping source onto destination item.
Args:
dst_item (:obj:`FileBrowserItem`): Target item.
src_item (:obj:`FileBrowserItem`): Source item.
"""
if self._drop_fn and source:
# OM-87075: Delay a frame and batch process source items, if the source arg passed in is a FileBrowserItem
# FIXME: The reason for adding this delay is that, when the drop happens between within the same treeview
# (eg. selected multiple items and drop to another item in the same tree view the the list view panel)
# this ``drop`` is called once per selected item, this causes hang if in `_drop_fn` there's UI related
# operation; Thus, here we have to cache pending items and delay a frame;
# Ideally, ``omni.ui.TreeView`` might adjust the drop trigger to batch items instead of calling once per
# selected item.
if isinstance(source, FileBrowserItem):
with self._mutex_lock:
self._pending_drop_items.append(source)
else:
self._drop_fn(dst_item, source)
return
async def delay_drop():
await omni.kit.app.get_app().next_update_async()
if self._pending_drop_items:
self._drop_fn(dst_item, '\n'.join([item.path for item in self._pending_drop_items]))
self._pending_drop_items = []
if threading.current_thread() is threading.main_thread():
asyncio.ensure_future(delay_drop())
else:
asyncio.run_coroutine_threadsafe(delay_drop(), self._loop)
def destroy(self):
self._root = None
self._drop_fn = None
self._filter_fn = None
self._list_change_subscription = None
self._loop = None
self._pending_item_changed: List = []
self._pending_drop_items.clear()
|
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/thumbnails.py | __all__ = ["MissingThumbnailError", "find_thumbnails_for_files_async", "list_thumbnails_for_folder_async", "generate_missing_thumbnails_async"]
import os
import asyncio
import omni.client
import omni.kit.app
from typing import List, Dict, Set
from carb import log_warn
from omni.kit.helper.file_utils import asset_types
from . import MISSING_IMAGE_THUMBNAILS_EVENT
# Module globals
_thumbnails_dir: str = ".thumbs/256x256"
_missing_thumbnails_cache: Set = set()
class MissingThumbnailError(Exception):
""" Raised when Moebius server error
"""
def __init__(self, msg: str = '', url: str = None):
super().__init__(msg)
self.url = url
async def find_thumbnails_for_files_async(urls: List[str], generate_missing: bool = True) -> Dict:
"""
Returns a dictionary of thumbnails for the given files.
Args:
urls (List[str]): List of file Urls.
generate_missing (bool): When True, emits a carb event for the missing thumbnails. Set to False to
disable this behavior.
Returns:
Dict: Dict of all found thumbnails, with file Url as key, and thumbnail Url as value.
"""
tasks = [_find_thumbnail_async(url, auto=False) for url in urls if url]
results = await asyncio.gather(*tasks, return_exceptions=True)
thumbnail_dict = {}
missing_thumbnails = []
for result in results:
if isinstance(result, MissingThumbnailError):
missing_thumbnails.append(result.url)
else:
url, thumbnail_url = result
if url and thumbnail_url:
thumbnail_dict[url] = thumbnail_url
# Generate any missing thumbnails
if missing_thumbnails and generate_missing:
await generate_missing_thumbnails_async(missing_thumbnails)
return thumbnail_dict
async def _find_thumbnail_async(url: str, auto=False):
if not url:
return None
broken_url = omni.client.break_url(url)
if _thumbnails_dir in broken_url.path:
return None
parent_path = os.path.dirname(broken_url.path)
filename = os.path.basename(broken_url.path)
thumbnail_path = f"{parent_path.rstrip('/')}/{_thumbnails_dir}/{filename}" + (".auto.png" if auto else ".png")
thumbnail_url = omni.client.make_url(scheme=broken_url.scheme, host=broken_url.host, port=broken_url.port, path=thumbnail_path)
result = None
try:
result, stats = await omni.client.stat_async(thumbnail_url)
except (Exception, asyncio.CancelledError, asyncio.TimeoutError) as e:
result = omni.client.Result.ERROR_NOT_FOUND
if result == omni.client.Result.OK:
return (url, thumbnail_url)
elif not auto:
return await _find_thumbnail_async(url, auto=True)
else:
raise MissingThumbnailError(url=url)
async def list_thumbnails_for_folder_async(url: str, timeout: float = 30.0, generate_missing: bool = True) -> Dict:
"""
Returns a dictionary of thumbnails for the files in the given folder.
Args:
url (str): Folder Url.
generate_missing (bool): When True, emits a carb event for the missing thumbnails. Set to False to
disable this behavior.
Returns:
Dict: Dict of all found thumbnails, with file Url as key, and thumbnail Url as value.
"""
thumbnail_dict = {}
if not url or _thumbnails_dir in url:
return {}
url = url.rstrip('/')
try:
result, stats = await omni.client.stat_async(url)
except (Exception, asyncio.CancelledError, asyncio.TimeoutError) as e:
result = omni.client.Result.ERROR_NOT_FOUND
else:
if stats and result == omni.client.Result.OK:
if not (stats.flags & omni.client.ItemFlags.CAN_HAVE_CHILDREN):
# Not a folder
return await find_thumbnails_for_files_async([url])
else:
log_warn(f"Failed to stat url {url}")
return {}
# 1. List the given folder and populate keys of thumbnail_dict
result, entries = None, {}
try:
result, entries = await asyncio.wait_for(omni.client.list_async(url), timeout=timeout)
except (Exception, asyncio.CancelledError, asyncio.TimeoutError) as e:
log_warn(f"Failed to list the folder at {url}: {str(e)}")
return {}
if result == omni.client.Result.OK:
for entry in entries:
thumbnail_dict[f"{url}/{entry.relative_path}"] = None
# 2. List thumbnail folder and match up thumbnail Url's
thumbnail_folder_url = f"{url}/{_thumbnails_dir}"
result = entries = None, {}
try:
result, entries = await asyncio.wait_for(omni.client.list_async(thumbnail_folder_url), timeout=timeout)
except (Exception, asyncio.CancelledError, asyncio.TimeoutError) as e:
result = omni.client.Result.ERROR_NOT_FOUND
if result == omni.client.Result.OK:
for entry in entries:
if entry.relative_path.endswith(".auto.png"):
asset_name = entry.relative_path[:-len(".auto.png")]
auto = True
elif entry.relative_path.endswith(".png"):
asset_name = entry.relative_path[:-len(".png")]
auto = False
else:
continue
asset_url = f"{url}/{asset_name}"
if not auto or (auto and thumbnail_dict.get(asset_url) is None):
# Take manual thumbnails over auto thumbnails
thumbnail_dict[asset_url] = f"{thumbnail_folder_url}/{entry.relative_path}"
# 3. Separate haves and have nots. Missing thumbnails have thumbnail Url == None
missing_thumbnails = [k for k, v in thumbnail_dict.items() if v == None]
thumbnail_dict = {k: v for k, v in thumbnail_dict.items() if v != None}
# 4. Generate any missing thumbnails
if missing_thumbnails and generate_missing:
asyncio.ensure_future(generate_missing_thumbnails_async(missing_thumbnails))
return thumbnail_dict
async def generate_missing_thumbnails_async(missing_thumbnails: List[str]):
"""
When missing thumbnails are discovered, send an event to have them generated. The generator
service is a separate process. Once generated, a reciprocal event is sent to update the UI.
The flow is diagramed below::
+-------------------------------+ +------------------------------+
| Filebrowser | | |
| +-------------------------+ | Missing thumbnails | |
| | | | event | |
| | update_grid +---------------------------> Thumbnail generator |
| | | | | service |
| +-------------------------+ | | |
| +-------------------------+ | Thumbnails | |
| | | | generated event | |
| | update_cards_on <---------------------------+ |
| | thumbnails_generated | | | |
| +-------------------------+ | | |
| | | |
+-------------------------------+ +------------------------------+
"""
image_urls = []
for url in missing_thumbnails:
if asset_types.is_asset_type(url, asset_types.ASSET_TYPE_IMAGE) and (url not in _missing_thumbnails_cache):
# Check that this file is an image type and not already submitted
image_urls.append(url)
if image_urls:
event_stream = omni.kit.app.get_app().get_message_bus_event_stream()
event_stream.push(MISSING_IMAGE_THUMBNAILS_EVENT, payload={"urls": image_urls})
_missing_thumbnails_cache.update(set(image_urls))
|
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/nucleus_model.py | # Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
__all__ = ["NucleusItem", "NucleusItemFactory", "NucleusModel", "NucleusConnectionItem"]
import asyncio
from datetime import datetime
from typing import Callable, Any
import omni.client
import omni.kit.app
from omni import ui
from .model import FileBrowserItem, FileBrowserItemFields, FileBrowserModel
from .style import ICON_PATH
from . import CONNECTION_ERROR_EVENT
class NucleusItem(FileBrowserItem):
def __init__(self, path: str, fields: FileBrowserItemFields, is_folder: bool = True, is_deleted: bool = False):
super().__init__(path, fields, is_folder=is_folder, is_deleted=is_deleted)
async def populate_async(self, callback_async: Callable = None, timeout: float = 10.0) -> Any:
"""
Populates current item asynchronously if not already. Overrides base method.
Args:
callback_async (Callable): Function signature is void callback(result, children: [FileBrowserItem]),
where result is an Exception type upon error.
timeout (float): Time out duration on failed server connections. Default 10.0.
Returns:
Any: Result of executing callback.
"""
result = omni.client.Result.OK
if not self.populated:
entries = []
try:
result, entries = await asyncio.wait_for(omni.client.list_async(self.path), timeout=timeout)
except asyncio.CancelledError:
# NOTE: Return early if operation cancelled, without marking as 'populated'.
return omni.client.Result.OK
except (asyncio.TimeoutError, Exception) as e:
result = omni.client.Result.ERROR
finally:
if result == omni.client.Result.OK:
self.children.clear()
else:
result = RuntimeWarning(f"Error listing directory '{self.path}': {result}")
# Emit connection error event
event_stream = omni.kit.app.get_app().get_message_bus_event_stream()
event_stream.push(CONNECTION_ERROR_EVENT, payload={"url": self.path, "exception": result})
for entry in entries:
full_path = f"{self.path}/{entry.relative_path}"
self.add_child(NucleusItemFactory.create_entry_item(entry, full_path))
# NOTE: Mark this item populated even when there's an error so we don't repeatedly try.
self.populated = True
if callback_async:
try:
return await callback_async(result, self.children)
except asyncio.CancelledError:
return omni.client.Result.OK
else:
return result
def on_list_change_event(self, event: omni.client.ListEvent, entry: omni.client.ListEntry) -> bool:
"""
Handles ListEvent changes, should update this item's children list with the corresponding ListEntry.
Args:
event (:obj:`omni.client.ListEvent`): One of of {UNKNOWN, CREATED, UPDATED, DELETED, METADATA, LOCKED, UNLOCKED}.
entry (:obj:`omni.client.ListEntry`): Updated entry as defined by omni.client.
"""
if not entry:
return False
item_changed = False
child_name = entry.relative_path
child_name = child_name[:-1] if child_name.endswith("/") else child_name
full_path = f"{self.path}/{entry.relative_path}"
if event == omni.client.ListEvent.CREATED:
if not child_name in self.children:
self.add_child(NucleusItemFactory.create_entry_item(entry, full_path))
else:
item = self.children[child_name]
if item.is_deleted:
item.is_deleted = False
item.item_changed = True
item_changed = True
elif event == omni.client.ListEvent.DELETED:
if child_name in self.children:
item = self.children[child_name]
item.is_deleted = True
item.item_changed = True
item_changed = True
elif event == omni.client.ListEvent.OBLITERATED:
self.del_child(child_name)
item_changed = True
elif event == omni.client.ListEvent.UPDATED:
child = self.children.get(child_name)
if child:
# Update file size
size_model = child.get_subitem_model(2)
size_model.set_value(FileBrowserItem.size_as_string(entry.size))
return item_changed
@property
def readable(self) -> bool:
return (self._fields.permissions & omni.client.AccessFlags.READ) > 0
@property
def writeable(self) -> bool:
return (self._fields.permissions & omni.client.AccessFlags.WRITE) > 0
class NucleusConnectionItem(NucleusItem):
"""NucleusItem that represents a nucleus connection."""
def __init__(self, path: str, fields: FileBrowserItemFields, is_folder: bool = True):
super().__init__(path, fields, is_folder=is_folder)
self._signed_in = False
@property
def signed_in(self):
return self._signed_in
@signed_in.setter
def signed_in(self, value):
self._signed_in = value
class NucleusItemFactory:
@staticmethod
def create_group_item(name: str, path: str) -> NucleusItem:
if not name:
return None
access = omni.client.AccessFlags.READ | omni.client.AccessFlags.WRITE
fields = FileBrowserItemFields(name, datetime.now(), 0, access)
item = NucleusConnectionItem(path, fields)
item._models = (ui.SimpleStringModel(item.name), datetime.now(), ui.SimpleStringModel(""))
return item
@staticmethod
def create_entry_item(entry: omni.client.ListEntry, path: str) -> NucleusItem:
if not entry:
return None
name = entry.relative_path.rstrip("/")
modified_time = entry.modified_time
fields = FileBrowserItemFields(name, modified_time, entry.size, entry.access)
is_folder = (entry.flags & omni.client.ItemFlags.CAN_HAVE_CHILDREN) > 0
is_deleted = (entry.flags & omni.client.ItemFlags.IS_DELETED) > 0
item = NucleusItem(path, fields, is_folder=is_folder, is_deleted=is_deleted)
size_model = ui.SimpleStringModel(FileBrowserItem.size_as_string(entry.size))
item._models = (ui.SimpleStringModel(item.name), modified_time, size_model)
return item
class NucleusModel(FileBrowserModel):
"""
A Filebrowser model class for navigating a Nucleus server in a tree view. Sub-classed from
:obj:`FileBrowserModel`.
Args:
name (str): Name of root item..
root_path (str): Root path. If None, then create empty model. Example: "omniverse://ov-content".
Keyword Args:
drop_fn (Callable): Function called to handle drag-n-drops. Function signature:
void drop_fn(dst_item: :obj:`FileBrowserItem`, src_item: :obj:`FileBrowserItem`)
filter_fn (Callable): This handler should return True if the given tree view item is visible,
False otherwise. Function signature: bool filter_fn(item: :obj:`FileBrowserItem`)
sort_by_field (str): Name of column by which to sort items in the same folder. Default "name".
sort_ascending (bool): Sort in ascending order. Default True.
"""
def __init__(self, name: str, root_path: str, **kwargs):
import carb.settings
super().__init__(**kwargs)
if not root_path:
return
self._root = NucleusItemFactory.create_group_item(name, root_path)
theme = carb.settings.get_settings().get_as_string("/persistent/app/window/uiStyle") or "NvidiaDark"
self._root.icon = f"{ICON_PATH}/{theme}/hdd.svg"
|
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/column_delegate_registry.py | # Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
__all__ = ["ColumnDelegateRegistry"]
from .singleton import Singleton
import carb
@Singleton
class ColumnDelegateRegistry:
"""
Singleton that keeps all the column delegated. It's used to put custom
columns to the content browser.
"""
class _Event(list):
"""
A list of callable objects. Calling an instance of this will cause a
call to each item in the list in ascending order by index.
"""
def __call__(self, *args, **kwargs):
"""Called when the instance is “called” as a function"""
# Call all the saved functions
for f in self:
f(*args, **kwargs)
def __repr__(self):
"""
Called by the repr() built-in function to compute the “official”
string representation of an object.
"""
return f"Event({list.__repr__(self)})"
class _EventSubscription:
"""
Event subscription.
_Event has callback while this object exists.
"""
def __init__(self, event, fn):
"""
Save the function, the event, and add the function to the event.
"""
self._fn = fn
self._event = event
event.append(self._fn)
def __del__(self):
"""Called by GC."""
self._event.remove(self._fn)
class _ColumnDelegateSubscription:
"""
Event subscription.
_Event has callback while this object exists.
"""
def __init__(self, name, delegate):
"""
Save name and type to the list.
"""
self._name = name
ColumnDelegateRegistry()._delegates[self._name] = delegate
ColumnDelegateRegistry()._on_delegates_changed()
def __del__(self):
"""Called by GC."""
del ColumnDelegateRegistry()._delegates[self._name]
ColumnDelegateRegistry()._on_delegates_changed()
def __init__(self):
self._delegates = {}
self._names = []
self._on_delegates_changed = self._Event()
self.__delegate_changed_sub = self.subscribe_delegate_changed(self.__delegate_changed)
def register_column_delegate(self, name, delegate):
"""
Add a new engine to the registry.
name: the name of the engine as it appears in the menu.
delegate: the type derived from AbstractColumnDelegate. Content
browser will create an object of this type to build widgets
for the custom column.
"""
if name in self._delegates:
carb.log_warn("Unknown column delegate: {}".format(name))
return
return self._ColumnDelegateSubscription(name, delegate)
def get_column_delegate_names(self):
"""Returns all the column delegate names"""
return self._names
def get_column_delegate(self, name):
"""Returns the type of derived from AbstractColumnDelegate for the given name"""
return self._delegates.get(name, None)
def subscribe_delegate_changed(self, fn):
"""
Return the object that will automatically unsubscribe when destroyed.
"""
return self._EventSubscription(self._on_delegates_changed, fn)
def __delegate_changed(self):
self._names = list(sorted(self._delegates.keys()))
|
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/clipboard.py | # Copyright (c) 2018-2023, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
from typing import List
from .model import FileBrowserItem
_clipboard_items: List = []
_is_clipboard_cut = False
def save_items_to_clipboard(items: List[FileBrowserItem], is_cut: bool = False):
global _clipboard_items
_clipboard_items.clear()
if isinstance(items, list):
_clipboard_items = items
elif isinstance(items, FileBrowserItem):
_clipboard_items = [items]
if _clipboard_items:
global _is_clipboard_cut
_is_clipboard_cut = is_cut
def get_clipboard_items() -> List[FileBrowserItem]:
return _clipboard_items
def is_clipboard_cut() -> bool:
return _is_clipboard_cut
def is_path_cut(path: str) -> bool:
if _is_clipboard_cut:
return any(path == item.path for item in _clipboard_items)
return False
def clear_clipboard():
# used when cut items are pasted, we need to clear the clipboard and cut status.
global _clipboard_items
_clipboard_items.clear()
global _is_clipboard_cut
_is_clipboard_cut = False
|
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/widget.py | # Copyright (c) 2018-2021, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
__all__ = ["FileBrowserWidget"]
from queue import Empty
import omni.kit.app
import carb
import omni.ui as ui
from carb import log_error, log_warn
from typing import Callable, List, Optional
from functools import partial
from . import LAYOUT_SINGLE_PANE_SLIM, LAYOUT_SINGLE_PANE_WIDE, LAYOUT_SPLIT_PANES, LAYOUT_DEFAULT, LAYOUT_SINGLE_PANE_LIST
from . import TREEVIEW_PANE, LISTVIEW_PANE
from . import ALERT_INFO, ALERT_WARNING, ALERT_ERROR
from .model import FileBrowserModel, FileBrowserItem, FileBrowserItemFactory
from .tree_view import FileBrowserTreeView
from .grid_view import FileBrowserGridView
from .zoom_bar import ZoomBar, SCALE_MAP
from .date_format_menu import DATETIME_FORMAT_SETTING
from .style import UI_STYLES, ICON_PATH
from .clipboard import get_clipboard_items, is_clipboard_cut
class FileBrowserWidget:
"""
The basic UI widget for navigating a filesystem as a tree view. The filesystem can either be from
your local machine or the Omniverse server.
Args:
title (str): Widget title. Default None.
Keyword Args:
layout (int): The overall layout of the window, one of: {LAYOUT_SPLIT_PANES, LAYOUT_SINGLE_PANE_SLIM,
LAYOUT_SINGLE_PANE_WIDE, LAYOUT_DEFAULT}. Default LAYOUT_SPLIT_PANES.
splitter_offset (int): Position of vertical splitter bar. Default 300.
tooltip (bool): Display tooltips when hovering over items. Default False.
allow_multi_selection (bool): Allow multiple items to be selected at once. Default True.
mouse_pressed_fn (Callable): Function called on mouse press. Function signature:
void mouse_pressed_fn(pane: int, button: int, key_mode: int, item: :obj:`FileBrowserItem`)
mouse_double_clicked_fn (Callable): Function called on mouse double click. Function signature:
void mouse_double_clicked_fn(pane: int, button: int, key_mode: int, item: :obj:`FileBrowserItem`)
selection_changed_fn (Callable): Function called when selection changed. Function signature:
void selection_changed_fn(pane: int, selections: list[:obj:`FileBrowserItem`])
drop_fn (Callable): Function called to handle drag-n-drops. Function signature:
void drop_fn(dst_item: :obj:`FileBrowserItem`, src_path: str)
filter_fn (Callable): This user function should return True if the given tree view item is
visible, False otherwise. Function signature: bool filter_fn(item: :obj:`FileBrowserItem`)
show_grid_view (bool): If True, initializes the folder view to display icons. Default False.
show_recycle_widget (bool): If True, show recycle view in the left bottom corner. Default False.
grid_view_scale (int): Scales grid view, ranges from 0-5. Default 2.
on_toggle_grid_view_fn (Callable): Callback after toggle grid view is executed. Default None.
on_scale_grid_view_fn (Callable): Callback after scale grid view is executed. Default None.
icon_provider (Callable): This callback provides an icon to replace the default one in the tree
view. Signature: str icon_provider(item: :obj:`FileBrowserItem`, expanded: bool).
thumbnail_provider (Callable): This callback returns the path to the item's thumbnail. If not specified,
then a default thumbnail is used. Signature: str thumbnail_provider(item: :obj:`FileBrowserItem`).
badges_provider (Callable): This callback provides the list of badges to layer atop the thumbnail
in the grid view. Callback signature: [str] badges_provider(item: :obj:`FileBrowserItem`)
treeview_identifier (str): widget identifier for treeview, only used by tests.
enable_zoombar (bool): Enables/disables zoombar. Default True.
"""
def __init__(self, title: str, **kwargs):
import carb.settings
self._tree_view = None
self._grid_view = None
self._table_view = None
self._zoom_bar = None
self._theme = carb.settings.get_settings().get_as_string("/persistent/app/window/uiStyle") or "NvidiaDark"
self._drop_fn = kwargs.get("drop_fn", None)
self._filter_fn = kwargs.get("filter_fn", None)
# Create model to group other models, used by the tree view
self._models = FileBrowserModel(name=title, drop_fn=self._drop_fn, filter_fn=self._filter_fn)
self._models.root.icon = f"{ICON_PATH}/{self._theme}/cloud.svg"
# Create the model for the list view
self._listview_model = FileBrowserModel(drop_fn=self._drop_fn, filter_fn=self._filter_fn)
# OM-70157: Added this selections for listview here, because we cannot aggregate and re-apply selection from
# grid view/list view if the switch grid view scale and toggle happened within one frame (i.e. if the user
# is dragging the zoombar from one end to another within one frame), because the grid view items are built
# one frame delay, the selection will be lost from the scale and switch; thus this is recorded at a higher
# level on this widget, as a source of truth for selections for both list view and grid view;
self._listview_selections = []
self._currently_visible_model = None
self._style = UI_STYLES[self._theme]
self._layout = kwargs.get("layout", LAYOUT_DEFAULT)
self._splitter_offset = kwargs.get("splitter_offset", 300)
self._tooltip = kwargs.get("tooltip", False)
self._tree_root_visible = kwargs.get("tree_root_visible", True)
self._allow_multi_selection = kwargs.get("allow_multi_selection", True)
self._mouse_pressed_fn = kwargs.get("mouse_pressed_fn", None)
self._mouse_double_clicked_fn = kwargs.get("mouse_double_clicked_fn", None)
self._selection_changed_fn = kwargs.get("selection_changed_fn", None)
self._show_grid_view = kwargs.get("show_grid_view", False)
self._grid_view_scale = kwargs.get("grid_view_scale", 2)
# OM-66270: Add callback to record show grid view settings in between sessions
self._on_toggle_grid_view_fn = kwargs.get("on_toggle_grid_view_fn", None)
self._on_scale_grid_view_fn = kwargs.get("on_scale_grid_view_fn", None)
self._icon_provider = kwargs.get("icon_provider", None)
self._thumbnail_provider = kwargs.get("thumbnail_provider", None)
self._badges_provider = kwargs.get("badges_provider", None)
self._treeview_identifier = kwargs.get('treeview_identifier', None)
self._enable_zoombar = kwargs.get("enable_zoombar", True)
self._datetime_format_updated_subscription = None
self._build_ui()
@property
def show_udim_sequence(self):
return self._listview_model.show_udim_sequence
@show_udim_sequence.setter
def show_udim_sequence(self, value: bool):
self._listview_model.show_udim_sequence = value
def _build_ui(self):
if self._layout in [LAYOUT_SPLIT_PANES, LAYOUT_SINGLE_PANE_LIST, LAYOUT_DEFAULT]:
self._tree_view = self._build_split_panes_view()
else:
slim_view = self._layout == LAYOUT_SINGLE_PANE_SLIM
self._tree_view = self._build_tree_view(
self._models,
slim_view=slim_view,
selection_changed_fn=partial(self._on_selection_changed, TREEVIEW_PANE),
)
def on_datetime_format_changed(_: carb.dictionary.Item, event_type: carb.settings.ChangeEventType):
if event_type == carb.settings.ChangeEventType.CHANGED:
self.refresh_ui(listview_only=True)
self._datetime_format_updated_subscription = omni.kit.app.SettingChangeSubscription(
DATETIME_FORMAT_SETTING, on_datetime_format_changed)
def _build_split_panes_view(self) -> FileBrowserTreeView:
show_grid_view = self._show_grid_view
use_default_style = carb.settings.get_settings().get_as_string("/persistent/app/window/useDefaultStyle") or False
if use_default_style:
self._style = {}
with ui.HStack(style=self._style):
with ui.ZStack(width=0, visible=self._layout != LAYOUT_SINGLE_PANE_LIST):
# Create navigation view as side pane
self._models.single_column = True
with ui.HStack():
with ui.VStack():
tree_view = self._build_tree_view(
self._models,
header_visible=False,
files_visible=False,
slim_view=True,
selection_changed_fn=partial(self._on_selection_changed, TREEVIEW_PANE),
)
ui.Spacer(width=2)
with ui.Placer(offset_x=self._splitter_offset, draggable=True, drag_axis=ui.Axis.X):
ui.Rectangle(width=4, style_type_name_override="Splitter")
with ui.ZStack():
self._grid_view = self._build_grid_view(self._listview_model)
self._table_view = self._build_table_view(self._listview_model)
if self._enable_zoombar:
with ui.VStack():
ui.Spacer()
self._zoom_bar = ZoomBar(
show_grid_view=self._show_grid_view,
grid_view_scale=self._grid_view_scale,
on_toggle_grid_view_fn=self.toggle_grid_view,
on_scale_grid_view_fn=self.scale_grid_view
)
ui.Spacer(height=2)
# OM-49484: Add a notification frame to list view stack, that could be used for showing notification
self._notification_frame = ui.Frame()
self.toggle_grid_view(show_grid_view)
return tree_view
def _build_tree_view(
self,
model: FileBrowserModel,
header_visible: bool = True,
files_visible: bool = True,
slim_view: bool = True,
selection_changed_fn: Callable = None,
) -> FileBrowserTreeView:
if slim_view:
model._single_column = True
with ui.ZStack(style=self._style):
ui.Rectangle(style_type_name_override="TreeView")
view = FileBrowserTreeView(
model,
header_visible=header_visible,
files_visible=files_visible,
tooltip=self._tooltip,
root_visible=self._tree_root_visible,
allow_multi_selection=self._allow_multi_selection,
mouse_pressed_fn=partial(self._on_mouse_pressed, TREEVIEW_PANE),
mouse_double_clicked_fn=partial(self._on_mouse_double_clicked, TREEVIEW_PANE),
selection_changed_fn=selection_changed_fn,
icon_provider=self._icon_provider,
treeview_identifier=f"{self._treeview_identifier}_folder_view",
)
view.build_ui()
return view
def _build_table_view(self, model: FileBrowserModel) -> FileBrowserTreeView:
# Create detail view as table view
view = FileBrowserTreeView(
model,
root_visible=False,
tooltip=self._tooltip,
allow_multi_selection=self._allow_multi_selection,
mouse_pressed_fn=partial(self._on_mouse_pressed, LISTVIEW_PANE),
mouse_double_clicked_fn=partial(self._on_mouse_double_clicked, LISTVIEW_PANE),
selection_changed_fn=partial(self._on_selection_changed, LISTVIEW_PANE),
icon_provider=self._icon_provider,
treeview_identifier=self._treeview_identifier,
)
view.build_ui()
return view
def _build_grid_view(self, model: FileBrowserModel) -> FileBrowserGridView:
# Create detail view as table view
view = FileBrowserGridView(
model,
root_visible=False,
tooltip=self._tooltip,
allow_multi_selection=self._allow_multi_selection,
mouse_pressed_fn=partial(self._on_mouse_pressed, LISTVIEW_PANE),
mouse_double_clicked_fn=partial(self._on_mouse_double_clicked, LISTVIEW_PANE),
selection_changed_fn=partial(self._on_selection_changed, LISTVIEW_PANE),
drop_fn=self._drop_fn,
thumbnail_provider=self._thumbnail_provider,
badges_provider=self._badges_provider,
treeview_identifier=f"{self._treeview_identifier}_grid_view",
)
view.build_ui()
return view
def _on_mouse_pressed(self, pane: int, button: int, key_mod: int, item: FileBrowserItem, x: float = 0, y: float = 0):
if self._mouse_pressed_fn:
self._mouse_pressed_fn(pane, button, key_mod, item, x=x, y=y)
def _on_mouse_double_clicked(self, pane: int, button: int, key_mod: int, item: FileBrowserItem, x: float = 0, y: float = 0):
if self._mouse_double_clicked_fn:
self._mouse_double_clicked_fn(pane, button, key_mod, item, x=x, y=y)
if item and item.is_folder:
self._tree_view.select_and_center(item)
def _on_selection_changed(self, pane: int, selected: List[FileBrowserItem]):
if self._selection_changed_fn:
self._selection_changed_fn(pane, selected)
if pane == TREEVIEW_PANE and selected:
item = selected[-1]
if item.populated:
# If entering an already populated folder, sync up to any folder changes that may
# have been missed.
self._models.sync_up_item_changes(item)
# Refresh the folder in the list view
self._listview_model.root = item
self.show_model(self._listview_model)
# Clear out list view selections
self._listview_selections = []
# Finally, set folder to auto-refresh
self._auto_refresh_folder(item)
if pane == LISTVIEW_PANE:
# update list view selection on list view model
self._listview_selections = selected
def _auto_refresh_folder(self, item: FileBrowserItem):
if item:
self._models.auto_refresh_item(item)
self._models.add_item_changed_fn(lambda model, item: self.refresh_ui(item, listview_only=True))
def get_root(self, pane: int = None) -> FileBrowserItem:
if not pane:
return self._models.root
elif pane == TREEVIEW_PANE:
return self._tree_view.model.root
elif pane == LISTVIEW_PANE:
return self._listview_model.root
return None
def toggle_grid_view(self, show_grid_view: bool):
current_selections = self.get_selections(pane=LISTVIEW_PANE)
if not (self._grid_view and self._table_view):
return
if show_grid_view:
self._grid_view.visible = True
self._table_view.visible = False
else:
self._grid_view.visible = False
self._table_view.visible = True
# OM-70157: maintain current selection when toggling between grid view and list view
self.set_selections(current_selections, pane=LISTVIEW_PANE)
# OM-86768: refresh UI if cut clipboard is not empty to maintain the cut style
if is_clipboard_cut() and get_clipboard_items():
self.refresh_ui(listview_only=True)
self._show_grid_view = show_grid_view
# OM-66270: Record show grid view settings in between sessions
if self._on_toggle_grid_view_fn:
self._on_toggle_grid_view_fn(show_grid_view)
def hide_notification(self):
self._notification_frame.visible = False
self._grid_view.visible = self.show_grid_view
self._table_view.visible = not self.show_grid_view
def show_notification(self):
self._notification_frame.visible = True
self._grid_view.visible = False
self._table_view.visible = False
@property
def show_grid_view(self):
return self._show_grid_view
def scale_grid_view(self, scale: float):
if not self._grid_view:
return
if scale < 0.5:
self.toggle_grid_view(False)
else:
self.toggle_grid_view(True)
self._grid_view.scale_view(scale)
self._grid_view.build_ui(restore_selections=self._listview_selections)
# OM-66270: Record grid view scale settings in between sessions
if self._on_scale_grid_view_fn:
scale_level = None
# infer scale level from SCALE_MAP
if scale in SCALE_MAP.values():
scale_level = list(SCALE_MAP.keys())[list(SCALE_MAP.values()).index(scale)]
self._on_scale_grid_view_fn(scale_level)
def create_grouping_item(self, name: str, path: str, parent: FileBrowserItem = None) -> FileBrowserItem:
child = FileBrowserItemFactory.create_group_item(name, path)
if child:
item = parent or self._models.root
item.add_child(child)
self._models._item_changed(parent)
return child
def add_model_as_subtree(self, model: FileBrowserModel, parent: FileBrowserItem = None):
if model:
parent = parent or self._models.root
parent.add_child(model.root)
# TODO: Remove it
self.refresh_ui()
def delete_child_by_name(self, item_name: str, parent: FileBrowserItem = None):
if item_name:
parent = parent or self._models.root
parent.del_child(item_name)
# TODO: Remove it
self.refresh_ui()
def delete_child(self, item: FileBrowserItem, parent: FileBrowserItem = None):
if item:
self.delete_child_by_name(item.name, parent)
def link_views(self, src_widget: object):
"""
Links this widget to the given widget, i.e. the 2 widgets will therafter display the same
models but not necessarily share the same view.
Args:
src_widget (:obj:`FilePickerWidget`): The source widget.
"""
if self._tree_view and src_widget._tree_view:
src_model = src_widget._tree_view.model
if src_model:
self._tree_view.set_root(src_model.root)
def set_item_alert(self, item: FileBrowserItem, alert_level: int, msg: str):
if item:
item.alert = (alert_level, msg)
self.refresh_ui(item)
def set_item_info(self, item: FileBrowserItem, msg: str):
self.set_item_alert(item, ALERT_INFO, msg)
def set_item_warning(self, item: FileBrowserItem, msg: str):
self.set_item_alert(item, ALERT_WARNING, msg)
def set_item_error(self, item: FileBrowserItem, msg: str):
self.set_item_alert(item, ALERT_ERROR, msg)
def clear_item_alert(self, item: FileBrowserItem):
if item:
item.alert = None
self.refresh_ui(item)
def refresh_ui(self, item: FileBrowserItem = None, listview_only: bool = False):
"""
Redraws the subtree rooted at the given item. If item is None, then redraws entire tree.
Args:
item (:obj:`FileBrowserItem`): Root of subtree to redraw. Default None, i.e. root.
"""
if not listview_only:
if self._tree_view:
self._tree_view.refresh_ui(item)
if self._grid_view:
self._grid_view.refresh_ui(item)
if self._table_view:
self._table_view.refresh_ui()
def set_selections(self, selections: [FileBrowserItem], pane: int = TREEVIEW_PANE):
"""
Selected given items in given pane.
ARGS:
selections (list[:obj:`FileBrowserItem`]): list of selections.
pane (int): One of TREEVIEW_PANE, LISTVIEW_PANE, or None for both. Default None.
"""
if not pane or pane == TREEVIEW_PANE:
if selections:
self._tree_view.tree_view.selection = selections
else:
# Note: OM-23294 - Segfaults when selections cleared
# self._tree_view.tree_view.clear_selection()
pass
if not pane or pane == LISTVIEW_PANE:
if selections:
self._table_view.tree_view.selection = selections
else:
# Note: OM-23294 - Segfaults when selections cleared
self._table_view.tree_view.clear_selection()
pass
if self._grid_view:
self._grid_view.selections = selections
self._listview_selections = selections
def get_selected_item(self, pane: int = TREEVIEW_PANE) -> FileBrowserItem:
"""
Returns last of selected item from the specified pane.
ARGS:
pane (int): One of TREEVIEW_PANE, LISTVIEW_PANE. Returns the union if None is specified.
Returns:
`FileBrowserItem` or None
"""
selections = self.get_selections(pane)
return selections[-1] if len(selections) > 0 else None
def get_selections(self, pane: int = TREEVIEW_PANE) -> [FileBrowserItem]:
"""
Returns list of selected items from the specified pane.
ARGS:
pane (int): One of TREEVIEW_PANE, LISTVIEW_PANE. Returns the union if None is specified.
Returns:
list[:obj:`FileBrowserItem`]
"""
if not pane or pane == TREEVIEW_PANE:
selections = self._tree_view.selections
else:
selections = []
if not pane or pane == LISTVIEW_PANE:
selections.extend(self._listview_selections)
# Ensure selections are unique
return list(set(selections))
def select_and_center(self, selection: FileBrowserItem, pane: int = TREEVIEW_PANE):
"""
Selects and centers the tree view on the given item, expanding the tree if needed.
Args:
selection (:obj:`FileBrowserItem`): The selected item.
pane (int): One of TREEVIEW_PANE, LISTVIEW_PANE.
"""
if not pane or pane == TREEVIEW_PANE:
self._tree_view.select_and_center(selection)
if self._grid_view:
self._grid_view.scroll_top()
if self._table_view:
self._table_view.scroll_top()
# clear out listview model selections when selecting treeview items
self._listview_selections = []
if not pane or pane == LISTVIEW_PANE:
if self._grid_view.visible:
self._grid_view.select_and_center(selection)
if self._table_view.visible:
self._table_view.select_and_center(selection)
self._listview_selections = [selection]
def set_expanded(self, item: FileBrowserItem, expanded: bool, recursive: bool = False):
"""
Sets the expansion state of the given item.
Args:
item (:obj:`FileBrowserItem`): The item to effect.
expanded (bool): True to expand, False to collapse.
recursive (bool): Apply state recursively to descendent nodes. Default False.
"""
if self._tree_view:
self._tree_view.set_expanded(item, expanded, recursive)
def show_model(self, model: FileBrowserModel):
if model:
new_model = model
new_model.copy_presets(self._listview_model)
else:
new_model = self._listview_model
if new_model != self._currently_visible_model:
# Hack to remove model to avoid memory leaks
# TODO: Find out how to create a model with no circular dependencies
if self._currently_visible_model and self._currently_visible_model != self._listview_model:
self._currently_visible_model.destroy()
self._currently_visible_model = new_model
if self._grid_view:
self._grid_view.model = self._currently_visible_model
if self._table_view:
self._table_view.model = self._currently_visible_model
def destroy(self):
"""
Destructor. Called by extension before destroying this object. It doesn't happen automatically.
Without this hot reloading doesn't work.
"""
if self._tree_view:
self._tree_view.destroy()
self._tree_view = None
if self._grid_view:
self._grid_view.destroy()
self._grid_view = None
if self._table_view:
self._table_view.destroy()
self._table_view = None
if self._listview_model:
self._listview_model.destroy()
self._listview_model = None
self._listview_selections.clear()
if self._notification_frame:
self._notification_frame = None
if self._zoom_bar:
self._zoom_bar.destroy()
self._zoom_bar = None
if self._models:
self._models.destroy()
self._models = None
self._currently_visible_model = None
self._style = None
self._drop_fn = None
self._filter_fn = None
self._mouse_pressed_fn = None
self._mouse_double_clicked_fn = None
self._selection_changed_fn = None
self._icon_provider = None
self._thumbnail_provider = None
self._badges_provider = None
self._datetime_format_updated_subscription = None
|
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/singleton.py | # Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
def Singleton(class_):
"""A singleton decorator"""
instances = {}
def getinstance(*args, **kwargs):
if class_ not in instances:
instances[class_] = class_(*args, **kwargs)
return instances[class_]
return getinstance
|
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/abstract_column_delegate.py | # Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
__all__ = ["ColumnItem", "AbstractColumnDelegate"]
import omni.ui as ui
import abc
class ColumnItem:
"""
It's not clear which data we need to pass to build_widget. It's path, but
there are potentially other interesting information the column has. To
keep API unchanged over the time, we pass data in a struct. It also allow
to pass custom data with deriving from this class.
"""
def __init__(self, path):
self._path = path
@property
def path(self):
return self._path
class AbstractColumnDelegate(metaclass=abc.ABCMeta):
"""
An abstract object that is used to put the widget to the file browser
asynchronously.
"""
@property
def initial_width(self):
"""The width of the column"""
return ui.Fraction(1)
def build_header(self):
"""Build the header"""
pass
@abc.abstractmethod
async def build_widget(self, item: ColumnItem):
"""
Build the widget for the given path. Works inside Frame in async
mode. Once the widget is created, it will replace the content of the
frame. It allow to await something for a while and create the widget
when the result is available.
"""
pass
|
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/tests/test_zoom_bar.py | ## Copyright (c) 2018-2019, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
import omni.kit.test
import omni.kit.app
from unittest.mock import patch
from ..widget import FileBrowserWidget
from ..grid_view import FileBrowserGridViewDelegate
class TestZoomBar(omni.kit.test.AsyncTestCase):
"""Testing FileBrowserGridViewDelegate.update_grid"""
async def setUp(self):
self._throttle_frames = 2
async def tearDown(self):
pass
async def _after_redraw_async(self):
for _ in range(self._throttle_frames + 1):
await omni.kit.app.get_app().next_update_async()
async def test_zoom_switches_to_table_view(self):
"""Testing FileBrowserWidget.scale_grid_view changes to treeview for small scale factors"""
under_test = FileBrowserWidget("test", show_grid_view=True)
self.assertFalse(under_test._table_view.visible)
self.assertTrue(under_test._grid_view.visible)
under_test.scale_grid_view(0.25)
self.assertTrue(under_test._table_view.visible)
self.assertFalse(under_test._grid_view.visible)
under_test.scale_grid_view(0.5)
self.assertFalse(under_test._table_view.visible)
self.assertTrue(under_test._grid_view.visible)
under_test.scale_grid_view(2.0)
self.assertFalse(under_test._table_view.visible)
self.assertTrue(under_test._grid_view.visible)
under_test.destroy()
under_test = None
async def test_zoom_rebuilds_grid_view(self):
"""Testing FileBrowserWidget.scale_grid_view re-builds the grid view"""
with patch.object(FileBrowserGridViewDelegate, "build_grid") as mock_build_grid,\
patch.object(FileBrowserGridViewDelegate, "update_grid") as mock_update_grid:
test_scale = 1.75
under_test = FileBrowserWidget("test", show_grid_view=True)
mock_build_grid.reset_mock()
mock_update_grid.reset_mock()
under_test.scale_grid_view(test_scale)
await self._after_redraw_async()
self.assertEqual(under_test._grid_view._delegate.scale, test_scale)
mock_build_grid.assert_called_once()
mock_update_grid.assert_called_once()
|
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/tests/test_thumbnails.py | ## Copyright (c) 2018-2019, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
import os
import asyncio
import omni.kit.test
import omni.kit.app
import omni.client
import omni.ui as ui
from unittest.mock import patch, Mock
from typing import List, Dict
from functools import partial
from ..grid_view import FileBrowserGridViewDelegate
from ..card import FileBrowserItemCard
from ..model import FileBrowserModel, FileBrowserItem, FileBrowserItemFactory
from ..thumbnails import find_thumbnails_for_files_async, list_thumbnails_for_folder_async
from .. import MISSING_IMAGE_THUMBNAILS_EVENT, THUMBNAILS_GENERATED_EVENT
from . import AsyncMock
class TestRefreshThumbnails(omni.kit.test.AsyncTestCase):
"""Testing FileBrowserGridViewDelegate rendering thumbnails"""
async def setUp(self):
self.test_dir = "omniverse://ov-test"
self.test_thumbnail_dict = {
f"{self.test_dir}/foo.tif": f"{self.test_dir}/.thumbs/foo.tif.png",
f"{self.test_dir}/bar.png": f"{self.test_dir}/.thumbs/bar.png.png",
}
async def tearDown(self):
pass
def _build_test_model(self, paths: List[str]) -> FileBrowserModel:
model = FileBrowserModel("ov-test", self.test_dir)
for path in paths:
model.root.add_child(
FileBrowserItemFactory.create_dummy_item(os.path.basename(path), path))
return model
async def _mock_get_folder_thumbnails_impl(self) -> Dict:
return self.test_thumbnail_dict
async def _mock_get_folder_thumbnails_empty(self) -> Dict:
return {}
async def _mock_find_thumbnails_impl(self, paths: str, generate_missing: bool = False) -> Dict:
return {path: self.test_thumbnail_dict.get(path) for path in paths}
async def test_update_grid_succeeds(self):
"""Testing FileBrowserGridViewDelegate.update_grid successfully renders custom thumbnails"""
with patch.object(FileBrowserItem, "get_custom_thumbnails_for_folder_async", side_effect=self._mock_get_folder_thumbnails_impl),\
patch.object(FileBrowserItemCard, "refresh_thumbnail_async", new_callable=AsyncMock) as mock_refresh_thumbnail:
paths = list(self.test_thumbnail_dict)
model = self._build_test_model(paths)
under_test = FileBrowserGridViewDelegate(ui.Frame(), "NvidiaDark", testing=True)
under_test.build_grid(model)
under_test.update_grid(model)
await omni.kit.app.get_app().next_update_async()
# Confirm that cards with existing thumbnails redraw themselves
self.assertEqual(mock_refresh_thumbnail.call_count, len(paths))
async def test_thumbnails_not_found(self):
"""Testing FileBrowserGridViewDelegate.update_grid correctly handles no thumbnails"""
with patch.object(FileBrowserItem, "get_custom_thumbnails_for_folder_async", side_effect=self._mock_get_folder_thumbnails_empty),\
patch.object(FileBrowserItemCard, "refresh_thumbnail_async", new_callable=AsyncMock) as mock_refresh_thumbnail:
paths = list(self.test_thumbnail_dict)
model = self._build_test_model(paths)
under_test = FileBrowserGridViewDelegate(ui.Frame(), "NvidiaDark", testing=True)
under_test.build_grid(model)
under_test.update_grid(model)
await omni.kit.app.get_app().next_update_async()
# Confirm that no matching thumbnails were found
mock_refresh_thumbnail.assert_not_called()
async def test_update_cards_on_thumbnails_generated(self):
"""Testing FileBrowserGridViewDelegate.update_cards_on_thumbnails_generated correctly handles new thumbnails"""
with patch.object(FileBrowserItem, "get_custom_thumbnails_for_folder_async", side_effect=self._mock_get_folder_thumbnails_empty),\
patch.object(FileBrowserItemCard, "refresh_thumbnail_async", new_callable=AsyncMock) as mock_refresh_thumbnail,\
patch("omni.kit.widget.filebrowser.grid_view.find_thumbnails_for_files_async", side_effect=self._mock_find_thumbnails_impl):
paths = list(self.test_thumbnail_dict)
model = self._build_test_model(paths)
under_test = FileBrowserGridViewDelegate(ui.Frame(), "NvidiaDark", testing=True)
under_test.build_grid(model)
under_test.update_grid(model)
await omni.kit.app.get_app().next_update_async()
# Listen for connection error events
event_stream = omni.kit.app.get_app().get_message_bus_event_stream()
event_stream.push(THUMBNAILS_GENERATED_EVENT, payload={'paths': [paths[0]]})
for _ in range(2):
await omni.kit.app.get_app().next_update_async()
mock_refresh_thumbnail.assert_called_with(self.test_thumbnail_dict.get(paths[0]))
event_stream.push(THUMBNAILS_GENERATED_EVENT, payload={'paths': [paths[1]]})
for _ in range(2):
await omni.kit.app.get_app().next_update_async()
mock_refresh_thumbnail.assert_called_with(self.test_thumbnail_dict.get(paths[1]))
class TestFindThumbnailsForFiles(omni.kit.test.AsyncTestCase):
"""Testing find_thumbnails_for_files_async api func"""
async def setUp(self):
pass
async def tearDown(self):
pass
async def test_find_thumbnails_succeeds(self):
"""Testing find_thumbnails_for_files_async returns expected thumbnails in dict"""
async def mock_stat_async_impl(path: str):
return omni.client.Result.OK, None
with patch("omni.client.stat_async", side_effect=mock_stat_async_impl):
test_urls = ["omniverse://ov-foo/foo.usd", "omniverse://ov-bar/bar.usd", "omniverse://ov-baz/baz.usd" ]
results = await find_thumbnails_for_files_async(test_urls)
# Confirm thumbnail files found
self.assertEqual(len(test_urls), len(results))
for url, thumbnail_url in results.items():
parent_dir = os.path.dirname(url)
filename = os.path.basename(url)
expected = f"{parent_dir}/.thumbs/256x256/{filename}.png"
self.assertEqual(thumbnail_url, expected)
async def test_find_thumbnails_returns_auto_files(self):
"""Testing find_thumbnails_for_files_async returns auto thumbnails when those are available"""
async def mock_stat_async_auto(path: str):
return (omni.client.Result.OK, None) if ".auto." in path else (omni.client.Result.ERROR_NOT_FOUND, None)
with patch("omni.client.stat_async", side_effect=mock_stat_async_auto):
test_urls = ["omniverse://ov-foo/foo.usd", "omniverse://ov-bar/bar.usd", "omniverse://ov-baz/baz.usd" ]
results = await find_thumbnails_for_files_async(test_urls)
# Confirm thumbnail files found
self.assertEqual(len(test_urls), len(results))
for url, thumbnail_url in results.items():
parent_dir = os.path.dirname(url)
filename = os.path.basename(url)
expected = f"{parent_dir}/.thumbs/256x256/{filename}.auto.png"
self.assertEqual(thumbnail_url, expected)
async def test_find_thumbnails_generates_missing_when_not_found(self):
"""Testing find_thumbnails_for_files_async submits missing thumbnails for generation"""
async def mock_stat_async_not_found(path: str):
return omni.client.Result.ERROR_NOT_FOUND, None
with patch("omni.client.stat_async", side_effect=mock_stat_async_not_found):
test_image_urls = ["omniverse://ov-foo/foo.png", "omniverse://ov-baz/baz.jpg"]
test_urls = test_image_urls + ["omniverse://ov-bar/bar.usd"]
mock_sub_callback = Mock()
event_stream = omni.kit.app.get_app().get_message_bus_event_stream()
event_stream_sub = event_stream.create_subscription_to_pop_by_type(MISSING_IMAGE_THUMBNAILS_EVENT, mock_sub_callback)
results = await find_thumbnails_for_files_async(test_urls)
# Check that subscription callback was triggered, and that only image files are submitted for
# thumbnail generation.
self.assertEqual(len(results), 0)
await omni.kit.app.get_app().next_update_async()
mock_sub_callback.assert_called_once()
event = mock_sub_callback.call_args[0][0]
self.assertTrue(event.payload.get_dict() == {'urls': tuple(test_image_urls)})
# Call again with additional inputs
test_more_image_urls = ["omniverse://ov-cow/cow.tif"]
test_urls += test_more_image_urls
mock_sub_callback.reset_mock()
results = await find_thumbnails_for_files_async(test_urls)
# This time, assert that only the new files are submitted for thumbnail generation. I.e. we don't
# want the same files to be submitted more than once.
self.assertEqual(len(results), 0)
await omni.kit.app.get_app().next_update_async()
mock_sub_callback.assert_called_once()
event = mock_sub_callback.call_args[0][0]
self.assertTrue(event.payload.get_dict() == {'urls': tuple(test_more_image_urls)})
class TestListThumbnailsForFolder(omni.kit.test.AsyncTestCase):
"""Testing list_thumbnails_for_folder_async api func"""
async def setUp(self):
self.test_folder = "omniverse://ov-test/folder"
self.test_files = ["foo.usd", "bar.jpg", "baz.png" ]
self.test_urls = [f"{self.test_folder}/{f}" for f in self.test_files]
self.test_thumbnails = [f"{self.test_folder}/.thumbs/256x256/{f}.png" for f in self.test_files]
self.test_auto_thumbnails = [f"{self.test_folder}/.thumbs/256x256/{f}.auto.png" for f in self.test_files]
async def tearDown(self):
pass
class MockStats:
def __init__(self, is_folder: bool = False):
self.flags = 0
if is_folder:
self.flags |= omni.client.ItemFlags.CAN_HAVE_CHILDREN
class MockListEntry:
def __init__(self, url: str):
self.relative_path = os.path.basename(url)
async def _mock_stat_async_impl(self, url: str):
if os.path.basename(url) == "folder":
return omni.client.Result.OK, self.MockStats(is_folder=True)
return omni.client.Result.OK, self.MockStats(is_folder=False)
async def _mock_list_async_impl(self, url: str):
if url.endswith(".thumbs/256x256"):
return omni.client.Result.OK, [self.MockListEntry(url) for url in self.test_thumbnails]
else:
return omni.client.Result.OK, [self.MockListEntry(url) for url in self.test_urls]
async def _mock_list_async_impl_auto(self, url: str):
if url.endswith(".thumbs/256x256"):
return omni.client.Result.OK, [self.MockListEntry(url) for url in self.test_auto_thumbnails]
else:
return omni.client.Result.OK, [self.MockListEntry(url) for url in self.test_urls]
async def _mock_list_async_timeout(self, url: str):
raise asyncio.TimeoutError
async def test_list_thumbnails_succeeds(self):
"""Testing list_thumbnails_for_folder_async returns expected thumbnails in dict"""
with patch("omni.client.stat_async", side_effect=self._mock_stat_async_impl),\
patch("omni.client.list_async", side_effect=self._mock_list_async_impl):
results = await list_thumbnails_for_folder_async(self.test_folder)
# Confirm thumbnail files found
self.assertEqual(len(self.test_urls), len(results))
for url, thumbnail_url in results.items():
parent_dir = os.path.dirname(url)
filename = os.path.basename(url)
expected = f"{parent_dir}/.thumbs/256x256/{filename}.png"
self.assertEqual(thumbnail_url, expected)
async def test_list_thumbnails_auto(self):
"""Testing list_thumbnails_for_folder_async returns auto thumbnails in dict"""
with patch("omni.client.stat_async", side_effect=self._mock_stat_async_impl),\
patch("omni.client.list_async", side_effect=self._mock_list_async_impl_auto):
results = await list_thumbnails_for_folder_async(self.test_folder)
# Confirm auto thumbnail files found
self.assertEqual(len(self.test_urls), len(results))
for url, thumbnail_url in results.items():
parent_dir = os.path.dirname(url)
filename = os.path.basename(url)
expected = f"{parent_dir}/.thumbs/256x256/{filename}.auto.png"
self.assertEqual(thumbnail_url, expected)
async def test_list_thumbnails_auto_precedence(self):
"""Testing that when list_thumbnails_for_folder_async returns multiple thumbnails, the non-auto one takes precedence"""
test_file = "foo.usd"
test_url = f"{self.test_folder}/{test_file}"
async def mock_list_async_impl(url: str):
if url.endswith(".thumbs/256x256"):
thumbnail_folder = f"{self.test_folder}/.thumbs/256x256"
# Return both auto and non-auto thumbnails
return omni.client.Result.OK, [self.MockListEntry(f"{thumbnail_folder}/{test_file}.auto.png"), self.MockListEntry(f"{thumbnail_folder}/{test_file}.png")]
else:
return omni.client.Result.OK, [self.MockListEntry(test_url)]
with patch("omni.client.stat_async", side_effect=self._mock_stat_async_impl),\
patch("omni.client.list_async", side_effect=mock_list_async_impl):
results = await list_thumbnails_for_folder_async(self.test_folder)
# Confirm non-auto thumbnail precedes auto thumbnail
expected = f"{self.test_folder}/.thumbs/256x256/{test_file}.png"
self.assertEqual(results.get(test_url), expected)
async def test_get_thumbnails_timeout(self):
"""Testing list_thumbnails_for_folder_async times out"""
with patch("omni.client.stat_async", side_effect=self._mock_stat_async_impl),\
patch("omni.client.list_async", side_effect=self._mock_list_async_timeout):
results = await list_thumbnails_for_folder_async(self.test_folder)
self.assertEqual(results, {})
async def test_get_thumbnails_generates_missing_when_not_found(self):
"""Testing list_thumbnails_for_folder_async submits missing thumbnails for generation"""
test_image_files = ["bar.jpg", "baz.png" ]
test_image_urls = [f"{self.test_folder}/{f}" for f in test_image_files]
test_urls = test_image_urls + [f"{self.test_folder}/foo.usd"]
async def mock_list_async_impl(url: str):
if url.endswith(".thumbs/256x256"):
# Thumbnails not found
return omni.client.Result.OK, []
else:
return omni.client.Result.OK, [self.MockListEntry(url) for url in test_urls]
with patch("omni.client.stat_async", side_effect=self._mock_stat_async_impl),\
patch("omni.client.list_async", side_effect=mock_list_async_impl):
mock_sub_callback = Mock()
event_stream = omni.kit.app.get_app().get_message_bus_event_stream()
event_stream_sub = event_stream.create_subscription_to_pop_by_type(MISSING_IMAGE_THUMBNAILS_EVENT, mock_sub_callback)
results = await list_thumbnails_for_folder_async(self.test_folder)
# Check that subscription callback was triggered, and that only image files are submitted for
# thumbnail generation.
self.assertEqual(len(results), 0)
await omni.kit.app.get_app().next_update_async()
mock_sub_callback.assert_called_once()
event = mock_sub_callback.call_args[0][0]
self.assertEqual(event.payload.get_dict(), {'urls': tuple(test_image_urls)})
# Call again with additional inputs
test_more_image_urls = [f"{self.test_folder}/cow.tif"]
test_urls += test_more_image_urls
mock_sub_callback.reset_mock()
results = await list_thumbnails_for_folder_async(self.test_folder)
# This time, assert that only the new files are submitted for thumbnail generation. I.e. we don't
# want the same files to be submitted more than once.
self.assertEqual(len(results), 0)
await omni.kit.app.get_app().next_update_async()
mock_sub_callback.assert_called_once()
event = mock_sub_callback.call_args[0][0]
self.assertTrue(event.payload.get_dict() == {'urls': tuple(test_more_image_urls)}) |
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/tests/test_datetime_format.py | ## Copyright (c) 2018-2019, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
import omni.kit.test
import omni.kit.app
import carb.settings
from functools import partial
from ..date_format_menu import DatetimeFormatMenu, DATETIME_FORMAT_SETTING, get_datetime_format
class TestDatetimeFormat(omni.kit.test.AsyncTestCase):
"""Testing DatetimeFormatMenu"""
async def setUp(self):
pass
async def tearDown(self):
pass
async def _after_redraw_async(self):
for _ in range(2):
await omni.kit.app.get_app().next_update_async()
async def test_datetime_format_change(self):
""" Test datetime format setting changes"""
self._datetime_format = "MM/DD/YYYY"
self._format_changed = False
def format_change_callback(owner):
owner._format_changed = True
datetime_menu = DatetimeFormatMenu(partial(format_change_callback, self))
datetime_menu.visible = True
# test datetime format value
carb.settings.get_settings().set(DATETIME_FORMAT_SETTING, self._datetime_format)
await self._after_redraw_async()
self.assertEqual(get_datetime_format(), "%m/%d/%Y")
carb.settings.get_settings().set(DATETIME_FORMAT_SETTING, "DD-MM-YYYY")
await self._after_redraw_async()
self.assertEqual(get_datetime_format(), "%d-%m-%Y")
# test datetime format setting change callback is work as expected
carb.settings.get_settings().set(DATETIME_FORMAT_SETTING, "DD/MM/YYYY")
await self._after_redraw_async()
self.assertEqual(get_datetime_format(), "%x")
self.assertTrue(self._format_changed)
|
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/tests/test_widget.py | ## Copyright (c) 2018-2019, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
import omni.kit.test
import omni.client
import omni.kit.app
from unittest.mock import patch
from ..model import FileBrowserModel, FileBrowserItemFactory
from ..widget import FileBrowserWidget
async def after_redraw_async(frames=1):
for _ in range(frames + 1):
await omni.kit.app.get_app().next_update_async()
class TestWidget(omni.kit.test.AsyncTestCase):
"""Testing FileBrowserWidget basic fuction"""
async def setUp(self):
self._throttle_frames = 4
async def tearDown(self):
# Wait a few frames for delayed item changed events to clear the system
await after_redraw_async(self._throttle_frames)
async def test_widget_refreshes_views(self):
"""Testing FileBrowserWidget._auto_refresh_item updates views"""
from .. import TREEVIEW_PANE, LISTVIEW_PANE
import omni.ui as ui
window_flags = ui.WINDOW_FLAGS_NO_SCROLLBAR | ui.WINDOW_FLAGS_NO_DOCKING
self._window = ui.Window("test_window", width=1200, height=900, flags=window_flags)
with self._window.frame:
test_url = "C://watched"
test_url2 = "C://watched2"
udim_url = "C://texture_1001.jpg"
udim_url2 = "C://texture_1002.jpg"
model = FileBrowserModel("C:", "C:")
watched = FileBrowserItemFactory.create_group_item("watched", test_url)
udim_item = FileBrowserItemFactory.create_udim_item("udim", udim_url, 0,1,1)
udim_item2 = FileBrowserItemFactory.create_udim_item("udim2", udim_url2,1,2,1)
udim_item.populate_udim(model.root)
model.root.add_child(watched)
model.root.add_child(udim_item)
model.root.add_child(udim_item2)
under_test = FileBrowserWidget("test")
under_test.add_model_as_subtree(model)
under_test._on_selection_changed(TREEVIEW_PANE, [watched])
# teat some widget's attribute and method
under_test.show_udim_sequence=True
self.assertTrue(under_test.show_udim_sequence)
self.assertEqual(under_test.get_root(), under_test._models.root)
self.assertEqual(under_test.get_root(TREEVIEW_PANE), under_test._tree_view.model.root)
self.assertEqual(under_test.get_root(LISTVIEW_PANE), under_test._listview_model.root)
# test notification and toggle
under_test.show_notification()
self.assertTrue(under_test._notification_frame.visible)
under_test.hide_notification()
self.assertFalse(under_test._notification_frame.visible)
under_test.toggle_grid_view(True)
self.assertTrue(under_test.show_grid_view)
# test create item
item_create_from_widget = under_test.create_grouping_item("watched2", test_url2)
self.assertEqual(item_create_from_widget.name, "watched2")
# test set item info
under_test.set_item_info(item_create_from_widget, "info")
self.assertEqual(item_create_from_widget.alert[1], "info")
under_test.set_item_warning(item_create_from_widget, "warning")
self.assertEqual(item_create_from_widget.alert[1], "warning")
await after_redraw_async(self._throttle_frames)
under_test.set_item_error(item_create_from_widget, "error")
self.assertEqual(item_create_from_widget.alert[1], "error")
await after_redraw_async(self._throttle_frames)
under_test.clear_item_alert(item_create_from_widget)
self.assertEqual(item_create_from_widget.alert, None)
await after_redraw_async(self._throttle_frames)
# test tree view select
under_test.set_selections([item_create_from_widget], TREEVIEW_PANE)
self.assertEqual(under_test.get_selected_item(), item_create_from_widget)
await after_redraw_async(self._throttle_frames)
under_test.select_and_center(item_create_from_widget, TREEVIEW_PANE)
under_test.set_expanded(item_create_from_widget, True, True)
self.assertEqual(under_test.get_selected_item(), item_create_from_widget)
await after_redraw_async(self._throttle_frames)
# test listview select
under_test.select_and_center(watched, LISTVIEW_PANE)
under_test.toggle_grid_view(False)
self.assertFalse(under_test.show_grid_view)
under_test.select_and_center(item_create_from_widget, LISTVIEW_PANE)
under_test._on_selection_changed(LISTVIEW_PANE, [item_create_from_widget])
self.assertEqual(under_test.get_selected_item(), item_create_from_widget)
await after_redraw_async(self._throttle_frames)
under_test.delete_child(item_create_from_widget)
await after_redraw_async(self._throttle_frames)
|
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/tests/__init__.py | ## Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
from unittest.mock import Mock
class AsyncMock(Mock):
"""Async equivalent of Mock class"""
def __call__(self, *args, **kwargs):
sup = super(AsyncMock, self)
async def coro():
return sup.__call__(*args, **kwargs)
return coro()
def __await__(self):
return self().__await__()
from .test_widget import *
from .test_populate import *
from .test_thumbnails import *
from .test_auto_refresh import *
from .test_grid_view import *
from .test_zoom_bar import *
from .test_datetime_format import *
from .test_drop import *
|
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/tests/test_populate.py | ## Copyright (c) 2018-2019, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
import omni.kit.test
import asyncio
import omni.client
import omni.kit.app
from typing import List, Callable
from functools import partial
from datetime import datetime
from unittest.mock import Mock, patch, ANY
from carb.events import IEventStream
from ..model import FileBrowserModel, FileBrowserItemFactory, FileBrowserItem
from ..nucleus_model import NucleusItemFactory, NucleusItem
from ..filesystem_model import FileSystemItemFactory, FileSystemItem
from .. import CONNECTION_ERROR_EVENT
from . import AsyncMock
class TestNucleusPopulate(omni.kit.test.AsyncTestCase):
"""Testing omni.kit.widget.filebrowser.NucleusItem"""
async def setUp(self):
self.test_listings = {"omniverse://ov-test": ["Lib", "NVIDIA", "Projects", "Users"]}
async def tearDown(self):
pass
class MockListEntry:
def __init__(self, path, size=0, access=0, flags=omni.client.ItemFlags.CAN_HAVE_CHILDREN):
self.relative_path = path
self.size = size
self.access = access
self.flags = flags
self.modified_time = datetime.now()
async def _mock_list_async_impl(self, url: str):
if url in self.test_listings:
entries = [self.MockListEntry(subdir) for subdir in self.test_listings[url]]
result = omni.client.Result.OK
else:
entries, result = [], omni.client.Result.ERROR_NOT_FOUND
return result, entries
async def _mock_list_async_exception(self, url: str):
raise RuntimeError("Runtime error")
async def _mock_list_async_error(self, url: str):
return omni.client.Result.ERROR, []
async def _mock_list_async_timeout(self, url: str, timeout = 1.0):
await asyncio.sleep(timeout+1)
async def test_listing_succeeds(self):
"""Testing NucleusItem.populate_async should succeed"""
with patch("omni.client.list_async") as mock_list_async:
mock_list_async.side_effect = self._mock_list_async_impl
mock_callback = AsyncMock(return_value=123)
test_path = "omniverse://ov-test"
item = NucleusItemFactory.create_group_item(test_path, test_path)
return_value = await item.populate_async(mock_callback)
# Check that item has been populated
self.assertTrue(item.populated)
# Check that the callback was invoked and that we received its return value
mock_callback.assert_called_once_with(omni.client.Result.OK, item.children)
self.assertEqual(return_value, 123)
async def test_listing_raises_exception(self):
"""Testing NucleusItem.populate_async should catch Exception"""
with patch("omni.client.list_async") as mock_list_async:
mock_list_async.side_effect = self._mock_list_async_exception
mock_callback = AsyncMock()
mock_sub_callback = Mock()
test_path = "omniverse://ov-test"
item = NucleusItemFactory.create_group_item(test_path, test_path)
# Listen for connection error events
event_stream = omni.kit.app.get_app().get_message_bus_event_stream()
event_stream_sub = event_stream.create_subscription_to_pop_by_type(CONNECTION_ERROR_EVENT, mock_sub_callback)
await item.populate_async(mock_callback)
# Check that the callback was invoked with Exception result.
result, _ = mock_callback.call_args[0]
assert isinstance(result, Exception)
# Check that item is nevertheless marked as populated
self.assertFalse(bool(item.children))
self.assertTrue(item.populated)
# Confirm that an error event was sent to the subscribed callback
await omni.kit.app.get_app().next_update_async()
mock_sub_callback.assert_called_once()
event = mock_sub_callback.call_args[0][0]
self.assertTrue(event.payload.get_dict() == {'url': test_path})
async def test_listing_returns_error(self):
"""Testing NucleusItem.populate_async should return error"""
with patch("omni.client.list_async") as mock_list_async:
mock_list_async.side_effect = self._mock_list_async_error
mock_callback = AsyncMock()
mock_sub_callback = Mock()
test_path = "omniverse://ov-test"
item = NucleusItemFactory.create_group_item(test_path, test_path)
# Listen for connection error events
event_stream = omni.kit.app.get_app().get_message_bus_event_stream()
event_stream_sub = event_stream.create_subscription_to_pop_by_type(CONNECTION_ERROR_EVENT, mock_sub_callback)
await item.populate_async(mock_callback)
# Check that the callback was invoked with Exception result.
result, _ = mock_callback.call_args[0]
assert isinstance(result, RuntimeWarning)
# Check that item is nevertheless marked as populated
self.assertFalse(bool(item.children))
self.assertTrue(item.populated)
# Check that an error event was sent to the subscribed callback
await omni.kit.app.get_app().next_update_async()
mock_sub_callback.assert_called_once()
event = mock_sub_callback.call_args[0][0]
self.assertTrue(event.payload.get_dict() == {'url': test_path})
async def test_listing_times_out(self):
"""Testing NucleusItem.populate_async times out"""
with patch("omni.client.list_async") as mock_list_async:
timeout = 1.0
mock_list_async.side_effect = self._mock_list_async_timeout
mock_callback = AsyncMock()
mock_sub_callback = Mock()
test_path = "omniverse://ov-test"
item = NucleusItemFactory.create_group_item(test_path, test_path)
# Listen for connection error events
event_stream = omni.kit.app.get_app().get_message_bus_event_stream()
event_stream_sub = event_stream.create_subscription_to_pop_by_type(CONNECTION_ERROR_EVENT, mock_sub_callback)
await item.populate_async(mock_callback, timeout=timeout)
# Check that the callback was invoked with Exception result.
result, _ = mock_callback.call_args[0]
assert isinstance(result, RuntimeWarning)
# Check that item is nevertheless marked as populated
self.assertFalse(bool(item.children))
self.assertTrue(item.populated)
# Check that an error event was sent to the subscribed callback
await omni.kit.app.get_app().next_update_async()
mock_sub_callback.assert_called_once()
event = mock_sub_callback.call_args[0][0]
self.assertTrue(event.payload.get_dict() == {'url': test_path})
async def test_listing_called_just_once(self):
"""Testing NucleusItem.populate_async should not populate item if already populated"""
with patch("omni.client.list_async") as mock_list_async:
mock_list_async.side_effect = self._mock_list_async_impl
test_path = "omniverse://ov-test"
item = NucleusItemFactory.create_group_item(test_path, test_path)
await item.populate_async(None)
# Check that item has been populated
self.assertTrue(bool(item.children) and item.populated)
# Populate again and again
await item.populate_async(None)
await item.populate_async(None)
# Check that the call to list_async ran only the first time
self.assertEqual(mock_list_async.call_count, 1)
class TestFileSystemPopulate(omni.kit.test.AsyncTestCase):
"""Testing omni.kit.widget.filebrowser.FileSystemItem"""
async def setUp(self):
self.test_listings = {"C:": ["Program Files", "ProgramData", "temp", "Users", "Windows"]}
async def tearDown(self):
pass
class MockDirEntry:
def __init__(self, path: str, file_attrs: int = 0, symlink: bool = False):
self.name = path
self.path = path
self._file_attrs = file_attrs
self._symlink = symlink
def stat(self):
from collections import namedtuple
MockStat = namedtuple("MockStat", "st_file_attributes st_size, st_mode, st_mtime")
return MockStat(self._file_attrs, 0, 0, 0)
def is_dir(self):
True
def is_symlink(self):
return self._symlink
class MockDirEntryIterator:
def __init__(self, subdirs = List[str]):
self._subdirs = subdirs
self._current = 0
def __iter__(self):
return self
def __next__(self):
if self._current < len(self._subdirs):
entry = TestFileSystemPopulate.MockDirEntry(self._subdirs[self._current])
self._current += 1
return entry
else:
raise StopIteration
def __enter__(self):
return self.__iter__()
def __exit__(self, e_type, e_val, e_traceback):
return False
def _mock_os_scandir_impl(self, path: str):
if path in self.test_listings:
subdirs = self.test_listings[path]
else:
subdirs = []
return self.MockDirEntryIterator(subdirs)
async def test_listing_succeeds(self):
"""Testing FileSystemItem.populate_async should succeed"""
with patch("os.scandir") as mock_os_scandir:
with patch("omni.kit.widget.filebrowser.FileSystemItem.keep_entry") as mock_keep_entry:
mock_os_scandir.side_effect = self._mock_os_scandir_impl
mock_keep_entry.return_value = True
mock_callback = AsyncMock(return_value=123)
test_path = "C:"
item = FileSystemItemFactory.create_group_item(test_path, test_path)
return_value = await item.populate_async(mock_callback)
# Check that item has been populated
self.assertTrue(item.populated)
# Check that the callback was invoked and that we received its return value
mock_callback.assert_called_once_with(None, item.children)
self.assertEqual(return_value, 123)
async def test_listing_returns_empty(self):
"""Testing FileSystemItem.populate_async returns empty"""
with patch("os.scandir") as mock_os_scandir:
with patch("omni.kit.widget.filebrowser.FileSystemItem.keep_entry") as mock_keep_entry:
mock_os_scandir.side_effect = self._mock_os_scandir_impl
mock_keep_entry.return_value = True
mock_callback = AsyncMock(return_value=123)
test_path = "O:"
item = FileSystemItemFactory.create_group_item(test_path, test_path)
return_value = await item.populate_async(mock_callback)
# Check that item has not been populated
self.assertFalse(bool(item.children) and item.populated)
# Check that the callback was invoked and that we received its return value
mock_callback.assert_called_once_with(None, ANY)
self.assertEqual(return_value, 123)
async def test_keep_entry(self):
"""Testing FileSystemItem.keep_entry returns True for valid entries"""
import stat
with patch("os.name", "nt"):
self.assertTrue(
FileSystemItem.keep_entry(self.MockDirEntry("Desktop")))
self.assertTrue(
FileSystemItem.keep_entry(self.MockDirEntry(".thumbs", file_attrs=stat.FILE_ATTRIBUTE_HIDDEN)))
self.assertFalse(
FileSystemItem.keep_entry(self.MockDirEntry("System", file_attrs=stat.FILE_ATTRIBUTE_SYSTEM)))
with patch("os.name", "posix"):
self.assertTrue(
FileSystemItem.keep_entry(self.MockDirEntry("home")))
self.assertTrue(
FileSystemItem.keep_entry(self.MockDirEntry("link@", symlink=True)))
class TestFileBrowserPopulate(omni.kit.test.AsyncTestCase):
"""Testing omni.kit.widget.filebrowser.FileBrowserItem"""
async def setUp(self):
self.test_listings = {"omniverse://ov-test": ["Lib", "NVIDIA", "Projects", "Users"]}
self._timeout = 1.0
async def tearDown(self):
pass
async def _mock_populate_async_impl(self, item: FileBrowserItem, callback_async: Callable, timeout: float = 1.0):
if not item.populated:
if item.path in self.test_listings:
subdirs = self.test_listings[item.path]
else:
subdirs = []
for subdir in subdirs:
item.add_child(FileBrowserItemFactory.create_group_item(subdir, f"{item.path}/{subdir}"))
item.populated = True
return await callback_async(None, item.children)
async def _mock_populate_async_timeout(self, item: FileBrowserItem, callback_async: Callable, timeout: float = 1.0):
return await callback_async(asyncio.TimeoutError(), None)
async def test_populate_with_callback_succeeds(self):
"""Testing FileBrowserItem.populate_with_callback should invoke callback"""
with patch.object(FileBrowserItem, "populate_async", autospec=True) as mock_populate_async:
mock_populate_async.side_effect = self._mock_populate_async_impl
mock_callback = Mock()
test_path = "omniverse://ov-test"
item = FileBrowserItemFactory.create_group_item(test_path, test_path)
item.populate_with_callback(mock_callback, timeout=self._timeout)
# Wait for the thread to finish, then check that callback was invoked
await omni.kit.app.get_app().next_update_async()
mock_callback.assert_called_once_with(item.children)
async def test_populate_with_callback_times_out(self):
"""Testing FileBrowserItem.populate_with_callback times out"""
with patch.object(FileBrowserItem, "populate_async", autospec=True) as mock_populate_async:
mock_populate_async.side_effect = self._mock_populate_async_timeout
mock_callback = Mock()
test_path = "omniverse://ov-test"
item = FileBrowserItemFactory.create_group_item(test_path, test_path)
item.populate_with_callback(mock_callback, timeout=self._timeout)
# Wait for the thread to finish, then check that callback was not invoked
await omni.kit.app.get_app().next_update_async()
mock_callback.assert_not_called()
async def test_get_item_children_succeeds(self):
"""Testing FileBrowserModel.get_item_children should populate asynchronously"""
with patch.object(FileBrowserItem, "populate_async", autospec=True) as mock_populate_async:
mock_populate_async.side_effect = self._mock_populate_async_impl
mock_item_changed_callback = Mock()
test_path = "omniverse://ov-test"
model = FileBrowserModel(test_path, test_path, timeout=self._timeout)
model.add_item_changed_fn(mock_item_changed_callback)
item = model.root
self.assertFalse(item.populated)
# Check that the call immediately returns but with initially empty children list
children = model.get_item_children(item)
self.assertEqual(children, [])
# Wait til populate_async fulfills its task
await omni.kit.app.get_app().next_update_async()
# Check again and confirm item is now populated with expected children
self.assertTrue(item.populated)
children = model.get_item_children(item)
self.assertEqual([c.name for c in children], self.test_listings.get(test_path))
# Confirm item changed was called
await omni.kit.app.get_app().next_update_async()
mock_item_changed_callback.assert_called_once_with(model, item)
|
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/tests/test_auto_refresh.py | ## Copyright (c) 2018-2019, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
import omni.kit.test
import omni.client
import omni.kit.app
from datetime import datetime
from typing import Callable
from unittest.mock import patch
from ..model import FileBrowserModel, FileBrowserItemFactory
from ..nucleus_model import NucleusItemFactory
from ..filesystem_model import FileSystemItemFactory
from ..widget import FileBrowserWidget
from ..tree_view import FileBrowserTreeView
from ..grid_view import FileBrowserGridView, FileBrowserGridViewDelegate
class MockListEntry:
def __init__(self, path, size=0, access=0, flags=omni.client.ItemFlags.CAN_HAVE_CHILDREN):
self.relative_path = path
self.size = size
self.access = access
self.flags = flags
self.modified_time = datetime.now()
self.deleted = False
class MockListSubscription:
def __init__(self, url, list_cb, list_change_cb):
self._url = url
self._list_cb = list_cb
self._list_change_cb = list_change_cb
self._events = []
self._cur_event = 0
def queue_event(self, result: omni.client.Result, event: omni.client.ListEvent, entry: MockListEntry):
self._events.append((result, event, entry))
def next_event(self, url: str) -> omni.client.ListEvent:
if url == self._url and self._cur_event < len(self._events):
result, event, entry = self._events[self._cur_event]
if self._list_change_cb:
self._list_change_cb(result, event, entry)
self._cur_event += 1
return event
else:
return None
async def after_redraw_async(frames=1):
for _ in range(frames + 1):
await omni.kit.app.get_app().next_update_async()
class TestAutoRefresh(omni.kit.test.AsyncTestCase):
"""Testing FileSystemItem.content_changed_async"""
async def setUp(self):
self.test_list_subscription = None
self._throttle_frames = 4
async def tearDown(self):
# Wait a few frames for delayed item changed events to clear the system
await after_redraw_async(self._throttle_frames)
def _mock_list_subscribe_impl(self, url: str, list_cb: Callable, list_change_cb: Callable):
self.test_list_subscription = MockListSubscription(url, list_cb, list_change_cb)
async def test_auto_refresh_nucleus_folder(self):
"""Testing FileBrowserModel.auto_refresh_item monitors Nucleus folder for changes"""
with patch.object(omni.client, "list_subscribe_with_callback", side_effect=self._mock_list_subscribe_impl),\
patch.object(FileBrowserModel, "_item_changed") as mock_item_changed:
test_url = "omniverse://ov-test/watched"
model = FileBrowserModel("ov-test", "omniverse://ov-test")
watched = NucleusItemFactory.create_group_item("watched", test_url)
model.root.add_child(watched)
# Queue up events
model.auto_refresh_item(watched, throttle_frames=self._throttle_frames)
self.test_list_subscription.queue_event(omni.client.Result.OK, omni.client.ListEvent.CREATED, MockListEntry("foo.usd"))
self.test_list_subscription.queue_event(omni.client.Result.OK, omni.client.ListEvent.CREATED, MockListEntry("bar.mdl"))
self.test_list_subscription.queue_event(omni.client.Result.OK, omni.client.ListEvent.DELETED, MockListEntry("foo.usd"))
self.test_list_subscription.queue_event(omni.client.Result.OK, omni.client.ListEvent.DELETED, MockListEntry("bar.mdl"))
# Created foo.usd
self.assertEqual(len(watched.children), 0)
self.test_list_subscription.next_event(watched.path)
self.assertEqual(len(watched.children), 1)
self.assertTrue("foo.usd" in watched.children)
# Created bar.mdl
self.test_list_subscription.next_event(watched.path)
self.assertEqual(len(watched.children), 2)
self.assertTrue("bar.mdl" in watched.children)
# Deleted foo.usd
self.test_list_subscription.next_event(watched.path)
self.assertEqual(len(watched.children), 2)
# To implement soft deleted feature, we don't real delete the item, set it's delete flag instead
self.assertTrue(watched.children["foo.usd"].is_deleted)
self.assertTrue(not watched.children["bar.mdl"].is_deleted)
# Deleted bar.mdl
self.test_list_subscription.next_event(watched.path)
self.assertEqual(len(watched.children), 2)
self.assertTrue(watched.children["bar.mdl"].is_deleted)
# Confirm item changes queued up and triggered only once after next frame
await after_redraw_async(self._throttle_frames)
mock_item_changed.assert_called_once_with(watched)
async def test_auto_refresh_filesystem_folder(self):
"""Testing FileBrowserModel.auto_refresh_item monitors Filesystem folder for changes"""
with patch("omni.client.list_subscribe_with_callback", side_effect=self._mock_list_subscribe_impl),\
patch.object(FileBrowserModel, "_item_changed") as mock_item_changed:
test_url = "C://watched"
model = FileBrowserModel("C:", "C:")
watched = FileSystemItemFactory.create_group_item("watched", test_url)
model.root.add_child(watched)
# Queue up events
model.auto_refresh_item(watched, throttle_frames=self._throttle_frames)
self.test_list_subscription.queue_event(omni.client.Result.OK, omni.client.ListEvent.CREATED, MockListEntry("foo.usd"))
self.test_list_subscription.queue_event(omni.client.Result.OK, omni.client.ListEvent.CREATED, MockListEntry("bar.mdl"))
self.test_list_subscription.queue_event(omni.client.Result.OK, omni.client.ListEvent.DELETED, MockListEntry("foo.usd"))
self.test_list_subscription.queue_event(omni.client.Result.OK, omni.client.ListEvent.DELETED, MockListEntry("bar.mdl"))
# Created foo.usd
self.assertEqual(len(watched.children), 0)
self.test_list_subscription.next_event(watched.path)
self.assertEqual(len(watched.children), 1)
self.assertTrue("foo.usd" in watched.children)
# Created bar.mdl
self.test_list_subscription.next_event(watched.path)
self.assertEqual(len(watched.children), 2)
self.assertTrue("bar.mdl" in watched.children)
# Deleted foo.usd
self.test_list_subscription.next_event(watched.path)
self.assertEqual(len(watched.children), 1)
# To implement soft deleted feature, we don't real delete the item, set it's delete flag instead
self.assertTrue(not "foo.usd" in watched.children)
self.assertTrue("bar.mdl" in watched.children)
# Deleted bar.mdl
self.test_list_subscription.next_event(watched.path)
self.assertEqual(len(watched.children), 0)
self.assertTrue(not "bar.mdl" in watched.children)
# Confirm item changes queued up and triggered only once
await after_redraw_async(self._throttle_frames)
mock_item_changed.assert_called_once_with(watched)
async def test_auto_refresh_ignores_update_events(self):
"""Testing FileBrowserModel.auto_refresh_item responds to only CREATED and DELETED events (OM-29866)"""
with patch("omni.client.list_subscribe_with_callback", side_effect=self._mock_list_subscribe_impl),\
patch.object(FileBrowserModel, "_item_changed") as mock_item_changed:
test_url = "omniverse://ov-test/watched"
model = FileBrowserModel("ov-test", "omniverse://ov-test")
watched = NucleusItemFactory.create_group_item("watched", test_url)
model.root.add_child(watched)
model.auto_refresh_item(watched, throttle_frames=self._throttle_frames)
self.assertEqual(len(watched.children), 0)
# CREATED event
mock_item_changed.reset_mock()
self.test_list_subscription.queue_event(omni.client.Result.OK, omni.client.ListEvent.CREATED, MockListEntry("foo.usd"))
self.test_list_subscription.next_event(watched.path)
self.assertEqual(len(watched.children), 1)
self.assertTrue("foo.usd" in watched.children)
await after_redraw_async(self._throttle_frames)
mock_item_changed.assert_called_once_with(watched)
# UPDATED, etc. events
self.test_list_subscription.queue_event(omni.client.Result.OK, omni.client.ListEvent.UPDATED, MockListEntry("foo.usd"))
self.test_list_subscription.queue_event(omni.client.Result.OK, omni.client.ListEvent.LOCKED, MockListEntry("foo.usd"))
self.test_list_subscription.queue_event(omni.client.Result.OK, omni.client.ListEvent.UNLOCKED, MockListEntry("foo.usd"))
self.test_list_subscription.queue_event(omni.client.Result.OK, omni.client.ListEvent.METADATA, MockListEntry("foo.usd"))
self.test_list_subscription.queue_event(omni.client.Result.OK, omni.client.ListEvent.UNKNOWN, MockListEntry("foo.usd"))
mock_item_changed.reset_mock()
while True:
# UPDATED event
event = self.test_list_subscription.next_event(watched.path)
if event:
await after_redraw_async(self._throttle_frames)
self.assertTrue(event not in [omni.client.ListEvent.CREATED, omni.client.ListEvent.DELETED])
mock_item_changed.assert_not_called()
else:
break
# DELETED event
mock_item_changed.reset_mock()
self.test_list_subscription.queue_event(omni.client.Result.OK, omni.client.ListEvent.DELETED, MockListEntry("foo.usd"))
self.test_list_subscription.next_event(watched.path)
# To implement soft deleted feature, we don't real delete the item, set it's delete flag instead
for child_name in watched.children:
item = watched.children[child_name]
item.is_deleted = True
self.assertEqual(item.is_deleted, True)
# Confirm item changes queued up and triggered only once
await after_redraw_async(self._throttle_frames)
mock_item_changed.assert_called_once_with(watched)
async def test_widget_refreshes_views(self):
"""Testing FileBrowserWidget._auto_refresh_item updates views"""
from .. import TREEVIEW_PANE
with patch("omni.client.list_subscribe_with_callback", side_effect=self._mock_list_subscribe_impl),\
patch.object(FileBrowserTreeView, "refresh_ui") as mock_refresh_tree_view,\
patch.object(FileBrowserGridView, "refresh_ui") as mock_refresh_grid_view:
test_url = "C://watched"
model = FileBrowserModel("C:", "C:")
watched = FileBrowserItemFactory.create_group_item("watched", test_url)
model.root.add_child(watched)
# Make watched directory the current one
under_test = FileBrowserWidget("test")
under_test.add_model_as_subtree(model)
under_test._on_selection_changed(TREEVIEW_PANE, [watched])
# Queue up events
self.test_list_subscription.queue_event(omni.client.Result.OK, omni.client.ListEvent.CREATED, MockListEntry("foo.usd"))
# Confirm change event triggers UI refresh
mock_refresh_tree_view.reset_mock()
mock_refresh_grid_view.reset_mock()
self.test_list_subscription.next_event(watched.path)
await after_redraw_async(self._throttle_frames)
mock_refresh_tree_view.assert_called()
mock_refresh_grid_view.assert_called()
async def test_gridview_redraws_only_once(self):
"""Testing FileBrowserGridView.refresh_ui updates grid view only once when refreshed many times"""
with patch.object(FileBrowserGridViewDelegate, "build_grid") as mock_delegate_build_grid,\
patch.object(FileBrowserGridViewDelegate, "update_grid") as mock_delegate_update_grid:
model = FileBrowserModel("ov-test", "omniverse://ov-test")
under_test = FileBrowserGridView(model)
mock_delegate_build_grid.assert_called_once_with(model)
# OM-78400 Clear out all refreshes from setting up the view before testing for additional ones
await after_redraw_async(self._throttle_frames)
mock_delegate_update_grid.reset_mock()
# Call refresh multiple times
under_test.refresh_ui()
under_test.refresh_ui()
under_test.refresh_ui()
# Confirm that refresh doesn't immediately rebuild the grid view. Instead, after some delay,
# builds the view only once.
mock_delegate_update_grid.assert_not_called()
await after_redraw_async(self._throttle_frames)
mock_delegate_update_grid.assert_called_once_with(model)
class TestSyncItemChanges(omni.kit.test.AsyncTestCase):
"""Testing omni.kit.widget.filebrowser.FileBrowserModel"""
async def setUp(self):
self.test_frame = 0
self.test_listings_by_frame = [["A", "B", "C"], ["B", "C", "D"]]
self._throttle_frames = 4
async def tearDown(self):
# Wait a few frames for delayed item changed events to clear the system
await after_redraw_async(self._throttle_frames)
async def _mock_list_async_impl(self, url: str, include_deleted_option=omni.client.ListIncludeOption.INCLUDE_DELETED_FILES):
subdirs = []
if self.test_frame < len(self.test_listings_by_frame):
subdirs = self.test_listings_by_frame[self.test_frame]
self.test_frame += 1
entries = [MockListEntry(subdir) for subdir in subdirs]
result = omni.client.Result.OK
return result, entries
async def test_syncing_item_changes_succeeds(self):
"""Testing FileBrowserModel.sync_up_item_changes updates given folder"""
with patch("omni.client.list_async") as mock_list_async:
mock_list_async.side_effect = self._mock_list_async_impl
test_url = "C://watched"
watched = FileSystemItemFactory.create_group_item("watched", test_url)
under_test = FileBrowserModel("C:", "C:")
under_test.root.add_child(watched)
under_test.sync_up_item_changes(watched)
await omni.kit.app.get_app().next_update_async()
test_subdirs_0 = self.test_listings_by_frame[0]
self.assertEqual(test_subdirs_0, [name for name in watched.children])
under_test.sync_up_item_changes(watched)
await omni.kit.app.get_app().next_update_async()
test_subdirs_1 = self.test_listings_by_frame[1]
self.assertEqual(test_subdirs_1, [name for name in watched.children])
|
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/tests/test_drop.py | ## Copyright (c) 2018-2023, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
import omni.kit.test
import omni.client
import omni.kit.app
from unittest.mock import Mock
from ..model import FileBrowserModel, FileBrowserItemFactory
class TestDrop(omni.kit.test.AsyncTestCase):
"""Testing FileSystemItem.content_changed_async"""
async def setUp(self):
pass
async def tearDown(self):
pass
async def test_drop_handler(self):
"""Test drop handler behaves as expected."""
from .. import TREEVIEW_PANE
mock_drop = Mock()
model = FileBrowserModel("C:", "C:", drop_fn=mock_drop)
src_paths = []
for i in range(100):
src_paths.append("C://foo_" + str(i +1))
src_items = []
for src in src_paths:
src_items.append(FileBrowserItemFactory.create_group_item(src.lstrip("C://"), src))
dst_item = FileBrowserItemFactory.create_group_item("dst", "C://dst")
# test drop_fn only called once when multiple items are triggering drop handler at the same time
for src_item in src_items:
model.drop(dst_item, src_item)
for _ in range(2):
await omni.kit.app.get_app().next_update_async()
mock_drop.assert_called_once_with(dst_item, "\n".join(src_paths))
mock_drop.reset_mock()
# test drop_fn called correctly when passing in string as source
src_paths_str = "C://foo\nC://bar\nC://baz"
model.drop(dst_item, src_paths_str)
mock_drop.assert_called_once_with(dst_item, src_paths_str) |
omniverse-code/kit/exts/omni.kit.widget.filebrowser/omni/kit/widget/filebrowser/tests/test_grid_view.py | ## Copyright (c) 2018-2019, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
import omni.kit.test
import omni.client
import omni.kit.app
import omni.ui as ui
from unittest.mock import patch
from ..model import FileBrowserModel, FileBrowserItemFactory, FileBrowserItem
from ..grid_view import FileBrowserGridView, FileBrowserGridViewDelegate
class TestUpdateGridView(omni.kit.test.AsyncTestCase):
"""Testing FileBrowserGridViewDelegate.update_grid"""
async def setUp(self):
self._throttle_frames = 2
async def tearDown(self):
pass
async def _after_redraw_async(self):
for _ in range(self._throttle_frames + 1):
await omni.kit.app.get_app().next_update_async()
async def _mock_refresh_thumbnails_async(self, model: FileBrowserModel):
pass
def _get_badges(self, item: FileBrowserItem):
return []
async def test_update_grid_adds_new_items(self):
"""Testing FileBrowserGridView.update_grid updates the grid view successfully"""
with patch.object(FileBrowserGridViewDelegate, "refresh_thumbnails_async", side_effect=self._mock_refresh_thumbnails_async):
model = FileBrowserModel("ov-test", "omniverse://ov-test")
test_items = ["foo.usd", "bar.usd"]
test_items_path = []
for name in test_items:
model.root.add_child(FileBrowserItemFactory.create_dummy_item(name, f"{model.root.path}/{name}"))
test_items_path.append(f"{model.root.path}/{name}")
# Assert grid initially empty
under_test = FileBrowserGridView(model, testing=True)
delegate = under_test._delegate
self.assertTrue(delegate._grid is not None)
self.assertEqual(0, len(ui.Inspector.get_children(delegate._grid)))
self.assertEqual(0, len(delegate._cards))
# Grid is populated after redraw
under_test.refresh_ui()
await self._after_redraw_async()
test_card = delegate._cards[test_items_path[0]]
test_card._get_badges_fn = self._get_badges
thumbnail = test_card._get_thumbnail(test_card._item)
self.assertIsNotNone(thumbnail)
test_card._item.alert = (1, "Info")
test_card.draw_badges()
self.assertEqual(len(test_items), len(ui.Inspector.get_children(delegate._grid)))
self.assertEqual(len(test_items), len(delegate._cards))
# Adding a file updates the grid
model.root.add_child(FileBrowserItemFactory.create_dummy_item("baz.usd", f"{model.root.path}/baz.usd"))
under_test.refresh_ui()
await self._after_redraw_async()
self.assertEqual(len(test_items)+1, len(ui.Inspector.get_children(delegate._grid)))
self.assertEqual(len(test_items)+1, len(delegate._cards))
# Assert deleting orignal files leaves only the added file in place
for name in test_items:
model.root.del_child(name)
under_test.refresh_ui()
await self._after_redraw_async()
self.assertEqual(1, len(ui.Inspector.get_children(delegate._grid)))
self.assertEqual(1, len(delegate._cards))
self.assertTrue(f"{model.root.path}/baz.usd" in delegate._cards)
async def test_cut_items_style_reflected(self):
"""Testing that items in cut clipboard are applied cut style."""
from ..clipboard import save_items_to_clipboard, is_path_cut
with patch.object(FileBrowserGridViewDelegate, "refresh_thumbnails_async", side_effect=self._mock_refresh_thumbnails_async):
model = FileBrowserModel("ov-test", "omniverse://ov-test")
test_names = ["foo.usd", "bar.usd", "baz.usd"]
for name in test_names:
model.root.add_child(FileBrowserItemFactory.create_dummy_item(name, f"{model.root.path}/{name}"))
# Assert grid initially empty
under_test = FileBrowserGridView(model, testing=True)
delegate = under_test._delegate
under_test.refresh_ui()
await self._after_redraw_async()
# with empty clipboard every item should be with normal name
for path, item in delegate._cards.items():
self.assertFalse(is_path_cut(path))
self.assertEqual(item._back_buffer_thumbnail.name, "")
item.draw_badges()
# put item in clipboard
items = model.get_item_children(model.root)
cut_path = items[0].path
save_items_to_clipboard(items[0], is_cut=True)
await self._after_redraw_async()
under_test.refresh_ui()
# item in clipboard should be applied Cut style name
for path, item in delegate._cards.items():
if path == cut_path:
self.assertTrue(is_path_cut(path))
self.assertEqual(item._back_buffer_thumbnail.name, "Cut")
else:
self.assertFalse(is_path_cut(path))
self.assertEqual(item._back_buffer_thumbnail.name, "")
|
omniverse-code/kit/exts/omni.kit.widget.filebrowser/docs/CHANGELOG.md | # Changelog
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
## [2.3.10] - 2023-01-19
### Updated
- Fixed issue with NucleusItem calling `on_populated_async` with incorrect number of parameters
## [2.3.9] - 2023-01-11
### Updated
- Fixed issue with selections before cards created
## [2.3.8] - 2022-11-30
### Updated
- OM-63433: Use content_clipping to speed up item display in file picker
## [2.3.7] - 2022-11-17
### Updated
- Fixes access flags for filesystem entries.
## [2.3.6] - 2022-10-21
### Updated
- Updated signature of copy_item_async to accept source and destination path, instead of always using
the source relative path and destination root to compute the destination path.
## [2.3.4] - 2022-10-03
### Updated
- Commented out deprecation warnings.
## [2.3.3] - 2022-09-21
### Updated
- Switching between different date formats.
## [2.3.2] - 2022-09-12
### Updated
- Updates cards in grid view on thumbnails generated.
## [2.3.1] - 2022-09-01
### Updated
- Unique identifier names for tree view and list view panes.
## [2.3.0] - 2022-08-30
### Updated
- Refactored thumbnails provider
## [2.2.30] - 2022-07-19
### Updated
- Minor bug fix
## [2.2.29] - 2022-07-06
### Updated
- Fix regression to show context menu when right click on grid view.
## [2.2.28] - 2022-06-22
### Updated
- Multiple drag and drop support.
## [2.2.27] - 2022-05-26
### Updated
- Adds read-only badge to treeview items.
- Updated unit of file size to Mebibyte (instead of Megabyte)
## [2.2.25] - 2022-04-06
### Updated
- Fixes occasional startup error.
## [2.2.24] - 2022-02-18
### Updated
- Adds copy_presets method for FileBrowser models.
## [2.2.23] - 2022-02-15
### Updated
- Increases reconnect timeout to 10 mins.
## [2.2.22] - 2022-02-09
### Updated
- Fixes crash when browsing folders in grid view.
## [2.2.21] - 2022-01-20
### Updated
- Added `set_filter_fn` to the model class.
## [2.2.20] - 2022-01-05
### Updated
- Improved reconnection by skipping signout step, also increased timeout to 30 secs.
## [2.2.19] - 2021-11-24
### Updated
- Added `show_grid_view` to get grid or table view.
## [2.2.18] - 2021-11-16
### Updated
- Catches exception from tagging service that was crashing Kit.
## [2.2.17] - 2021-11-12
### Updated
- Fixes scaling of thumbnails.
## [2.2.16] - 2021-10-12
### Updated
- Notify on connection error.
## [2.2.15] - 2021-09-17
### Updated
- Added widget identifers
## [2.2.14] - 2021-09-07
### Updated
- Updated the reconnection to server flow.
## [2.2.13] - 2021-08-25
### Updated
- Fixes race condition that causes the table view to crash while auto-refreshing.
## [2.2.12] - 2021-08-12
### Updated
- Fixes multi-selection drag-n-drop from listview into viewport.
## [2.2.11] - 2021-08-09
### Updated
- Smoother update of thumbnails while populating a search filter.
## [2.2.10] - 2021-07-13
### Updated
- Moved zoom bar back from filepicker widget for better encapsulation.
## [2.2.9] - 2021-07-13
### Updated
- Update the directory path from either tree or list view.
Fixes failure when opening a file under a nested directory in the right-pane when a hierarchial view.
## [2.2.8] - 2021-06-16
### Updated
- Syncs up folder upon entering but do so incrementally instead of re-creating it.
- Change above also fixes crashing when navigating to a folder, due to a race condition for populating that folder.
## [2.2.7] - 2021-06-10
### Updated
- Ignore omni.client.ListEvent.CREATED on existing directories
## [2.2.6] - 2021-06-07
### Updated
- More thorough destruction of class instances upon shutdown.
## [2.2.5] - 2021-06-04
### Updated
- Added overwrite dialog when copying files
## [2.2.4] - 2021-05-12
### Updated
- Eliminates too many concurrent redraws of the grid view causing it to crash. This happens because
manually initiated redraws conflict the new auto refresh.
## [2.2.3] - 2021-04-16
### Updated
- Double clicking on file icon in treeview opens it.
- Lock badge repositioned to not obstruct label.
- Small files show proper size instead of 0.00 Mb.
## [2.2.2] - 2021-04-15
### Updated
- Fixes auto refresh crash when copying large number of files, by limiting number of grid view redraws to
at most once per frame.
## [2.2.1] - 2021-04-08
### Updated
- Auto refresh ignores update events, which breaks live sync mode.
## [2.2.0] - 2021-04-02
### Added
- Now auto refreshes current folder.
## [2.1.6] - 2021-03-25
### Updated
- Fixes thumbnail generator improperly skipped.
## [2.1.5] - 2021-02-16
### Updated
- Fixes thumbnails for search model.
## [2.1.4] - 2021-02-12
### Updated
- Fix for thumbnails not loading properly as part of the gather process.
## [2.1.3] - 2021-02-10
### Changes
- Updated StyleUI handling
## [2.1.2] - 2021-02-09
### Updated
- Added vertical spacing to the cards in grid view to accommodate larger font size.
## [2.1.1] - 2021-02-09
### Updated
- Fixed navigation slowness caused by processing of thumbnails.
## [2.1.0] - 2021-02-04
### Updated
- Extracted ZoomBar into its own widget and moved to omni.kit.window.filepicker extension.
## [2.0.1] - 2021-02-03
### Updated
- Refactored code for getting auto-generated thumbnails. The simplification allowed for easier testing.
- Fixed bug that was causing artifacts and mismatched thumbnails in grid view
### Added
- Unittests for navigating directories
## [2.0.0] - 2021-01-03
### Updated
- Implements omni.client.list_async to improve overall stability in case of network delays.
## [1.2.5] - 2020-12-10
### Updated
- Adds methods reconnect_url and stat_path_with_callback
- Removes method stat_path_async
## [1.2.4] - 2020-11-23
### Updated
- Fixes missing scroll bar in grid view.
## [1.2.3] - 2020-11-19
### Updated
- Supports multi-selection mouse press and double clicks.
## [1.2.2] - 2020-11-18
### Updated
- Updated to work with omni.client version 0.1.0
- Fixes: crash on double clicking in table view to open a folder.
- Fixes: cannot select item at bottom of table view.
## [1.2.1] - 2020-11-13
### Added
- Clear selections in list view whenever new directory is clicked.
## [1.2.0] - 2020-10-31
### Added
- Select and center in grid view.
## [1.1.0] - 2020-10-27
### Added
- Changed ui.Image to ui.ImageWithProvider almost everywhere in order to address UI lag.
## [0.2.5] - 2020-09-16
### Added
- Initial commit to master.
|
omniverse-code/kit/exts/omni.kit.widget.filebrowser/docs/README.md | # Kit Filebrowser Widget [omni.kit.widget.filebrowser]
The basic UI widget and set of supporting classes for navigating the filesystem through a tree view. The filesystem can either be from your local machine or the Omniverse server.
|
omniverse-code/kit/exts/omni.kit.widget.filebrowser/docs/index.rst | omni.kit.widget.filebrowser
###########################
Kit Filebrowser Widget.
.. toctree::
:maxdepth: 1
Overview
CHANGELOG
.. automodule:: omni.kit.widget.filebrowser
:platform: Windows-x86_64, Linux-x86_64
:members:
:show-inheritance:
:undoc-members:
.. autoclass:: FileBrowserWidget
:members:
.. autoclass:: FileBrowserModel
:members:
.. autoclass:: FileBrowserItem
:members:
.. autoclass:: FileSystemModel
:members:
.. autoclass:: NucleusModel
:members:
|
omniverse-code/kit/exts/omni.kit.widget.filebrowser/docs/Overview.md | # Overview
|
omniverse-code/kit/exts/omni.index.compute/ogn/docs/OgnTimestepSelector.rst | .. _omni_index_compute_timestepSelector_1:
.. _omni_index_compute_timestepSelector:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: Timestep selector
:keywords: lang-en omnigraph node threadsafe compute timestep-selector
Timestep selector
=================
.. <description>
Selects a timestep from time input
.. </description>
Installation
------------
To use this node enable :ref:`omni.index.compute<ext_omni_index_compute>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"FPS (*inputs:fps*)", "``double``", "FPS", "1.0"
"Time (*inputs:time*)", "``double``", "Time", "-1.0"
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Timestep (*outputs:timestep*)", "``int``", "Timestep", "-1"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.index.compute.timestepSelector"
"Version", "1"
"Extension", "omni.index.compute"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "None"
"uiName", "Timestep selector"
"Generated Class Name", "OgnTimestepSelectorDatabase"
"Python Module", "omni.index.compute"
|
omniverse-code/kit/exts/omni.index.compute/ogn/docs/OgnIndexDistributedComputeTechnique.rst | .. _omni_index_compute_indexDistributedComputeTechnique_1:
.. _omni_index_compute_indexDistributedComputeTechnique:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: NVIDIA IndeX distributed compute technique
:keywords: lang-en omnigraph node compute index-distributed-compute-technique
NVIDIA IndeX distributed compute technique
==========================================
.. <description>
Integration with NVIDIA IndeX distributed compute technique
.. </description>
Installation
------------
To use this node enable :ref:`omni.index.compute<ext_omni_index_compute>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"Active (*inputs:active*)", "``bool``", "If false then disable the node operation", "True"
"Compute buffers (*inputs:buffers*)", "``uint64[]``", "Input compute buffers", "[]"
"Multithreading (*inputs:threading*)", "``bool``", "Use multithreading", "True"
"Timestep (*inputs:timestep*)", "``int``", "Active timestep", "-1"
"Verbose (*inputs:verbose*)", "``int``", "Log verbose output", "0"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.index.compute.indexDistributedComputeTechnique"
"Version", "1"
"Extension", "omni.index.compute"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "None"
"uiName", "NVIDIA IndeX distributed compute technique"
"Generated Class Name", "OgnIndexDistributedComputeTechniqueDatabase"
"Python Module", "omni.index.compute"
|
omniverse-code/kit/exts/omni.index.compute/omni/index/compute/__init__.py | """There is no public API to this module."""
__all__ = []
from ._impl.extension import _PublicExtension # noqa: F401
|
omniverse-code/kit/exts/omni.index.compute/omni/index/compute/ogn/OgnTimestepSelectorDatabase.py | """Support for simplified access to data on nodes of type omni.index.compute.timestepSelector
Selects a timestep from time input
"""
import omni.graph.core as og
import omni.graph.core._omni_graph_core as _og
import omni.graph.tools.ogn as ogn
class OgnTimestepSelectorDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.index.compute.timestepSelector
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.fps
inputs.time
Outputs:
outputs.timestep
"""
# Imprint the generator and target ABI versions in the file for JIT generation
GENERATOR_VERSION = (1, 41, 3)
TARGET_VERSION = (2, 139, 12)
# This is an internal object that provides per-class storage of a per-node data dictionary
PER_NODE_DATA = {}
# This is an internal object that describes unchanging attributes in a generic way
# The values in this list are in no particular order, as a per-attribute tuple
# Name, Type, ExtendedTypeIndex, UiName, Description, Metadata,
# Is_Required, DefaultValue, Is_Deprecated, DeprecationMsg
# You should not need to access any of this data directly, use the defined database interfaces
INTERFACE = og.Database._get_interface([
('inputs:fps', 'double', 0, 'FPS', 'FPS', {ogn.MetadataKeys.DEFAULT: '1.0'}, True, 1.0, False, ''),
('inputs:time', 'double', 0, 'Time', 'Time', {ogn.MetadataKeys.DEFAULT: '-1.0'}, True, -1.0, False, ''),
('outputs:timestep', 'int', 0, 'Timestep', 'Timestep', {ogn.MetadataKeys.DEFAULT: '-1'}, True, -1, False, ''),
])
class ValuesForInputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = { }
"""Helper class that creates natural hierarchical access to input attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self._batchedReadAttributes = []
self._batchedReadValues = []
@property
def fps(self):
data_view = og.AttributeValueHelper(self._attributes.fps)
return data_view.get()
@fps.setter
def fps(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.fps)
data_view = og.AttributeValueHelper(self._attributes.fps)
data_view.set(value)
@property
def time(self):
data_view = og.AttributeValueHelper(self._attributes.time)
return data_view.get()
@time.setter
def time(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.time)
data_view = og.AttributeValueHelper(self._attributes.time)
data_view.set(value)
def _prefetch(self):
readAttributes = self._batchedReadAttributes
newValues = _og._prefetch_input_attributes_data(readAttributes)
if len(readAttributes) == len(newValues):
self._batchedReadValues = newValues
class ValuesForOutputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = { }
"""Helper class that creates natural hierarchical access to output attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self._batchedWriteValues = { }
@property
def timestep(self):
data_view = og.AttributeValueHelper(self._attributes.timestep)
return data_view.get()
@timestep.setter
def timestep(self, value):
data_view = og.AttributeValueHelper(self._attributes.timestep)
data_view.set(value)
def _commit(self):
_og._commit_output_attributes_data(self._batchedWriteValues)
self._batchedWriteValues = { }
class ValuesForState(og.DynamicAttributeAccess):
"""Helper class that creates natural hierarchical access to state attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
def __init__(self, node):
super().__init__(node)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_INPUT)
self.inputs = OgnTimestepSelectorDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnTimestepSelectorDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnTimestepSelectorDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
|
omniverse-code/kit/exts/omni.index.compute/omni/index/compute/ogn/OgnIndexDistributedComputeTechniqueDatabase.py | """Support for simplified access to data on nodes of type omni.index.compute.indexDistributedComputeTechnique
Integration with NVIDIA IndeX distributed compute technique
"""
import numpy
import omni.graph.core as og
import omni.graph.core._omni_graph_core as _og
import omni.graph.tools.ogn as ogn
class OgnIndexDistributedComputeTechniqueDatabase(og.Database):
"""Helper class providing simplified access to data on nodes of type omni.index.compute.indexDistributedComputeTechnique
Class Members:
node: Node being evaluated
Attribute Value Properties:
Inputs:
inputs.active
inputs.buffers
inputs.threading
inputs.timestep
inputs.verbose
"""
# Imprint the generator and target ABI versions in the file for JIT generation
GENERATOR_VERSION = (1, 41, 3)
TARGET_VERSION = (2, 139, 12)
# This is an internal object that provides per-class storage of a per-node data dictionary
PER_NODE_DATA = {}
# This is an internal object that describes unchanging attributes in a generic way
# The values in this list are in no particular order, as a per-attribute tuple
# Name, Type, ExtendedTypeIndex, UiName, Description, Metadata,
# Is_Required, DefaultValue, Is_Deprecated, DeprecationMsg
# You should not need to access any of this data directly, use the defined database interfaces
INTERFACE = og.Database._get_interface([
('inputs:active', 'bool', 0, 'Active', 'If false then disable the node operation', {ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:buffers', 'uint64[]', 0, 'Compute buffers', 'Input compute buffers', {ogn.MetadataKeys.DEFAULT: '[]'}, True, [], False, ''),
('inputs:threading', 'bool', 0, 'Multithreading', 'Use multithreading', {ogn.MetadataKeys.DEFAULT: 'true'}, True, True, False, ''),
('inputs:timestep', 'int', 0, 'Timestep', 'Active timestep', {ogn.MetadataKeys.DEFAULT: '-1'}, True, -1, False, ''),
('inputs:verbose', 'int', 0, 'Verbose', 'Log verbose output', {ogn.MetadataKeys.DEFAULT: '0'}, True, 0, False, ''),
])
class ValuesForInputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = { }
"""Helper class that creates natural hierarchical access to input attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self._batchedReadAttributes = []
self._batchedReadValues = []
@property
def active(self):
data_view = og.AttributeValueHelper(self._attributes.active)
return data_view.get()
@active.setter
def active(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.active)
data_view = og.AttributeValueHelper(self._attributes.active)
data_view.set(value)
@property
def buffers(self):
data_view = og.AttributeValueHelper(self._attributes.buffers)
return data_view.get()
@buffers.setter
def buffers(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.buffers)
data_view = og.AttributeValueHelper(self._attributes.buffers)
data_view.set(value)
self.buffers_size = data_view.get_array_size()
@property
def threading(self):
data_view = og.AttributeValueHelper(self._attributes.threading)
return data_view.get()
@threading.setter
def threading(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.threading)
data_view = og.AttributeValueHelper(self._attributes.threading)
data_view.set(value)
@property
def timestep(self):
data_view = og.AttributeValueHelper(self._attributes.timestep)
return data_view.get()
@timestep.setter
def timestep(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.timestep)
data_view = og.AttributeValueHelper(self._attributes.timestep)
data_view.set(value)
@property
def verbose(self):
data_view = og.AttributeValueHelper(self._attributes.verbose)
return data_view.get()
@verbose.setter
def verbose(self, value):
if self._setting_locked:
raise og.ReadOnlyError(self._attributes.verbose)
data_view = og.AttributeValueHelper(self._attributes.verbose)
data_view.set(value)
def _prefetch(self):
readAttributes = self._batchedReadAttributes
newValues = _og._prefetch_input_attributes_data(readAttributes)
if len(readAttributes) == len(newValues):
self._batchedReadValues = newValues
class ValuesForOutputs(og.DynamicAttributeAccess):
LOCAL_PROPERTY_NAMES = { }
"""Helper class that creates natural hierarchical access to output attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
self._batchedWriteValues = { }
def _commit(self):
_og._commit_output_attributes_data(self._batchedWriteValues)
self._batchedWriteValues = { }
class ValuesForState(og.DynamicAttributeAccess):
"""Helper class that creates natural hierarchical access to state attributes"""
def __init__(self, node: og.Node, attributes, dynamic_attributes: og.DynamicAttributeInterface):
"""Initialize simplified access for the attribute data"""
context = node.get_graph().get_default_graph_context()
super().__init__(context, node, attributes, dynamic_attributes)
def __init__(self, node):
super().__init__(node)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_INPUT)
self.inputs = OgnIndexDistributedComputeTechniqueDatabase.ValuesForInputs(node, self.attributes.inputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_OUTPUT)
self.outputs = OgnIndexDistributedComputeTechniqueDatabase.ValuesForOutputs(node, self.attributes.outputs, dynamic_attributes)
dynamic_attributes = self.dynamic_attribute_data(node, og.AttributePortType.ATTRIBUTE_PORT_TYPE_STATE)
self.state = OgnIndexDistributedComputeTechniqueDatabase.ValuesForState(node, self.attributes.state, dynamic_attributes)
|
omniverse-code/kit/exts/omni.index.compute/omni/index/compute/ogn/tests/TestOgnIndexDistributedComputeTechnique.py | import os
import omni.kit.test
import omni.graph.core as og
import omni.graph.core.tests as ogts
from omni.graph.core.tests.omnigraph_test_utils import _TestGraphAndNode
from omni.graph.core.tests.omnigraph_test_utils import _test_clear_scene
from omni.graph.core.tests.omnigraph_test_utils import _test_setup_scene
from omni.graph.core.tests.omnigraph_test_utils import _test_verify_scene
class TestOgn(ogts.OmniGraphTestCase):
async def test_data_access(self):
from omni.index.compute.ogn.OgnIndexDistributedComputeTechniqueDatabase import OgnIndexDistributedComputeTechniqueDatabase
test_file_name = "OgnIndexDistributedComputeTechniqueTemplate.usda"
usd_path = os.path.join(os.path.dirname(__file__), "usd", test_file_name)
if not os.path.exists(usd_path):
self.assertTrue(False, f"{usd_path} not found for loading test")
(result, error) = await ogts.load_test_file(usd_path)
self.assertTrue(result, f'{error} on {usd_path}')
test_node = og.Controller.node("/TestGraph/Template_omni_index_compute_indexDistributedComputeTechnique")
database = OgnIndexDistributedComputeTechniqueDatabase(test_node)
self.assertTrue(test_node.is_valid())
node_type_name = test_node.get_type_name()
self.assertEqual(og.GraphRegistry().get_node_type_version(node_type_name), 1)
def _attr_error(attribute: og.Attribute, usd_test: bool) -> str:
test_type = "USD Load" if usd_test else "Database Access"
return f"{node_type_name} {test_type} Test - {attribute.get_name()} value error"
self.assertTrue(test_node.get_attribute_exists("inputs:active"))
attribute = test_node.get_attribute("inputs:active")
db_value = database.inputs.active
expected_value = True
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:buffers"))
attribute = test_node.get_attribute("inputs:buffers")
db_value = database.inputs.buffers
expected_value = []
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:threading"))
attribute = test_node.get_attribute("inputs:threading")
db_value = database.inputs.threading
expected_value = True
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:timestep"))
attribute = test_node.get_attribute("inputs:timestep")
db_value = database.inputs.timestep
expected_value = -1
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:verbose"))
attribute = test_node.get_attribute("inputs:verbose")
db_value = database.inputs.verbose
expected_value = 0
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
|
omniverse-code/kit/exts/omni.index.compute/omni/index/compute/ogn/tests/TestOgnTimestepSelector.py | import os
import omni.kit.test
import omni.graph.core as og
import omni.graph.core.tests as ogts
from omni.graph.core.tests.omnigraph_test_utils import _TestGraphAndNode
from omni.graph.core.tests.omnigraph_test_utils import _test_clear_scene
from omni.graph.core.tests.omnigraph_test_utils import _test_setup_scene
from omni.graph.core.tests.omnigraph_test_utils import _test_verify_scene
class TestOgn(ogts.OmniGraphTestCase):
async def test_data_access(self):
from omni.index.compute.ogn.OgnTimestepSelectorDatabase import OgnTimestepSelectorDatabase
test_file_name = "OgnTimestepSelectorTemplate.usda"
usd_path = os.path.join(os.path.dirname(__file__), "usd", test_file_name)
if not os.path.exists(usd_path):
self.assertTrue(False, f"{usd_path} not found for loading test")
(result, error) = await ogts.load_test_file(usd_path)
self.assertTrue(result, f'{error} on {usd_path}')
test_node = og.Controller.node("/TestGraph/Template_omni_index_compute_timestepSelector")
database = OgnTimestepSelectorDatabase(test_node)
self.assertTrue(test_node.is_valid())
node_type_name = test_node.get_type_name()
self.assertEqual(og.GraphRegistry().get_node_type_version(node_type_name), 1)
def _attr_error(attribute: og.Attribute, usd_test: bool) -> str:
test_type = "USD Load" if usd_test else "Database Access"
return f"{node_type_name} {test_type} Test - {attribute.get_name()} value error"
self.assertTrue(test_node.get_attribute_exists("inputs:fps"))
attribute = test_node.get_attribute("inputs:fps")
db_value = database.inputs.fps
expected_value = 1.0
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("inputs:time"))
attribute = test_node.get_attribute("inputs:time")
db_value = database.inputs.time
expected_value = -1.0
actual_value = og.Controller.get(attribute)
ogts.verify_values(expected_value, actual_value, _attr_error(attribute, True))
ogts.verify_values(expected_value, db_value, _attr_error(attribute, False))
self.assertTrue(test_node.get_attribute_exists("outputs:timestep"))
attribute = test_node.get_attribute("outputs:timestep")
db_value = database.outputs.timestep
|
omniverse-code/kit/exts/omni.index.compute/omni/index/compute/ogn/tests/__init__.py | """====== GENERATED BY omni.graph.tools - DO NOT EDIT ======"""
import omni.graph.tools._internal as ogi
ogi.import_tests_in_directory(__file__, __name__)
|
omniverse-code/kit/exts/omni.index.compute/omni/index/compute/bindings/_omni_index_compute.pyi | """pybind11 omni.index.compute bindings"""
from __future__ import annotations
import omni.index.compute.bindings._omni_index_compute
import typing
__all__ = [
"IOmniGraphIndex",
"acquire_interface",
"release_interface"
]
class IOmniGraphIndex():
pass
def acquire_interface(plugin_name: str = None, library_path: str = None) -> IOmniGraphIndex:
pass
def release_interface(arg0: IOmniGraphIndex) -> None:
pass
|
omniverse-code/kit/exts/omni.index.compute/omni/index/compute/tests/test_api.py | """Testing the stability of the API in this module"""
import omni.graph.core.tests as ogts
import omni.index.compute as ogidx
from omni.graph.tools.tests.internal_utils import _check_module_api_consistency, _check_public_api_contents
# ======================================================================
class _TestOmniGraphIndexApi(ogts.OmniGraphTestCase):
_UNPUBLISHED = ["bindings", "ogn", "tests"]
async def test_api(self):
_check_module_api_consistency(ogidx, self._UNPUBLISHED) # noqa: PLW0212
_check_module_api_consistency(ogidx.tests, is_test_module=True) # noqa: PLW0212
async def test_api_features(self):
"""Test that the known public API features continue to exist"""
_check_public_api_contents(ogidx, [], self._UNPUBLISHED, only_expected_allowed=True) # noqa: PLW0212
_check_public_api_contents(ogidx.tests, [], [], only_expected_allowed=True) # noqa: PLW0212
|
omniverse-code/kit/exts/omni.index.compute/omni/index/compute/tests/__init__.py | """There is no public API to this module."""
__all__ = []
scan_for_test_modules = True
"""The presence of this object causes the test runner to automatically scan the directory for unit test cases"""
|
omniverse-code/kit/exts/omni.kit.manipulator.selector/omni/kit/manipulator/selector/manipulator_order_manager.py | # Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
from typing import Callable, Dict
import carb.settings
MANIPULATOR_ORDERS_SETTING_PATH = "/persistent/exts/omni.kit.manipulator.selector/orders"
class ManipulatorOrderManager:
def __init__(self):
self._on_orders_changed_fns_id = 0
self._on_orders_changed_fns: Dict[Callable] = {}
self._settings = carb.settings.get_settings()
self._sub = self._settings.subscribe_to_tree_change_events(
MANIPULATOR_ORDERS_SETTING_PATH, self._on_setting_changed
)
self._orders_dict: Dict[str, int] = {}
self._refresh_orders()
def destroy(self):
if self._sub:
self._settings.unsubscribe_to_change_events(self._sub)
self._sub = None
def __del__(self):
self.destroy()
@property
def orders_dict(self) -> Dict[str, int]:
return self._orders_dict
def subscribe_to_orders_changed(self, fn: Callable) -> int:
self._on_orders_changed_fns_id += 1
self._on_orders_changed_fns[self._on_orders_changed_fns_id] = fn
return self._on_orders_changed_fns_id
def unsubscribe_to_orders_changed(self, id: int):
self._on_orders_changed_fns.pop(id, None)
def _on_setting_changed(self, tree_item, changed_item, event_type):
self._refresh_orders()
def _refresh_orders(self):
self._orders_dict = self._settings.get_settings_dictionary(MANIPULATOR_ORDERS_SETTING_PATH)
for fn in self._on_orders_changed_fns.values():
fn()
|
omniverse-code/kit/exts/omni.kit.manipulator.selector/omni/kit/manipulator/selector/extension.py | # Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
from typing import Dict
import omni.ext
from .manipulator_order_manager import ManipulatorOrderManager
from .manipulator_selector import ManipulatorSelector
_selectors: Dict[str, ManipulatorSelector] = {}
_order_manager: ManipulatorOrderManager = None
# Each UsdContext has a ManipulatorSelector to subscribe to selection event
def get_manipulator_selector(usd_context_name: str) -> ManipulatorSelector:
global _selectors
global _order_manager
if usd_context_name not in _selectors:
selector = ManipulatorSelector(_order_manager, usd_context_name)
_selectors[usd_context_name] = selector
return selector
return _selectors[usd_context_name]
class ManipulatorPrim(omni.ext.IExt):
def on_startup(self, ext_id):
global _order_manager
assert _order_manager is None
_order_manager = ManipulatorOrderManager()
def on_shutdown(self):
global _selectors
global _order_manager
for selector in _selectors.values():
selector.destroy()
_selectors.clear()
if _order_manager:
_order_manager.destroy()
_order_manager = None
|
omniverse-code/kit/exts/omni.kit.manipulator.selector/omni/kit/manipulator/selector/manipulator_selector.py | # Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
from __future__ import annotations
from typing import TYPE_CHECKING, Dict, Set
import carb.events
import carb.settings
import omni.usd
from pxr import Sdf
if TYPE_CHECKING:
from .manipulator_base import ManipulatorBase, ManipulatorOrderManager
class ManipulatorSelector:
def __init__(self, order_manager: ManipulatorOrderManager, usd_context_name: str):
self._order_manager = order_manager
self._usd_context_name = usd_context_name
self._manipulators: Dict[str, Set[ManipulatorBase]] = {}
self._usd_context = omni.usd.get_context(usd_context_name)
self._stage_event_sub = self._usd_context.get_stage_event_stream().create_subscription_to_pop_by_type(
int(omni.usd.StageEventType.SELECTION_CHANGED),
self._on_stage_selection_event,
name="ManipulatorSelector stage event",
)
self._order_sub = self._order_manager.subscribe_to_orders_changed(self._on_orders_changed)
self._refresh()
def destroy(self):
self._stage_event_sub = None
if self._order_sub:
self._order_manager.unsubscribe_to_orders_changed(self._order_sub)
self._order_sub = None
def __del__(self):
self.destroy()
def register_manipulator_instance(self, name: str, manipulator: ManipulatorBase):
needs_sort = False
if name not in self._manipulators:
self._manipulators[name] = set()
needs_sort = True
self._manipulators[name].add(manipulator)
if needs_sort:
self._sort()
self._refresh()
def unregister_manipulator_instance(self, name: str, manipulator: ManipulatorBase):
manipulator_set = self._manipulators.get(name, set())
manipulator_set.remove(manipulator)
self._refresh()
def _sort(self) -> bool:
orders_dict = self._order_manager.orders_dict
# sort by order
sorted_manipulators = dict(sorted(self._manipulators.items(), key=lambda item: orders_dict.get(item[0], 0)))
# compare keys to check order difference (direct dicts compare are equal if their content is same but in
# different order)
if sorted_manipulators != self._manipulators or list(sorted_manipulators.keys()) != list(
self._manipulators.keys()
):
self._manipulators = sorted_manipulators
return True
return False
def _refresh(self):
if self._usd_context.get_stage_state() == omni.usd.StageState.OPENED:
self._on_selection_changed()
def _on_stage_selection_event(self, event: carb.events.IEvent):
self._on_selection_changed()
def _on_selection_changed(self):
selection = self._usd_context.get_selection().get_selected_prim_paths()
selection_sdf = [Sdf.Path(path) for path in selection]
for _, manipulators in self._manipulators.items():
handled = False
for manipulator in manipulators:
if manipulator.on_selection_changed(self._usd_context.get_stage(), selection_sdf):
manipulator.enabled = True
handled = True
else:
manipulator.enabled = False
if handled:
# Set selection_sdf to None to signal subsequent manipulator the selection has been handled
# This is different from being empty []
selection_sdf = None
def _on_orders_changed(self):
if self._sort():
self._refresh()
|
omniverse-code/kit/exts/omni.kit.manipulator.selector/omni/kit/manipulator/selector/__init__.py | from .extension import *
from .manipulator_base import ManipulatorBase
|
omniverse-code/kit/exts/omni.kit.manipulator.selector/omni/kit/manipulator/selector/manipulator_base.py | # Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
import asyncio
from abc import ABC, abstractmethod
from typing import List, Union
from pxr import Sdf, Usd
from .extension import get_manipulator_selector
class ManipulatorBase(ABC):
"""
Base class for prim manipulator that works with ManipulatorSelector.
Instead of subscribing to UsdStageEvent for selection change, manipulator should inherit this class and implements
all abstractmethods to support choosing between multiple types of prim manipulators based on their order and enable
criterions.
The order of the manipulator is specified at carb.settings path `/persistent/exts/omni.kit.manipulator.selector/orders/<name>"`
"""
def __init__(self, name: str, usd_context_name: str):
"""
Constructor.
Args:
name (str): name of the manipulator. It must match the <name> in the setting path specifies order.
usd_context_name (str): name of the UsdContext this manipulator operates on.
"""
self._name = name
self._selector = get_manipulator_selector(usd_context_name)
self._register_task = None
self._registered = None
# do an async registration so that the child class __init__ has a chance to finish first.
self._delayed_register()
def destroy(self):
if self._register_task and not self._register_task.done():
self._register_task.cancel()
self._register_task = None
if self._registered:
self._selector.unregister_manipulator_instance(self._name, self)
self._registered = False
def __del__(self):
self.destroy()
@abstractmethod
def on_selection_changed(self, stage: Usd.Stage, selection: Union[List[Sdf.Path], None], *args, **kwargs) -> bool:
"""
Function called when selection changes or types of prim manipulators are added or removed.
Args:
stage (Usd.Stage): the usd stage of which the selection change happens. It is the same as the stage of the
UsdContext this manipulator works on.
selection (Union[List[Sdf.Path], None]): the list of selected prim paths. If it is None (different from []),
it means another manipulator with higher priority has handled the
selection and this manipulator should yield.
Return:
True if selected prim paths can be handled by this manipulator and subsequent manipulator with higher order
should yield.
False if selected prim paths can not be handled. Function should always return False if `selection` is None.
"""
raise NotImplementedError("Derived class must implement on_selection_changed")
return False
@property
@abstractmethod
def enabled(self) -> bool:
"""
Returns if this manipulator is enabled.
"""
raise NotImplementedError('Derived class must implement "enabled" getter')
return False
@enabled.setter
@abstractmethod
def enabled(self, value: bool):
"""
Sets if this manipulator is enabled. A disabled manipulator should hide itself.
"""
raise NotImplementedError('Derived class must implement "enabled" setter')
def _delayed_register(self):
async def register_manipulator():
self._selector.register_manipulator_instance(self._name, self)
self._registered = True
self._register_task = asyncio.ensure_future(register_manipulator())
|
omniverse-code/kit/exts/omni.kit.manipulator.selector/omni/kit/manipulator/selector/tests/test_manipulator.py | # Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
from typing import List, Union
from omni.kit.manipulator.prim.prim_transform_manipulator import PrimTransformManipulator
from omni.kit.manipulator.transform import get_default_style
from omni.kit.manipulator.transform.settings_constants import c
from omni.kit.viewport.registry import RegisterScene
from pxr import Sdf, Usd, UsdGeom
# Creates a test manipulator that is white and half in size when selecting a mesh
class PrimTransformManipulatorMeshTest(PrimTransformManipulator):
def __init__(self, usd_context_name: str = "", viewport_api=None):
super().__init__(
usd_context_name=usd_context_name,
viewport_api=viewport_api,
name="omni.kit.manipulator.test_mesh_prim",
size=0.5,
)
def _create_local_global_styles(self):
super()._create_local_global_styles()
global_style = get_default_style()
global_style["Translate.Axis::x"]["color"] = 0xFFFFFFFF
global_style["Translate.Axis::y"]["color"] = 0xFFFFFFFF
global_style["Translate.Axis::z"]["color"] = 0xFFFFFFFF
self._styles[c.TRANSFORM_MODE_GLOBAL] = global_style
def on_selection_changed(self, stage: Usd.Stage, selection: Union[List[Sdf.Path], None], *args, **kwargs) -> bool:
if selection is None:
self.model.on_selection_changed([])
return False
self.model.on_selection_changed(selection)
for path in selection:
prim = stage.GetPrimAtPath(path)
if prim.IsA(UsdGeom.Mesh):
return True
return False
class PrimTransformManipulatorScene:
def __init__(self, desc: dict):
usd_context_name = desc.get("usd_context_name")
self.__transform_manip_override = PrimTransformManipulatorMeshTest(
usd_context_name=usd_context_name, viewport_api=desc.get("viewport_api")
)
def destroy(self):
if self.__transform_manip_override:
self.__transform_manip_override.destroy()
self.__transform_manip_override = None
# PrimTransformManipulator & TransformManipulator don't have their own visibility
@property
def visible(self):
return True
@visible.setter
def visible(self, value):
pass
@property
def categories(self):
return ("manipulator",)
@property
def name(self):
return "Test Mesh Prim Transform"
class TransformManipulatorRegistry:
def __init__(self):
self._scene = RegisterScene(PrimTransformManipulatorScene, "omni.kit.manipulator.test_mesh_prim")
def __del__(self):
self.destroy()
def destroy(self):
self._scene = None
|
omniverse-code/kit/exts/omni.kit.manipulator.selector/omni/kit/manipulator/selector/tests/__init__.py | # Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
from .test_manipulator_selector import TestSelector
|
omniverse-code/kit/exts/omni.kit.manipulator.selector/omni/kit/manipulator/selector/tests/test_manipulator_selector.py | # Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
import omni.kit.test
import inspect
import logging
import os
from pathlib import Path
from omni.kit.test.teamcity import is_running_in_teamcity
import sys
import unittest
import carb
import carb.input
import carb.settings
import omni.kit.commands
import omni.kit.ui_test as ui_test
import omni.kit.undo
import omni.kit.viewport.utility
import omni.usd
from omni.kit.manipulator.prim.settings_constants import Constants as prim_c
from omni.kit.manipulator.transform.settings_constants import c
from omni.kit.test_helpers_gfx.compare_utils import ComparisonMetric, capture_and_compare
from omni.kit.ui_test import Vec2
from omni.ui.tests.test_base import OmniUiTest
CURRENT_PATH = Path(f"{omni.kit.app.get_app().get_extension_manager().get_extension_path_by_module(__name__)}/data")
OUTPUTS_DIR = Path(omni.kit.test.get_test_output_path()).resolve().absolute()
logger = logging.getLogger(__name__)
class TestSelector(OmniUiTest):
# Before running each test
async def setUp(self):
await super().setUp()
self._context = omni.usd.get_context()
self._selection = self._context.get_selection()
self._settings = carb.settings.get_settings()
self._golden_img_dir = CURRENT_PATH.absolute().resolve().joinpath("tests").joinpath("golden")
self._usd_scene_dir = CURRENT_PATH.absolute().resolve().joinpath("tests").joinpath("usd")
await self._setup()
# After running each test
async def tearDown(self):
self._golden_img_dir = None
await super().tearDown()
async def _snapshot(self, golden_img_name: str = "", threshold: float = 2e-4):
await ui_test.human_delay()
test_fn_name = ""
for frame_info in inspect.stack():
if os.path.samefile(frame_info[1], __file__):
test_fn_name = frame_info[3]
golden_img_name = f"{test_fn_name}.{golden_img_name}.png"
# Because we're testing RTX renderered pixels, use a better threshold filter for differences
diff = await capture_and_compare(
golden_img_name,
threshold=threshold,
output_img_dir=OUTPUTS_DIR,
golden_img_dir=self._golden_img_dir,
metric=ComparisonMetric.MEAN_ERROR_SQUARED,
)
self.assertLessEqual(
diff,
threshold,
f"The generated image {golden_img_name} has a difference of {diff}, but max difference is {threshold}",
)
async def _setup(
self,
scene_file: str = "test_scene.usda",
enable_toolbar: bool = False,
):
usd_path = self._usd_scene_dir.joinpath(scene_file)
success, error = await self._context.open_stage_async(str(usd_path))
self.assertTrue(success, error)
# move the mouse out of the way
await ui_test.emulate_mouse_move(Vec2(0, 0))
await ui_test.human_delay()
self._settings.set(prim_c.MANIPULATOR_PLACEMENT_SETTING, prim_c.MANIPULATOR_PLACEMENT_LAST_PRIM_PIVOT)
self._settings.set(c.TRANSFORM_MOVE_MODE_SETTING, c.TRANSFORM_MODE_GLOBAL)
self._settings.set(c.TRANSFORM_ROTATE_MODE_SETTING, c.TRANSFORM_MODE_GLOBAL)
self._settings.set(c.TRANSFORM_OP_SETTING, c.TRANSFORM_OP_MOVE)
self._settings.set("/app/viewport/snapEnabled", False)
self._settings.set("/persistent/app/viewport/snapToSurface", False)
self._settings.set("/exts/omni.kit.manipulator.prim/tools/enabled", enable_toolbar)
@unittest.skipIf(is_running_in_teamcity() and sys.platform.startswith("linux"), "OM-84020")
async def test_multi_manipulator_selector(self):
from .test_manipulator import PrimTransformManipulatorMeshTest, TransformManipulatorRegistry
# Select the /Cube, should show default manipulator
self._selection.set_selected_prim_paths(["/Cube"], True)
await ui_test.human_delay()
await self._snapshot("default_mesh")
# Select the /Xform, should show default manipulator
self._selection.set_selected_prim_paths(["/World"], True)
await ui_test.human_delay()
await self._snapshot("default_xform")
# Register the test manipulator that is specialized for Mesh
active_vp_window = omni.kit.viewport.utility.get_active_viewport_window()
if hasattr(active_vp_window, "legacy_window"):
test_manipulator = PrimTransformManipulatorMeshTest()
else:
test_manipulator = TransformManipulatorRegistry()
await ui_test.human_delay()
# Select the /Cube, should show overridden manipulator
self._selection.set_selected_prim_paths(["/Cube"], True)
await ui_test.human_delay()
await self._snapshot("overridden_mesh")
# Select the /Xform, should still show default manipulator as it's not a mesh
self._selection.set_selected_prim_paths(["/World"], True)
await ui_test.human_delay()
await self._snapshot("default_xform")
# Remove the overridden manipulator
test_manipulator.destroy()
test_manipulator = None
# Select the /Cube, should revert back to default manipulator
self._selection.set_selected_prim_paths(["/Cube"], True)
await ui_test.human_delay()
await self._snapshot("default_mesh")
|
omniverse-code/kit/exts/omni.kit.manipulator.selector/docs/index.rst | omni.kit.manipulator.selector
################################
Prim Manipulator Selector Extension
.. toctree::
:maxdepth: 1
CHANGELOG
.. automodule:: omni.kit.manipulator.selector
:platform: Windows-x86_64, Linux-x86_64
:members:
:undoc-members:
:show-inheritance:
:imported-members:
:exclude-members: contextmanager
|
omniverse-code/kit/exts/omni.usd.schema.semantics/pxr/Semantics/__init__.py | #
#====
# Copyright (c) 2018, NVIDIA CORPORATION
#======
#
#
# Copyright 2016 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
# 6. Trademarks. This License does not grant permission to use the trade
# names, trademarks, service marks, or product names of the Licensor
# and its affiliates, except as required to comply with Section 4(c) of
# the License and to reproduce the content of the NOTICE file.
#
# You may obtain a copy of the Apache License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Apache License with the above modification is
# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the Apache License for the specific
# language governing permissions and limitations under the Apache License.
#
import os
import sys
import platform
py38 = (3,8)
current_version = sys.version_info
if platform.system() == "Windows" and current_version >= py38:
from pathlib import Path
os.add_dll_directory(Path.joinpath(Path(os.path.dirname(__file__)), Path('..\\..\\')).__str__())
from . import _semanticAPI
from pxr import Tf
Tf.PrepareModule(_semanticAPI, locals())
del Tf
try:
import __DOC
__DOC.Execute(locals())
del __DOC
except Exception:
try:
import __tmpDoc
__tmpDoc.Execute(locals())
del __tmpDoc
except:
pass
|
omniverse-code/kit/exts/omni.usd.schema.semantics/pxr/Semantics/_semanticAPI.pyi | from __future__ import annotations
import pxr.Semantics._semanticAPI
import typing
import Boost.Python
import pxr.Usd
__all__ = [
"SemanticsAPI"
]
class SemanticsAPI(pxr.Usd.APISchemaBase, pxr.Usd.SchemaBase, Boost.Python.instance):
@staticmethod
def Apply(*args, **kwargs) -> None: ...
@staticmethod
def CanApply(*args, **kwargs) -> None: ...
@staticmethod
def CreateSemanticDataAttr(*args, **kwargs) -> None: ...
@staticmethod
def CreateSemanticTypeAttr(*args, **kwargs) -> None: ...
@staticmethod
def Get(*args, **kwargs) -> None: ...
@staticmethod
def GetAll(*args, **kwargs) -> None: ...
@staticmethod
def GetSchemaAttributeNames(*args, **kwargs) -> None: ...
@staticmethod
def GetSemanticDataAttr(*args, **kwargs) -> None: ...
@staticmethod
def GetSemanticTypeAttr(*args, **kwargs) -> None: ...
@staticmethod
def IsSemanticsAPIPath(*args, **kwargs) -> None: ...
@staticmethod
def _GetStaticTfType(*args, **kwargs) -> None: ...
__instance_size__ = 48
pass
class _CanApplyResult(Boost.Python.instance):
@property
def whyNot(self) -> None:
"""
:type: None
"""
__instance_size__ = 56
pass
__MFB_FULL_PACKAGE_NAME = 'semanticAPI'
|
omniverse-code/kit/exts/omni.usd.schema.semantics/plugins/SemanticAPI/resources/generatedSchema.usda | #usda 1.0
(
"WARNING: THIS FILE IS GENERATED BY usdGenSchema. DO NOT EDIT."
)
class "SemanticsAPI"
{
string semantic:__INSTANCE_NAME__:params:semanticData (
doc = "String value of the semantic data"
)
string semantic:__INSTANCE_NAME__:params:semanticType (
doc = "String value of the semantic type"
)
}
|
omniverse-code/kit/exts/omni.usd.schema.semantics/plugins/SemanticAPI/resources/SemanticAPI/schema.usda | #usda 1.0
(
subLayers = [
@usd/schema.usda@
]
)
over "GLOBAL" (
customData = {
string libraryName = "semantics"
string libraryPath = "./"
string libraryPrefix = "Semantics"
}
) {
}
class "SemanticsAPI" (
inherits = </APISchemaBase>
customData = {
token apiSchemaType = "multipleApply"
token propertyNamespacePrefix = "semantic"
}
)
{
# Should we have a "string version" field?
string params:semanticType (
customData = {
string apiName = "semanticType"
}
doc = "String value of the semantic type"
)
string params:semanticData (
customData = {
string apiName = "semanticData"
}
doc = "String value of the semantic data"
)
# Should we have a "color4f color" field?
}
|
omniverse-code/kit/exts/omni.rtx.index_composite/omni/rtx/index_composite/__init__.py | |
omniverse-code/kit/exts/omni.rtx.index_composite/omni/rtx/index_composite/tests/nvindex_rtx_composite_render_test.py | #!/usr/bin/env python3
import carb
import omni.kit.commands
import omni.kit.test
import omni.usd
from omni.rtx.tests import RtxTest, testSettings, postLoadTestSettings
from omni.rtx.tests.test_common import set_transform_helper, wait_for_update
from omni.kit.test_helpers_gfx.compare_utils import ComparisonMetric
from pxr import Sdf, Gf, UsdVol
from pathlib import Path
EXTENSION_DIR = Path(omni.kit.app.get_app().get_extension_manager().get_extension_path_by_module(__name__))
TESTS_DIR = EXTENSION_DIR.joinpath('data', 'tests')
USD_DIR = TESTS_DIR.joinpath('usd')
GOLDEN_IMAGES_DIR = TESTS_DIR.joinpath('golden')
VOLUMES_DIR = TESTS_DIR.joinpath('volumes')
OUTPUTS_DIR = Path(omni.kit.test.get_test_output_path())
# This class is auto-discoverable by omni.kit.test
class IndexRtxCompositeRenderTest(RtxTest):
WINDOW_SIZE = (512, 512)
THRESHOLD = 1e-6
async def setUp(self):
await super().setUp()
self.set_settings(testSettings)
self.ctx.new_stage()
self.add_dir_light()
await omni.kit.app.get_app().next_update_async()
self.set_settings(postLoadTestSettings)
# Overridden with custom paths
async def capture_and_compare(self, img_subdir: Path = "", golden_img_name=None, threshold=THRESHOLD,
metric: ComparisonMetric = ComparisonMetric.MEAN_ERROR_SQUARED):
golden_img_dir = GOLDEN_IMAGES_DIR.joinpath(img_subdir)
output_img_dir = OUTPUTS_DIR.joinpath(img_subdir)
if not golden_img_name:
golden_img_name = f"{self.__test_name}.png"
return await self._capture_and_compare(golden_img_name, threshold, output_img_dir, golden_img_dir, metric)
# Overridden with custom paths
def open_usd(self, usdSubpath: Path):
path = USD_DIR.joinpath(usdSubpath)
self.ctx.open_stage(str(path))
async def run_imge_test(self, usd_file: str, image_name: str, fn = None, threshold=THRESHOLD):
if usd_file:
self.open_usd(usd_file)
if fn:
fn()
await wait_for_update()
await self.capture_and_compare(golden_img_name=image_name, threshold=threshold)
#
# The tests
#
async def test_render_torus_volume_with_geometry(self):
self.open_usd('torus-volume-with-geometry.usda')
settings = carb.settings.get_settings()
for depth_mode in [0, 1, 2, 3]:
settings.set("/rtx/index/compositeDepthMode", depth_mode)
await wait_for_update()
# Non-stable depth mode is more noisy
threshold = (1e-2 if depth_mode == 2 else IndexRtxCompositeRenderTest.THRESHOLD)
await self.run_imge_test(None, f"nvindex-torus-composite-depth-mode-{depth_mode}.png", threshold=threshold)
|
omniverse-code/kit/exts/omni.rtx.index_composite/omni/rtx/index_composite/tests/__init__.py | from .nvindex_rtx_composite_render_test import *
|
omniverse-code/kit/exts/omni.kit.usd_undo/omni/kit/usd_undo/__init__.py | from .layer_undo import *
|
omniverse-code/kit/exts/omni.kit.usd_undo/omni/kit/usd_undo/layer_undo.py | from pxr import Sdf, Usd
class UsdLayerUndo:
class Key:
def __init__(self, path, info):
self.path = path
self.info = info
def __init__(self, layer: Sdf.Layer):
self._layer = layer
self.reset()
def reserve(self, path: Sdf.Path, info=None):
# Check if it's included by any added paths
path = Sdf.Path(path)
for added_key in self._paths:
if path.HasPrefix(added_key.path) and added_key.info is None:
return
# Check if it includes any added paths
if info is None:
for added_key in self._paths:
if added_key.path.HasPrefix(path):
self._paths.pop(added_key)
# If it doesn't exist, it's new spec. No need to reserve anything.
key = self.Key(path, info)
if not self._layer.GetObjectAtPath(path):
self._paths[key] = True
return
else:
self._paths[key] = False
# Reserve existing data
if info is None:
Sdf.CreatePrimInLayer(self._reserve_layer, path.GetParentPath())
Sdf.CopySpec(self._layer, path, self._reserve_layer, path)
else:
# We must know attribute type to create it in layer. So we don't handle it here.
if path.IsPropertyPath():
raise Exception("Property info is not supported.")
spec = self._layer.GetObjectAtPath(path)
Sdf.CreatePrimInLayer(self._reserve_layer, path)
reserve_spec = self._reserve_layer.GetObjectAtPath(path)
reserve_spec.SetInfo(info, spec.GetInfo(info))
def undo(self):
batch_edit = Sdf.BatchNamespaceEdit()
for key, new_spec in self._paths.items():
spec = self._layer.GetObjectAtPath(key.path)
reserve_spec = self._reserve_layer.GetObjectAtPath(key.path)
if new_spec:
# Remove new added spec
if spec:
batch_edit.Add(Sdf.NamespaceEdit.Remove(key.path))
elif key.info is None:
# Restore spec
Sdf.CopySpec(self._reserve_layer, key.path, self._layer, key.path)
else:
# Restore spec info
spec.SetInfo(key.info, reserve_spec.GetInfo(key.info))
self._layer.Apply(batch_edit)
def reset(self):
self._reserve_layer = Sdf.Layer.CreateAnonymous()
self._paths = {}
class UsdEditTargetUndo:
def __init__(self, edit_target: Usd.EditTarget):
self._edit_target = edit_target
self._layer_undo = UsdLayerUndo(self._edit_target.GetLayer())
def reserve(self, path: Sdf.Path, info=None):
self._layer_undo.reserve(path, info)
def undo(self):
self._layer_undo.undo()
def reset(self):
self._layer_undo.reset()
|
omniverse-code/kit/exts/omni.kit.usd_undo/omni/kit/usd_undo/tests/__init__.py | from .test import *
|
omniverse-code/kit/exts/omni.kit.usd_undo/omni/kit/usd_undo/tests/test.py | import omni.kit.test
from ..layer_undo import *
from pxr import Sdf, Usd, UsdGeom, Kind, Gf
class TestUsdUndo(omni.kit.test.AsyncTestCase):
async def test_layer_undo(self):
stage = Usd.Stage.CreateInMemory()
usd_undo = UsdEditTargetUndo(stage.GetEditTarget())
mesh = UsdGeom.Mesh.Define(stage, "/root")
mesh.CreateNormalsAttr().Set([Gf.Vec3f(1, 0, 0)])
mesh.SetNormalsInterpolation("constant")
model = Usd.ModelAPI(mesh)
model.SetKind(Kind.Tokens.group)
org_stage_str = stage.ExportToString()
print("Original stage:")
print(org_stage_str)
usd_undo.reserve("/root.normals")
mesh.GetNormalsAttr().Set([Gf.Vec3f(0, 1, 0)])
mesh.SetNormalsInterpolation("faceVarying")
usd_undo.reserve("/root", "kind")
model.SetKind(Kind.Tokens.component)
usd_undo.reserve("/root/newPrim")
stage.DefinePrim("/root/newPrim")
modified_stage_str = stage.ExportToString()
print("Modified stage:")
print(modified_stage_str)
assert org_stage_str != modified_stage_str
usd_undo.undo()
undone_stage_str = stage.ExportToString()
print("Undone stage:")
print(undone_stage_str)
assert org_stage_str == undone_stage_str
|
omniverse-code/kit/exts/omni.kit.usd_undo/docs/index.rst | omni.kit.usd_undo
###########################
Utitlity to implement undo for USD layer.
``UsdLayerUndo`` class is the utility to help you to implement USD undo. It reserves the state of a path, which could be a prim path or a property path. And when you call ``UsdLayerUndo.undo()``, those paths will be restored to their reserved state.
Example:
.. code:: python
import omni.kit.usd_undo
usd_undo = omni.kit.usd_undo.UsdLayerUndo(stage.GetEditTarget().GetLayer())
usd_undo.reserve("/root/prim")
'''Do anything to prim /root/prim here, including creating/deleting prim,
modifying/creating/deleting meta data or fields, modifying/creating/deleting
any attributes, modifying/creating/deleting any descendants, etc.'''
usd_undo.reserve("root/prim2.prop")
'''Do anything to property root/prim2.prop here, including creating, deleting,
modifying, etc.'''
usd_undo.reserve("root/prim2", Usd.Tokens.apiSchemas)
'''Do anything to apiSchemas field of prim root/prim2 here.'''
# Call UsdLayerUndo.undo() to revert all changes of those paths.
usd_undo.undo()
|
omniverse-code/kit/exts/omni.kit.manipulator.selection/omni/kit/manipulator/selection/__init__.py | # Expose these for easier import via from omni.kit.manipulator.selection import XXX
from .manipulator import SelectionManipulator, SelectionMode
|
omniverse-code/kit/exts/omni.kit.manipulator.selection/omni/kit/manipulator/selection/model.py | # Copyright (c) 2021-2022, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
from omni.ui import scene as sc
from typing import List, Sequence, Union
class SelectionShapeModel(sc.AbstractManipulatorModel):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.__items = {
"ndc_start": (sc.AbstractManipulatorItem(), 2),
"ndc_current": (sc.AbstractManipulatorItem(), 2),
"ndc_rect": (sc.AbstractManipulatorItem(), 4),
"mode": (sc.AbstractManipulatorItem(), 1),
"live_update": (sc.AbstractManipulatorItem(), 1)
}
self.__ndc_ret_item = self.__items.get('ndc_rect')[0]
self.__values = {item: [] for item, _ in self.__items.values()}
def __validate_arguments(self, name: Union[str, sc.AbstractManipulatorItem], values: Sequence[Union[int, float]] = None) -> sc.AbstractManipulatorItem:
if isinstance(name, sc.AbstractManipulatorItem):
return name
item, expected_len = self.__items.get(name, (None, None))
if item is None:
raise KeyError(f"SelectionShapeModel doesn't understand values of {name}")
if values and len(values) != expected_len:
raise ValueError(f"SelectionShapeModel {name} takes {expected_len} values, got {len(values)}")
return item
def get_item(self, name: str) -> sc.AbstractManipulatorItem():
return self.__items.get(name, (None, None))[0]
def set_ints(self, name: str, values: Sequence[int]):
item = self.__validate_arguments(name, values)
self.__values[item] = values
def set_floats(self, name: str, values: Sequence[int]):
item = self.__validate_arguments(name, values)
self.__values[item] = values
def get_as_ints(self, name: str) -> List[int]:
item = self.__validate_arguments(name)
return self.__values[item]
def get_as_floats(self, name: str) -> List[float]:
item = self.__validate_arguments(name)
if item == self.__ndc_ret_item:
ndc_start, ndc_end = self.__values[self.get_item('ndc_start')], self.__values[self.get_item('ndc_current')]
if not ndc_start:
return []
if not ndc_end:
ndc_end = ndc_start
min_x = min(ndc_start[0], ndc_end[0])
max_x = max(ndc_start[0], ndc_end[0])
min_y = min(ndc_start[1], ndc_end[1])
max_y = max(ndc_start[1], ndc_end[1])
return [min_x, min_y, max_x, max_y]
return self.__values[item]
|
omniverse-code/kit/exts/omni.kit.manipulator.selection/omni/kit/manipulator/selection/manipulator.py | # Copyright (c) 2021-2022, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
__all__ = ['SelectionManipulator', 'SelectionMode']
import carb.input
from omni.ui import scene as sc
from .model import SelectionShapeModel
from pxr import Gf
from typing import List
import weakref
class SelectionMode:
REPLACE = 0
APPEND = 1
REMOVE = 2
def _optional_bool(model: sc.AbstractManipulatorModel, item: str, default_value: bool = False):
values = model.get_as_ints(item)
return values[0] if values else default_value
class _KeyDown:
def __init__(self):
self.__input = carb.input.acquire_input_interface()
def test(self, key_a, key_b):
if self.__input.get_keyboard_button_flags(None, key_a) & carb.input.BUTTON_FLAG_DOWN:
return True
if self.__input.get_keyboard_button_flags(None, key_b) & carb.input.BUTTON_FLAG_DOWN:
return True
return False
class _SelectionPreventer(sc.GestureManager):
'''Class to explicitly block selection in favor of alt-orbit when alt-dragging'''
def can_be_prevented(self, gesture):
alt_down = _KeyDown().test(carb.input.KeyboardInput.LEFT_ALT, carb.input.KeyboardInput.RIGHT_ALT)
if alt_down:
if getattr(gesture, 'name', None) == "SelectionDrag":
return True
# Never prevent in the middle or at the end of drag
return (
gesture.state != sc.GestureState.CHANGED
and gesture.state != sc.GestureState.ENDED
and gesture.state != sc.GestureState.CANCELED
)
def should_prevent(self, gesture, preventer):
alt_down = _KeyDown().test(carb.input.KeyboardInput.LEFT_ALT, carb.input.KeyboardInput.RIGHT_ALT)
if alt_down:
name = getattr(gesture, 'name', None)
if name == "TumbleGesture":
return False
if name == "SelectionDrag":
return True
return super().should_prevent(gesture, preventer)
class _SelectionGesture:
@classmethod
def __get_selection_mode(self):
key_down = _KeyDown()
shift_down = key_down.test(carb.input.KeyboardInput.LEFT_SHIFT, carb.input.KeyboardInput.RIGHT_SHIFT)
if shift_down:
return SelectionMode.APPEND
ctrl_down = key_down.test(carb.input.KeyboardInput.LEFT_CONTROL, carb.input.KeyboardInput.RIGHT_CONTROL)
if ctrl_down:
return SelectionMode.REMOVE
# alt_down = key_down.test(carb.input.KeyboardInput.LEFT_ALT, carb.input.KeyboardInput.RIGHT_ALT)
return SelectionMode.REPLACE
@classmethod
def _set_mouse(self, model: sc.AbstractManipulatorModel, ndc_mouse: List[float], is_start: bool = False):
if is_start:
model.set_floats('ndc_start', ndc_mouse)
model.set_ints('mode', [self.__get_selection_mode()])
elif _optional_bool(model, 'live_update'):
model.set_ints('mode', [self.__get_selection_mode()])
model.set_floats('ndc_current', ndc_mouse)
@classmethod
def _on_ended(self, manipulator: sc.Manipulator):
# This is needed to not fight with alt+left-mouse camera orbit when not blocking alt explicitly
# manipulator.invalidate()
model = manipulator.model
model.set_floats('ndc_start', [])
model.set_floats('ndc_current', [])
model.set_ints('mode', [])
model._item_changed(model.get_item('ndc_rect'))
class _DragGesture(sc.DragGesture):
def __init__(self, manipulator: sc.Manipulator, *args, **kwargs):
super().__init__(*args, **kwargs)
self.__manipulator = manipulator
def on_began(self):
_SelectionGesture._set_mouse(self.__manipulator.model, self.sender.gesture_payload.mouse, True)
def on_changed(self):
model = self.__manipulator.model
_SelectionGesture._set_mouse(model, self.sender.gesture_payload.mouse)
model._item_changed(model.get_item('ndc_rect'))
def on_ended(self):
# Track whether on_changed has been called.
# When it has: this drag is a drag.
# When it hasn't: this drag is actually a click.
if self.state != sc.GestureState.ENDED:
return
_SelectionGesture._on_ended(self.__manipulator)
class _ClickGesture(sc.ClickGesture):
def __init__(self, manipulator: sc.Manipulator, *args, **kwargs):
super().__init__(*args, **kwargs)
self.__manipulator = manipulator
def on_ended(self):
model = self.__manipulator.model
_SelectionGesture._set_mouse(model, self.sender.gesture_payload.mouse, True)
model._item_changed(model.get_item('ndc_rect'))
_SelectionGesture._on_ended(self.__manipulator)
class SelectionManipulator(sc.Manipulator):
def __init__(self, style: dict = None, *args, **kwargs):
applied_style = {
'as_rect': True,
'thickness': 2.0,
'color': (1.0, 1.0, 1.0, 0.2),
'inner_color': (1.0, 1.0, 1.0, 0.2)
}
if style:
applied_style.update(style)
super().__init__(*args, **kwargs)
self.__as_rect = applied_style['as_rect']
self.__outline_color = applied_style['color']
self.__inner_color = applied_style['inner_color']
self.__thickness = applied_style['thickness']
self.__polygons, self.__transform = [], None
# Provide some defaults
if not self.model:
self.model = SelectionShapeModel()
self.gestures = []
def on_build(self):
if self.__transform:
self.__transform.clear()
self.__polygons = []
sc.Screen(gestures=self.gestures or [
_DragGesture(weakref.proxy(self), manager=_SelectionPreventer(), name='SelectionDrag'),
_ClickGesture(weakref.proxy(self), name='SelectionClick'),
])
self.__transform = sc.Transform(look_at=sc.Transform.LookAt.CAMERA)
def __draw_shape(self, start, end, as_rect):
if as_rect:
avg_z = (start[2] + end[2]) * 0.5
points = ((start[0], start[1], avg_z),
(end[0], start[1], avg_z),
(end[0], end[1], avg_z),
(start[0], end[1], avg_z))
else:
if self.__polygons:
points = self.__polygons[0].positions + [end]
else:
points = start, end
# FIXME: scene.ui needs a full rebuild on this case
self.__transform.clear()
self.__polygons = []
npoints = len(points)
visible = npoints >= 3
if not self.__polygons:
with self.__transform:
faces = [x for x in range(npoints)]
# TODO: omni.ui.scene Shouldn't requires redundant color & thickness for constant color
if self.__inner_color:
self.__polygons.append(
sc.PolygonMesh(points, [self.__inner_color]*npoints, [npoints], faces, wireframe=False, visible=visible)
)
if self.__thickness and self.__outline_color:
self.__polygons.append(
sc.PolygonMesh(points, [self.__outline_color]*npoints, [npoints], faces, wireframe=True, thicknesses=[self.__thickness]*npoints, visible=visible)
)
else:
for poly in self.__polygons:
poly.positions = points
poly.visible = visible
def on_model_updated(self, item):
model = self.model
if item != model.get_item('ndc_rect'):
return
ndc_rect = model.get_as_floats('ndc_rect')
if ndc_rect:
ndc_depth = 1
start = self.__transform.transform_space(sc.Space.NDC, sc.Space.OBJECT, (ndc_rect[0], ndc_rect[1], ndc_depth))
end = self.__transform.transform_space(sc.Space.NDC, sc.Space.OBJECT, (ndc_rect[2], ndc_rect[3], ndc_depth))
self.__draw_shape(start, end, self.__as_rect)
else:
self.__transform.clear()
self.__polygons = []
|
omniverse-code/kit/exts/omni.kit.manipulator.selection/omni/kit/manipulator/selection/tests/test_selection_manipulator.py | ## Copyright (c) top_left[0]22, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
__all__ = ['TestSelectionManipulator']
import omni.kit.test
from ..manipulator import SelectionManipulator
from .test_scene_ui_base import TestOmniUiScene
from omni.ui import scene as sc
class TestSelectionManipulator(TestOmniUiScene):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.__ndc_rects = []
self.__last_rect = None
def on_item_changed(self, model, item):
# ndc_rect should be part of the model, always
ndc_rect_item = model.get_item('ndc_rect')
self.assertIsNotNone(ndc_rect_item)
# Ignore other signals
if item != ndc_rect_item:
return
# Get the values
ndc_rect = model.get_as_floats(ndc_rect_item)
self.assertIsNotNone(ndc_rect)
# NDC rect cannot be none, but it can be empty (on mouse-up)
if ndc_rect != []:
# ndc_rect should be totally ordered: top-left, bottom-right
self.assertLess(ndc_rect[0], ndc_rect[2])
self.assertLess(ndc_rect[1], ndc_rect[3])
# Save the lat mouse for a test later
self.__last_rect = ndc_rect
def ndc_rects_match(self):
self.assertIsNotNone(self.__last_rect)
self.__ndc_rects.append(self.__last_rect)
self.__last_rect = None
if len(self.__ndc_rects) > 1:
self.assertEqual(self.__ndc_rects[0], self.__ndc_rects[-1])
async def test_ortho_selection(self):
window, scene_view = await self.create_ortho_scene_view('test_ortho_selection')
with scene_view.scene:
manipulator = SelectionManipulator()
sc.Arc(radius=25, wireframe=True, tesselation = 36 * 3, thickness = 2)
manip_sub = manipulator.model.subscribe_item_changed_fn(self.on_item_changed)
top_left = (20, 40)
bottom_right = (window.width-top_left[0], window.height-60)
# Test dragging top-left to bottom-right
await self.wait_frames()
await self.mouse_dragging_test('test_ortho_selection', (top_left[0], top_left[1]), (bottom_right[0], bottom_right[1]))
await self.wait_frames()
# Ortho and Perspective should stil have same selection box
self.ndc_rects_match()
# Test dragging bottom-right to top-left
await self.wait_frames()
await self.mouse_dragging_test('test_ortho_selection', (bottom_right[0], bottom_right[1]), (top_left[0], top_left[1]))
await self.wait_frames()
# Ortho and Perspective should stil have same selection box
self.ndc_rects_match()
# Test dragging top-right to bottom-left
await self.wait_frames()
await self.mouse_dragging_test('test_ortho_selection', (bottom_right[0], top_left[1]), (top_left[0], bottom_right[1]))
await self.wait_frames()
# Should stil have same selection box
self.ndc_rects_match()
# Test dragging bottom-left to top-right
await self.wait_frames()
await self.mouse_dragging_test('test_ortho_selection', (top_left[0], bottom_right[1]), (bottom_right[0], top_left[1]))
await self.wait_frames()
async def test_persepctive_selection(self):
window, scene_view = await self.create_perspective_scene_view('test_persepctive_selection')
with scene_view.scene:
manipulator = SelectionManipulator({
'thickness': 5.0,
'color': (0.2, 0.2, 0.8, 0.8),
'inner_color': (0.2, 0.6, 0.8, 0.4)
})
sc.Arc(radius=25, wireframe=True, tesselation = 36 * 3, thickness = 2)
manip_sub = manipulator.model.subscribe_item_changed_fn(self.on_item_changed)
top_left = (20, 40)
bottom_right = (window.width-top_left[0], window.height-60)
# Test dragging bottom-left to top-right
await self.wait_frames()
await self.mouse_dragging_test('test_persepctive_selection', (top_left[0], bottom_right[1]), (bottom_right[0], top_left[1]))
await self.wait_frames()
# Should stil have same selection box
self.ndc_rects_match()
# Test dragging top-right to bottom-left
await self.wait_frames()
await self.mouse_dragging_test('test_persepctive_selection', (bottom_right[0], top_left[1]), (top_left[0], bottom_right[1]))
await self.wait_frames()
# Should stil have same selection box
self.ndc_rects_match()
# Test dragging bottom-right to top-left
await self.wait_frames()
await self.mouse_dragging_test('test_persepctive_selection', (bottom_right[0], bottom_right[1]), (top_left[0], top_left[1]))
await self.wait_frames()
# Ortho and Perspective should stil have same selection box
self.ndc_rects_match()
# Test dragging top-left to bottom-right
await self.wait_frames()
await self.mouse_dragging_test('test_persepctive_selection', (top_left[0], top_left[1]), (bottom_right[0], bottom_right[1]))
await self.wait_frames()
# Ortho and Perspective should stil have same selection box
self.ndc_rects_match()
|
omniverse-code/kit/exts/omni.kit.manipulator.selection/omni/kit/manipulator/selection/tests/__init__.py | from .test_selection_model import TestSelectionModel
from .test_selection_manipulator import TestSelectionManipulator
|
omniverse-code/kit/exts/omni.kit.manipulator.selection/omni/kit/manipulator/selection/tests/test_scene_ui_base.py | ## Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
from omni.ui.tests.test_base import OmniUiTest
from omni.ui.tests.compare_utils import capture_and_compare
from omni.kit.ui_test.input import emulate_mouse, emulate_mouse_slow_move, human_delay
from omni.kit.ui_test import Vec2
from omni.ui import scene as sc
import omni.ui as ui
import omni.appwindow
import omni.kit.app
import carb
from carb.input import MouseEventType
from pxr import Gf
from pathlib import Path
async def emulate_mouse_drag_and_drop(start_pos, end_pos, right_click=False, human_delay_speed: int = 4, end_with_up: bool = True):
"""Emulate Mouse Drag & Drop. Click at start position and slowly move to end position."""
await emulate_mouse(MouseEventType.MOVE, start_pos)
await emulate_mouse(MouseEventType.RIGHT_BUTTON_DOWN if right_click else MouseEventType.LEFT_BUTTON_DOWN)
await human_delay(human_delay_speed)
await emulate_mouse_slow_move(start_pos, end_pos, human_delay_speed=human_delay_speed)
if end_with_up:
await emulate_mouse(MouseEventType.RIGHT_BUTTON_UP if right_click else MouseEventType.LEFT_BUTTON_UP)
await human_delay(human_delay_speed)
def _flatten_matrix(matrix: Gf.Matrix4d):
return [matrix[0][0], matrix[0][1], matrix[0][2], matrix[0][3],
matrix[1][0], matrix[1][1], matrix[1][2], matrix[1][3],
matrix[2][0], matrix[2][1], matrix[2][2], matrix[2][3],
matrix[3][0], matrix[3][1], matrix[3][2], matrix[3][3]]
class TestOmniUiScene(OmniUiTest):
DATA_PATH = None
async def setUp(self, ext_id: str = None):
await super().setUp()
self.__width, self.__height = None, None
# If no extension-id, assume standard xxx.xxx.xxx.tests.current_test
if ext_id is None:
ext_id = '.'.join(self.__module__.split('.')[0:-2])
TestOmniUiScene.DATA_PATH = Path(carb.tokens.get_tokens_interface().resolve("${" + ext_id + "}")).absolute().resolve()
self.__golden_img_dir = TestOmniUiScene.DATA_PATH.joinpath("data", "tests")
# After running each test
async def tearDown(self):
self.__golden_img_dir = None
await super().tearDown()
async def setup_test_area_and_input(self, title: str, width: int = 256, height: int = 256):
self.__width, self.__height = width, height
await self.create_test_area(width=width, height=height)
app_window = omni.appwindow.get_default_app_window()
app_window.set_input_blocking_state(carb.input.DeviceType.MOUSE, False)
return ui.Window(title=title, width=width, height=height,
flags=ui.WINDOW_FLAGS_NO_SCROLLBAR | ui.WINDOW_FLAGS_NO_TITLE_BAR | ui.WINDOW_FLAGS_NO_RESIZE | ui.WINDOW_FLAGS_NO_MOVE)
async def create_ortho_scene_view(self, title='test', width = 256, height = 256, ortho_size = 100, z_pos = -5):
window = await self.setup_test_area_and_input(title, width, height)
with window.frame:
# Camera matrices
projection = self.ortho_projection()
view = sc.Matrix44.get_translation_matrix(0, 0, z_pos)
scene_view = sc.SceneView(aspect_ratio_policy=sc.AspectRatioPolicy.STRETCH, model=sc.CameraModel(projection, view))
return window, scene_view
async def create_perspective_scene_view(self, title='test', width = 256, height = 256, field_of_view = 25, distance = 100):
window = await self.setup_test_area_and_input(title, width, height)
with window.frame:
# Camera matrices
projection = self.perspective_projection(field_of_view)
eye = Gf.Vec3d(distance, distance, distance)
target = Gf.Vec3d(0, 0, 0)
forward = (target - eye).GetNormalized()
up = Gf.Vec3d(0, 0, 1).GetComplement(forward)
view = _flatten_matrix(Gf.Matrix4d().SetLookAt(eye, target, up))
scene_view = sc.SceneView(aspect_ratio_policy=sc.AspectRatioPolicy.STRETCH, model=sc.CameraModel(projection, view))
return window, scene_view
async def finish_scene_ui_test(self, wait_frames = 15):
for _ in range(wait_frames):
await omni.kit.app.get_app().next_update_async()
return await self.finalize_test(golden_img_dir=self.__golden_img_dir)
def ortho_projection(self, ortho_size: float = 100, aspect_ratio: float = None, near: float = 0.001, far: float = 10000):
if aspect_ratio is None:
aspect_ratio = self.__width / self.__height
if aspect_ratio > 1:
ortho_half_height = ortho_size * 0.5
ortho_half_width = ortho_half_height * aspect_ratio
else:
ortho_half_width = ortho_size * 0.5
ortho_half_height = ortho_half_width * aspect_ratio
frustum = Gf.Frustum()
frustum.SetOrthographic(-ortho_half_width, ortho_half_width, -ortho_half_height, ortho_half_height, near, far)
return _flatten_matrix(frustum.ComputeProjectionMatrix())
def perspective_projection(self, field_of_view: float = 20, aspect_ratio: float = None, near: float = 0.001, far: float = 10000):
if aspect_ratio is None:
aspect_ratio = self.__width / self.__height
frustum = Gf.Frustum()
frustum.SetPerspective(field_of_view / aspect_ratio, aspect_ratio, near, far)
return _flatten_matrix(frustum.ComputeProjectionMatrix())
@property
def golden_img_dir(self):
return self.__golden_img_dir
@property
def human_delay(self):
return 4
async def wait_frames(self, frames: int = 15):
for _ in range(10):
await omni.kit.app.get_app().next_update_async()
async def end_mouse(self):
await emulate_mouse(MouseEventType.LEFT_BUTTON_UP)
await human_delay(self.human_delay)
async def mouse_dragging_test(self, test_name, start_pos, end_pos):
threshold = 10
start_pos = Vec2(start_pos[0], start_pos[1])
end_pos = Vec2(end_pos[0], end_pos[1])
# Do a drag operation
await emulate_mouse_drag_and_drop(start_pos, end_pos, human_delay_speed = self.human_delay, end_with_up=False)
# Capture while mouse is down
diff1 = await capture_and_compare(f'{test_name}_drag.png', threshold, self.golden_img_dir)
# End the drag
await self.end_mouse()
# And cature again with mouse up
diff2 = await capture_and_compare(f'{test_name}_done.png', threshold, self.golden_img_dir)
if diff1 != 0:
carb.log_warn(f"[{test_name}_drag.png] the generated image has difference {diff1}")
if diff2 != 0:
carb.log_warn(f"[{test_name}_done.png] the generated image has difference {diff2}")
self.assertTrue(
(diff1 is not None and diff1 < threshold),
msg=f"The image for test '{test_name}_drag.png' doesn't match the golden one. Difference of {diff1} is is not less than threshold of {threshold}.",
)
self.assertTrue(
(diff2 is not None and diff2 < threshold),
msg=f"The image for test '{test_name}_done.png' doesn't match the golden one. Difference of {diff2} is is not less than threshold of {threshold}.",
) |
omniverse-code/kit/exts/omni.kit.manipulator.selection/omni/kit/manipulator/selection/tests/test_selection_model.py | ## Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
__all__ = ['TestSelectionModel']
import omni.kit.test
from ..model import SelectionShapeModel
class TestSelectionModel(omni.kit.test.AsyncTestCase):
async def test_ortho_selection(self):
model = SelectionShapeModel()
# Standard item should exist
ndc_start_item = model.get_item('ndc_start')
self.assertIsNotNone(ndc_start_item)
# Standard item should exist
ndc_current_item = model.get_item('ndc_current')
self.assertIsNotNone(ndc_current_item)
# Standard item should exist
ndc_rect_item = model.get_item('ndc_rect')
self.assertIsNotNone(ndc_rect_item)
# Test setting only a start result in no rect
model.set_floats(ndc_start_item, [1, 2])
ndc_rect = model.get_as_floats(ndc_rect_item)
self.assertEqual(ndc_rect, [1, 2, 1, 2])
# Test setting a start and current results in a rect
model.set_floats(ndc_start_item, [1, 2])
model.set_floats(ndc_current_item, [3, 4])
ndc_rect = model.get_as_floats(ndc_rect_item)
self.assertEqual(ndc_rect, [1, 2, 3, 4])
# Changing the order should result in the same sorted top-left, bottom-right rect
model.set_floats(ndc_start_item, [3, 4])
model.set_floats(ndc_current_item, [1, 2])
ndc_rect = model.get_as_floats(ndc_rect_item)
self.assertEqual(ndc_rect, [1, 2, 3, 4])
|
omniverse-code/kit/exts/omni.kit.manipulator.selection/docs/index.rst | omni.kit.manipulator.selection
###########################
Selection Shape/Box for omni.ui.scene
.. toctree::
:maxdepth: 1
README
CHANGELOG
.. automodule:: omni.kit.manipulator.selection
:platform: Windows-x86_64, Linux-x86_64
:members:
:undoc-members:
:show-inheritance:
:imported-members:
|
omniverse-code/kit/exts/omni.kit.filebrowser_column.tags/omni/kit/filebrowser_column/tags/__init__.py | from .tags_extension import TagsExtension
|
omniverse-code/kit/exts/omni.kit.filebrowser_column.tags/omni/kit/filebrowser_column/tags/tags_extension.py | # Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
from .tags_delegate import TagsDelegate
from omni.kit.widget.filebrowser import ColumnDelegateRegistry
import omni.ext
import carb
class TagsExtension(omni.ext.IExt):
def on_startup(self, ext_id):
self._subscription = ColumnDelegateRegistry().register_column_delegate("Tags", TagsDelegate)
def on_shutdown(self):
self._subscription = None
|
omniverse-code/kit/exts/omni.kit.filebrowser_column.tags/omni/kit/filebrowser_column/tags/tags_delegate.py | # Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
from omni.kit.tagging import OmniKitTaggingDelegate, get_tagging_instance
from omni.kit.widget.filebrowser import ColumnItem
from omni.kit.widget.filebrowser import AbstractColumnDelegate
import asyncio
import carb
import functools
import omni.client
import omni.ui as ui
import traceback
def handle_exception(func):
"""
Decorator to print exception in async functions
"""
@functools.wraps(func)
async def wrapper(*args, **kwargs):
try:
return await func(*args, **kwargs)
except asyncio.CancelledError:
pass
except Exception as e:
carb.log_error(f"Exception when async '{func}'")
carb.log_error(f"{e}")
carb.log_error(f"{traceback.format_exc()}")
return wrapper
class TagsDelegate(AbstractColumnDelegate):
"""
The object that adds the new column "Access" to fileblowser. The columns
displays access flags.
"""
@property
def initial_width(self):
"""The width of the column"""
return ui.Pixel(40)
def build_header(self):
"""Build the header"""
ui.Label("Tags", style_type_name_override="TreeView.Header")
@handle_exception
async def build_widget(self, item: ColumnItem):
"""
Build the widget for the given item. Works inside Frame in async
mode. Once the widget is created, it will replace the content of the
frame. It allow to await something for a while and create the widget
when the result is available.
"""
tagging = get_tagging_instance()
if tagging is None:
carb.log_warn("Tagging client not found")
return
# sanitize relative item paths
path = item.path.replace("/./", "/")
results = await tagging.get_tags_async([path])
if results is None:
results = []
ordered_tags = tagging.ordered_tag_list(results)
tag_string = ", ".join(ordered_tags)
tooltip_string = "\n".join(ordered_tags)
ui.Label(tag_string, style_type_name_override="TreeView.Item", tooltip=tooltip_string)
|
omniverse-code/kit/exts/omni.kit.property.layer/PACKAGE-LICENSES/omni.kit.property.layer-LICENSE.md | Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved.
NVIDIA CORPORATION and its licensors retain all intellectual property
and proprietary rights in and to this software, related documentation
and any modifications thereto. Any use, reproduction, disclosure or
distribution of this software and related documentation without an express
license agreement from NVIDIA CORPORATION is strictly prohibited. |
omniverse-code/kit/exts/omni.kit.property.layer/config/extension.toml | [package]
# Semantic Versioning is used: https://semver.org/
version = "1.1.4"
category = "Internal"
feature = true
# Lists people or organizations that are considered the "authors" of the package.
authors = ["NVIDIA"]
# The title and description fields are primarly for displaying extension info in UI
title = "Layer Property Window Widgets"
description="Property Window widgets that displays Layer related information."
# URL of the extension source repository.
repository = ""
# Keywords for the extension
keywords = ["kit", "usd", "property", "Layer"]
# Location of change log file in target (final) folder of extension, relative to the root.
# More info on writing changelog: https://keepachangelog.com/en/1.0.0/
changelog="docs/CHANGELOG.md"
# Preview image displayed in extension manager
preview_image = "data/preview.png"
# Icon is shown in Extensions window, it is recommended to be square, of size 256x256.
icon = "data/icon.png"
[dependencies]
"omni.kit.commands" = {}
"omni.usd" = {}
"omni.ui" = {}
"omni.client" = {}
"omni.kit.window.filepicker" = {}
"omni.kit.window.content_browser" = {}
"omni.kit.window.property" = {}
"omni.kit.widget.layers" = {}
"omni.kit.usd.layers" = {}
"omni.kit.widget.versioning" = { optional=true }
# Main python module this extension provides, it will be publicly available as "import omni.example.hello".
[[python.module]]
name = "omni.kit.property.layer"
[[test]]
args = ["--/app/file/ignoreUnsavedOnExit=true"]
|
omniverse-code/kit/exts/omni.kit.property.layer/omni/kit/property/layer/layer_property_models.py | # Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
import asyncio
import omni.kit.commands
import omni.timeline
import omni.ui as ui
import omni.usd
import weakref
import omni.kit.widget.layers
from pxr import Usd, Sdf, UsdGeom, UsdPhysics
from omni.kit.widget.layers import LayerUtils
from .types import LayerMetaType
class LayerPathModel(ui.SimpleStringModel):
def __init__(self, layer_item: weakref):
super().__init__()
self._layer_item = layer_item
if self._layer_item and self._layer_item():
self._identifier = self._layer_item().identifier
else:
self._identifier = None
def get_value_as_string(self):
return self._identifier
def set_value(self, value):
if value != self._identifier:
self._identifier = value
self._value_changed()
def begin_edit(self):
pass
def end_edit(self):
if not self._layer_item or not self._layer_item():
return
value = self.get_value_as_string()
layer_item = self._layer_item()
if not layer_item.reserved:
sublayer_position = LayerUtils.get_sublayer_position_in_parent(
layer_item.parent.identifier, layer_item.identifier
)
omni.kit.commands.execute(
"ReplaceSublayer",
layer_identifier=layer_item.parent.identifier,
sublayer_position=sublayer_position,
new_layer_path=value,
)
# OM-76598: Delay frames until layer item is initialized.
async def focus_on_layer_item(path):
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
layer_instance = omni.kit.widget.layers.get_instance()
layer_instance.set_current_focused_layer_item(path)
asyncio.ensure_future(focus_on_layer_item(value))
def replace_layer(self, value):
self.set_value(value)
self.end_edit()
def is_reserved_layer(self):
if not self._layer_item or not self._layer_item():
return True
return self._layer_item().reserved
def anonymous(self):
if not self._layer_item or not self._layer_item() or not self._layer_item().layer:
return True
return self._layer_item().anonymous
class LayerWorldAxisItem(ui.AbstractItem):
def __init__(self, text):
super().__init__()
self.model = ui.SimpleStringModel(text)
class LayerWorldAxisModel(ui.AbstractItemModel):
def __init__(self, layer_item: weakref):
super().__init__()
self._layer_item = layer_item
self._items = [LayerWorldAxisItem(text) for text in [UsdGeom.Tokens.y, UsdGeom.Tokens.z]]
self._current_index = ui.SimpleIntModel()
self.on_value_changed()
self._current_index.add_value_changed_fn(self._current_index_changed)
def get_item_children(self, item):
return self._items
def get_item_value_model(self, item, column_id):
if item is None:
return self._current_index
return item.model
def _current_index_changed(self, model):
if not self._layer_item or not self._layer_item():
return
stage = Usd.Stage.Open(self._layer_item().layer)
index = model.as_int
if index == 0:
omni.kit.commands.execute("ModifyStageAxis", stage=stage, axis=UsdGeom.Tokens.y)
elif index == 1:
omni.kit.commands.execute("ModifyStageAxis", stage=stage, axis=UsdGeom.Tokens.z)
UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.z)
self._item_changed(None)
def get_usd_token_name(self):
return UsdGeom.Tokens.upAxis
def on_value_changed(self):
if self._layer_item and self._layer_item():
layer = self._layer_item().layer
stage = Usd.Stage.Open(layer)
up_axis = UsdGeom.GetStageUpAxis(stage)
index = 0 if up_axis == UsdGeom.Tokens.y else 1
self._current_index.set_value(index)
class LayerMetaModel(ui.AbstractValueModel):
def __init__(self, layer_item: weakref, meta_type: LayerMetaType):
super().__init__()
self._layer_item = layer_item
self._meta_type = meta_type
self._value = self._get_value_as_string()
def get_value_as_string(self):
return self._value
def _get_value_as_string(self):
if not self._layer_item or not self._layer_item():
return None
layer = self._layer_item().layer
if not layer:
return None
if self._meta_type == LayerMetaType.COMMENT:
return str(layer.comment)
elif self._meta_type == LayerMetaType.DOC:
return str(layer.documentation)
elif self._meta_type == LayerMetaType.START_TIME:
return str(layer.startTimeCode)
elif self._meta_type == LayerMetaType.END_TIME:
return str(layer.endTimeCode)
elif self._meta_type == LayerMetaType.TIMECODES_PER_SECOND:
return str(layer.timeCodesPerSecond)
elif layer.HasFramesPerSecond() and self._meta_type == LayerMetaType.FPS_PER_SECOND:
return str(layer.framesPerSecond)
elif self._meta_type == LayerMetaType.UNITS:
stage = Usd.Stage.Open(layer, None, None, Usd.Stage.LoadNone)
meters = UsdGeom.GetStageMetersPerUnit(stage)
return str(meters)
elif self._meta_type == LayerMetaType.KG_PER_UNIT:
stage = Usd.Stage.Open(layer, None, None, Usd.Stage.LoadNone)
kilograms = UsdPhysics.GetStageKilogramsPerUnit(stage)
return str(kilograms)
elif (
self._layer_item().parent and self._meta_type == LayerMetaType.LAYER_OFFSET
):
parent = self._layer_item().parent
layer_index = LayerUtils.get_sublayer_position_in_parent(parent.identifier, layer.identifier)
offset = parent.layer.subLayerOffsets[layer_index]
return str(offset.offset)
elif self._layer_item().parent and self._meta_type == LayerMetaType.LAYER_SCALE:
parent = self._layer_item().parent
layer_index = LayerUtils.get_sublayer_position_in_parent(parent.identifier, layer.identifier)
offset = parent.layer.subLayerOffsets[layer_index]
return str(offset.scale)
return None
def set_value(self, value):
if value != self._value:
self._value = value
self._value_changed()
def end_edit(self):
if not self._layer_item or not self._layer_item():
return
layer = self._layer_item().layer
if not layer:
return
if self._layer_item().parent:
parent_layer_identifier = self._layer_item().parent.identifier
else:
parent_layer_identifier = None
layer_identifier = layer.identifier
omni.kit.commands.execute(
"ModifyLayerMetadata",
layer_identifier=layer_identifier,
parent_layer_identifier=parent_layer_identifier,
meta_index=self._meta_type,
value=self._value,
)
def begin_edit(self):
pass
def get_usd_token_name(self):
if self._meta_type == LayerMetaType.COMMENT:
return Sdf.Layer.CommentKey
elif self._meta_type == LayerMetaType.DOC:
return Sdf.Layer.DocumentationKey
elif self._meta_type == LayerMetaType.START_TIME:
return Sdf.Layer.StartTimeCodeKey
elif self._meta_type == LayerMetaType.END_TIME:
return Sdf.Layer.EndTimeCodeKey
elif self._meta_type == LayerMetaType.TIMECODES_PER_SECOND:
return Sdf.Layer.TimeCodesPerSecondKey
elif self._meta_type == LayerMetaType.FPS_PER_SECOND:
return Sdf.Layer.FramesPerSecondKey
elif self._meta_type == LayerMetaType.UNITS:
return UsdGeom.Tokens.metersPerUnit
elif self._meta_type == LayerMetaType.KG_PER_UNIT:
return UsdPhysics.Tokens.kilogramsPerUnit
elif self._meta_type == LayerMetaType.LAYER_OFFSET:
return "subLayerOffsets_offset" # USD has no python bindings for this key
elif self._meta_type == LayerMetaType.LAYER_SCALE:
return "subLayerOffsets_scale" # USD has no python bindings for this key
return ""
def on_value_changed(self):
self.set_value(self._get_value_as_string())
|
omniverse-code/kit/exts/omni.kit.property.layer/omni/kit/property/layer/widgets.py | # Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
import carb
import omni.ext
import omni.kit.app
import omni.usd
import weakref
from pathlib import Path
from pxr import Sdf, UsdGeom
from typing import List
from .layer_property_widgets import LayerPathWidget, LayerMetaWiget
ICON_PATH = ""
_instance = None
def get_instance():
global _instance
return _instance
class LayerPropertyWidgets(omni.ext.IExt):
def __init__(self):
self._registered = False
self._examples = None
self._selection_notifiers = []
super().__init__()
def on_startup(self, ext_id):
global _instance
_instance = self
manager = omni.kit.app.get_app().get_extension_manager()
extension_path = manager.get_extension_path(ext_id)
global ICON_PATH
ICON_PATH = Path(extension_path).joinpath("data").joinpath("icons")
self._selection_notifiers.append(SelectionNotifier()) # default context
self._hooks = manager.subscribe_to_extension_enable(
lambda _: self._register_widget(),
lambda _: self._unregister_widget(),
ext_name="omni.kit.window.property",
hook_name="omni.kit.property.layer listener",
)
def on_shutdown(self):
global _instance
if _instance:
_instance = None
for notifier in self._selection_notifiers:
notifier.stop()
self._selection_notifiers.clear()
self._hooks = None
if self._registered:
self._unregister_widget()
def _register_widget(self):
try:
import omni.kit.window.property as p
from .layer_property_widgets import LayerPathWidget, LayerMetaWiget
w = p.get_window()
self._layer_path_widget = LayerPathWidget(ICON_PATH)
self._meta_widget = LayerMetaWiget(ICON_PATH)
if w:
w.register_widget("layers", "path", self._layer_path_widget)
w.register_widget("layers", "metadata", self._meta_widget)
for notifier in self._selection_notifiers:
notifier.start()
# notifier._notify_layer_selection_changed(None) # force a refresh
self._registered = True
except Exception as exc:
carb.log_warn(f"error {exc}")
def _unregister_widget(self):
try:
import omni.kit.window.property as p
w = p.get_window()
if w:
for notifier in self._selection_notifiers:
notifier.stop()
w.unregister_widget("layers", "metadata")
w.unregister_widget("layers", "path")
self._registered = False
if self._layer_path_widget:
self._layer_path_widget.destroy()
self._layer_path_widget = None
self._meta_widget = None
except Exception as e:
carb.log_warn(f"Unable to unregister omni.kit.property.layer.widgets: {e}")
class SelectionNotifier:
def __init__(self, property_window_context_id=""):
self._property_window_context_id = property_window_context_id
def start(self):
layers_widget = self.get_layers_widget()
if layers_widget:
layers_widget.add_layer_selection_changed_fn(self._notify_layer_selection_changed)
def get_layers_widget(self):
return omni.kit.widget.layers.get_instance()
def stop(self):
layers_widget = self.get_layers_widget()
if layers_widget:
layers_widget.remove_layer_selection_changed_fn(self._notify_layer_selection_changed)
def _notify_layer_selection_changed(self, item):
import omni.kit.window.property as p
# TODO _property_window_context_id
w = p.get_window()
if w and self.get_layers_widget():
layer_item = self.get_layers_widget().get_current_focused_layer_item()
if layer_item:
w.notify("layers", weakref.ref(layer_item))
else:
w.notify("layers", None)
|
omniverse-code/kit/exts/omni.kit.property.layer/omni/kit/property/layer/commands.py | import weakref
import carb
import omni.kit.commands
from pxr import Sdf, Usd, UsdGeom, UsdPhysics
from .types import LayerMetaType
from omni.kit.widget.layers import LayerUtils
class ModifyStageAxisCommand(omni.kit.commands.Command):
"""Modify stage up axis undoable **Command**."""
def __init__(self, stage, axis):
if stage:
self._stage = weakref.ref(stage)
else:
self._stage = None
self._new_axis = axis
self._old_axis = None
def do(self):
if self._stage and self._stage():
self._old_axis = UsdGeom.GetStageUpAxis(self._stage())
UsdGeom.SetStageUpAxis(self._stage(), self._new_axis)
def undo(self):
if self._stage and self._stage() and self._old_axis:
UsdGeom.SetStageUpAxis(self._stage(), self._old_axis)
class ModifyLayerMetadataCommand(omni.kit.commands.Command):
"""Modify layer metadata undoable **Command**."""
def __init__(self, layer_identifier, parent_layer_identifier, meta_index, value):
"""Constructor.
Keyword Arguments:
layer_identifier (str): Layer identifier to operate.
parent_identifier (str): Parent identifier that layer_identifier resides in as sublayer.
It's None if it's root layer.
meta_index (omni.kit.property.layer.types.LayerMetaType): Metadata type.
"""
super().__init__()
self._layer_identifer = layer_identifier
self._parent_layer_identifier = parent_layer_identifier
self._meta_index = meta_index
self._new_value = value
self._old_value = None
def _set_value(self, meta_type, value):
layer = Sdf.Find(self._layer_identifer)
if not layer:
return
if self._parent_layer_identifier:
parent_layer = Sdf.Find(self._parent_layer_identifier)
else:
parent_layer = None
try:
if meta_type == LayerMetaType.COMMENT:
self._old_value = layer.comment
layer.comment = str(value)
elif meta_type == LayerMetaType.DOC:
self._old_value = layer.documentation
layer.documentation = str(value)
elif meta_type == LayerMetaType.START_TIME:
self._old_value = layer.startTimeCode
layer.startTimeCode = float(value)
elif meta_type == LayerMetaType.END_TIME:
self._old_value = layer.endTimeCode
layer.endTimeCode = float(value)
elif meta_type == LayerMetaType.TIMECODES_PER_SECOND:
self._old_value = layer.timeCodesPerSecond
layer.timeCodesPerSecond = float(value)
elif meta_type == LayerMetaType.FPS_PER_SECOND:
self._old_value = layer.framesPerSecond
layer.framesPerSecond = float(value)
elif meta_type == LayerMetaType.UNITS:
stage = Usd.Stage.Open(layer, None, None, Usd.Stage.LoadNone)
meters = UsdGeom.GetStageMetersPerUnit(stage)
self._old_value = meters
UsdGeom.SetStageMetersPerUnit(stage, float(value))
elif meta_type == LayerMetaType.KG_PER_UNIT:
stage = Usd.Stage.Open(layer, None, None, Usd.Stage.LoadNone)
kilograms = UsdPhysics.GetStageKilogramsPerUnit(stage)
self._old_value = kilograms
UsdPhysics.SetStageKilogramsPerUnit(stage, float(value))
elif parent_layer and meta_type == LayerMetaType.LAYER_OFFSET:
layer_index = LayerUtils.get_sublayer_position_in_parent(
self._parent_layer_identifier, layer.identifier
)
offset = parent_layer.subLayerOffsets[layer_index]
self._old_value = offset.offset
parent_layer.subLayerOffsets[layer_index] = Sdf.LayerOffset(float(value), offset.scale)
elif parent_layer and meta_type == LayerMetaType.LAYER_SCALE:
layer_index = LayerUtils.get_sublayer_position_in_parent(
self._parent_layer_identifier, layer.identifier
)
offset = parent_layer.subLayerOffsets[layer_index]
self._old_value = offset.scale
parent_layer.subLayerOffsets[layer_index] = Sdf.LayerOffset(offset.offset, float(value))
except Exception as e:
pass
def do(self):
self._set_value(self._meta_index, self._new_value)
def undo(self):
self._set_value(self._meta_index, self._old_value)
|
omniverse-code/kit/exts/omni.kit.property.layer/omni/kit/property/layer/layer_property_widgets.py | # Copyright (c) 2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
import os
import carb
import omni.client
import omni.kit.window.content_browser as content
import omni.ui as ui
import omni.usd
from omni.kit.usd.layers import get_layers, LayerEventType, get_layer_event_payload
from omni.kit.window.property.templates import HORIZONTAL_SPACING, LABEL_HEIGHT, LABEL_WIDTH, SimplePropertyWidget
from .file_picker import FileBrowserSelectionType, FilePicker
from .layer_property_models import LayerMetaModel, LayerPathModel, LayerWorldAxisModel
from .types import LayerMetaName, LayerMetaType
class LayerPathWidget(SimplePropertyWidget):
def __init__(self, icon_path):
super().__init__(title="Layer Path", collapsed=False)
self._icon_path = icon_path
self._file_picker = None
self._layer_path_field = False
self._layer_path_model = None
def destroy(self):
if self._file_picker:
self._file_picker.destroy()
def _show_file_picker(self):
if not self._file_picker:
self._file_picker = FilePicker(
"Select File",
"Select",
FileBrowserSelectionType.FILE_ONLY,
[(omni.usd.writable_usd_re(),
omni.usd.writable_usd_files_desc())],
)
self._file_picker.set_custom_fn(self._on_file_selected, None)
if self._layer_path_field:
value = self._layer_path_field.model.get_value_as_string()
current_dir = os.path.dirname(value)
self._file_picker.set_current_directory(current_dir)
self._file_picker.show_dialog()
def _on_file_selected(self, path):
self._layer_path_field.model.replace_layer(path)
def on_new_payload(self, payload):
if not super().on_new_payload(payload, ignore_large_selection=True):
return False
return payload is not None
def build_items(self):
layer_item = self._payload
if layer_item and layer_item():
with ui.VStack(height=0, spacing=5):
with ui.HStack():
self._layer_path_model = LayerPathModel(layer_item)
if self._layer_path_model.is_reserved_layer():
read_only = True
else:
read_only = False
self._layer_path_field = ui.StringField(
name="models", model=self._layer_path_model, read_only=read_only
)
if layer_item().missing:
self._layer_path_field.set_style({"color" : 0xFF6F72FF})
style = {"image_url": str(self._icon_path.joinpath("small_folder.png"))}
if not read_only:
ui.Spacer(width=3)
open_button = ui.Button(style=style, width=20, tooltip="Open")
open_button.set_clicked_fn(self._show_file_picker)
if not self._layer_path_model.anonymous():
ui.Spacer(width=3)
style["image_url"] = str(self._icon_path.joinpath("find.png"))
find_button = ui.Button(style=style, width=20, tooltip="Find")
def find_button_fn():
path = self._layer_path_field.model.get_value_as_string()
# Remove checkpoint and branch so navigate_to works
client_url = omni.client.break_url(path)
path = omni.client.make_url(
scheme=client_url.scheme,
user=client_url.user,
host=client_url.host,
port=client_url.port,
path=client_url.path,
query=None,
fragment=client_url.fragment,
)
content.get_content_window().navigate_to(path)
find_button.set_clicked_fn(find_button_fn)
if not self._layer_path_model.anonymous():
if self._filter.matches("Checkpoint"):
self._build_checkpoint_ui(layer_item().identifier)
self._any_item_visible = True
else:
selected_info_name = "(nothing selected)"
ui.StringField(name="layer_path", height=LABEL_HEIGHT, enabled=False).model.set_value(selected_info_name)
def _build_checkpoint_ui(self, absolute_layer_path):
try:
# Use checkpoint widget in the drop down menu for more detailed information
from omni.kit.widget.versioning.checkpoint_combobox import CheckpointCombobox
with ui.HStack(spacing=HORIZONTAL_SPACING):
self.add_label("Checkpoint")
def on_selection_changed(selection):
if selection:
self._layer_path_model.replace_layer(selection.get_full_url())
self._checkpoint_combobox = CheckpointCombobox(absolute_layer_path, on_selection_changed)
return None
except ImportError as e:
# If the widget is not available, create a simple combo box instead
carb.log_warn(f"Checkpoint widget in Layer Path widget is not availbale due to: {e}")
class LayerMetaWiget(SimplePropertyWidget):
def __init__(self, icon_path):
super().__init__(title="Layer Metadata", collapsed=False)
self._icon_path = icon_path
self._models = {}
self._meta_change_listener = None
def on_new_payload(self, payload):
if not super().on_new_payload(payload):
return False
return payload is not None
def reset(self):
super().reset()
self._meta_change_listener = None
self._models = {}
def _on_meta_changed(self, event: carb.events.IEvent):
payload = get_layer_event_payload(event)
if payload and payload.event_type == LayerEventType.INFO_CHANGED:
layer_item = self._payload
if layer_item and layer_item() and layer_item().layer:
layer_item = layer_item()
if layer_item.identifier in payload.layer_info_data:
info_tokens = payload.layer_info_data.get(layer_item.identifier, [])
for token in info_tokens:
model = self._models.get(token, None)
if model:
model.on_value_changed()
def build_items(self):
layer_item = self._payload
if layer_item and layer_item() and layer_item().layer:
usd_context = layer_item().usd_context
layers = get_layers(usd_context)
event_stream = layers.get_event_stream()
self._meta_change_listener = event_stream.create_subscription_to_pop(self._on_meta_changed, name="Layers Property Window")
model = LayerWorldAxisModel(layer_item)
self._models[model.get_usd_token_name()] = model
if self._filter.matches("World Axis"):
with ui.HStack(spacing=HORIZONTAL_SPACING):
self.add_label("World Axis")
ui.ComboBox(model, name="choices")
self._any_item_visible = True
for index in range(LayerMetaType.NUM_PROPERTIES):
model = LayerMetaModel(layer_item, index)
if model.get_value_as_string() is not None:
self.add_item_with_model(LayerMetaName[index], model, True)
self._models[model.get_usd_token_name()] = model
|
omniverse-code/kit/exts/omni.kit.property.layer/omni/kit/property/layer/__init__.py | # Copyright (c) 2018-2020, NVIDIA CORPORATION. All rights reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
from .widgets import LayerPropertyWidgets, get_instance
from .commands import ModifyStageAxisCommand, ModifyLayerMetadataCommand
|
omniverse-code/kit/exts/omni.kit.property.layer/omni/kit/property/layer/file_picker.py | import asyncio
import os
import re
import psutil
import carb
import omni.ui
import omni.client
from typing import Callable, Iterable, Tuple, Union
from omni.kit.window.filepicker import FilePickerDialog
from omni.kit.widget.filebrowser import FileBrowserItem
class FileBrowserSelectionType:
FILE_ONLY = 0
DIRECTORY_ONLY = 1
ALL = 2
class FilePicker:
"""
Args:
title (str): Title of the window.
apply_button_name (str): Name of the confirm button.
selection_type (FileBrowserSelectionType): The file type that confirm event will respond to.
item_filter_options (Iterable[Tuple[Union[re.Pattern, str], str]]):
Array of filter options. Element of array is a tuple that first
element of this tuple is the regex for filtering (string or compiled
re.Pattern), and second element of this tuple is the descriptions,
like (".*", "All Files"). By default, it will list all files.
"""
def __init__(
self,
title: str,
apply_button_name: str,
selection_type: FileBrowserSelectionType = FileBrowserSelectionType.ALL,
item_filter_options: Iterable[Tuple[Union[re.Pattern, str], str]] = ((
re.compile(".*"), "All Files (*.*)")),
):
self._title = title
self._filepicker = None
self._selection_type = selection_type
self._custom_select_fn = None
self._custom_cancel_fn = None
self._apply_button_name = apply_button_name
self._filter_regexes = []
self._filter_descriptions = []
self._current_directory = None
for regex, desc in item_filter_options:
if not isinstance(regex, re.Pattern):
regex = re.compile(regex, re.IGNORECASE)
self._filter_regexes.append(regex)
self._filter_descriptions.append(desc)
self._build_ui()
def destroy(self):
self.set_custom_fn(None, None)
if self._filepicker:
self._filepicker.destroy()
def set_custom_fn(self, select_fn, cancel_fn):
self._custom_select_fn = select_fn
self._custom_cancel_fn = cancel_fn
def show_dialog(self):
self._filepicker.show(self._current_directory)
self._current_directory = None
def hide_dialog(self):
self._filepicker.hide()
def set_current_directory(self, dir: str):
self._current_directory = dir
def set_current_filename(self, filename: str):
self._filepicker.set_filename(filename)
def _build_ui(self):
on_click_open = lambda f, d: asyncio.ensure_future(self._on_click_open(f, d))
on_click_cancel = lambda f, d: asyncio.ensure_future(self._on_click_cancel(f, d))
# Create the dialog
self._filepicker = FilePickerDialog(
self._title,
allow_multi_selection=False,
apply_button_label=self._apply_button_name,
click_apply_handler=on_click_open,
click_cancel_handler=on_click_cancel,
item_filter_options=self._filter_descriptions,
item_filter_fn=lambda item: self._on_filter_item(item),
error_handler=lambda m: self._on_error(m),
)
# Start off hidden
self.hide_dialog()
def _on_filter_item(self, item: FileBrowserItem) -> bool:
if not item or item.is_folder:
return True
if self._filepicker.current_filter_option >= len(self._filter_regexes):
return False
regex = self._filter_regexes[self._filepicker.current_filter_option]
if regex.match(item.path):
return True
else:
return False
def _on_error(self, msg: str):
"""
Demonstrates error handling. Instead of just printing to the shell, the App can
display the error message to a console window.
"""
print(msg)
async def _on_click_open(self, filename: str, dirname: str):
"""
The meat of the App is done in this callback when the user clicks 'Accept'. This is
a potentially costly operation so we implement it as an async operation. The inputs
are the filename and directory name. Together they form the fullpath to the selected
file.
"""
dirname = dirname.strip()
if dirname and not dirname.endswith("/"):
dirname += "/"
fullpath = f"{dirname}{filename}"
result, entry = omni.client.stat(fullpath)
if result == omni.client.Result.OK and entry.flags & omni.client.ItemFlags.CAN_HAVE_CHILDREN:
is_folder = True
else:
is_folder = False
if (is_folder and self._selection_type == FileBrowserSelectionType.FILE_ONLY) or (
not is_folder and self._selection_type == FileBrowserSelectionType.DIRECTORY_ONLY
):
return
self.hide_dialog()
await omni.kit.app.get_app().next_update_async()
if self._custom_select_fn:
self._custom_select_fn(fullpath)
async def _on_click_cancel(self, filename: str, dirname: str):
"""
This function is called when the user clicks 'Cancel'.
"""
self.hide_dialog()
await omni.kit.app.get_app().next_update_async()
if self._custom_cancel_fn:
self._custom_cancel_fn()
|
omniverse-code/kit/exts/omni.kit.property.layer/omni/kit/property/layer/types.py | class LayerMetaType:
START_TIME = 0
END_TIME = 1
TIMECODES_PER_SECOND = 2
FPS_PER_SECOND = 3
UNITS = 4
LAYER_OFFSET = 5
LAYER_SCALE = 6
KG_PER_UNIT = 7
COMMENT = 8
DOC = 9
NUM_PROPERTIES = 10
LayerMetaName = [
"Start Time Code",
"End Time Code",
"Time Codes Per Second",
"Frames Per Second",
"Meters Per Unit",
"Layer Offset",
"Layer Scale",
"Kgs Per Unit",
"Comment",
"Documentation"
]
|
omniverse-code/kit/exts/omni.kit.property.layer/omni/kit/property/layer/tests/test_property_window.py | ## Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
##
## NVIDIA CORPORATION and its licensors retain all intellectual property
## and proprietary rights in and to this software, related documentation
## and any modifications thereto. Any use, reproduction, disclosure or
## distribution of this software and related documentation without an express
## license agreement from NVIDIA CORPORATION is strictly prohibited.
##
import tempfile
import os
import omni.kit.app
import omni.kit.commands
import omni.kit.test
import omni.ui as ui
import omni.kit.widget.layers as layers_widget
import omni.kit.property.layer as layers_property
from omni.kit.property.layer.layer_property_models import LayerMetaModel, LayerWorldAxisModel
from omni.kit.property.layer.types import LayerMetaType
from omni.ui.tests.test_base import OmniUiTest
from pxr import Kind, Sdf, Gf, UsdGeom, UsdPhysics
class TestLayerPropertyUI(OmniUiTest):
# Before running each test
async def setUp(self):
await super().setUp()
self._usd_context = omni.usd.get_context()
await self._usd_context.new_stage_async()
# After running each test
async def tearDown(self):
await self._usd_context.close_stage_async()
await super().tearDown()
async def wait_for_update(self, usd_context=omni.usd.get_context(), wait_frames=10):
max_loops = 0
while max_loops < wait_frames:
_, files_loaded, total_files = usd_context.get_stage_loading_status()
await omni.kit.app.get_app().next_update_async()
if files_loaded or total_files:
continue
max_loops = max_loops + 1
async def test_layer_replacement(self):
omni.usd.get_context().set_pending_edit(False)
stage = self._usd_context.get_stage()
root_layer = stage.GetRootLayer()
sublayer = Sdf.Layer.CreateAnonymous()
sublayer_replace = Sdf.Layer.CreateAnonymous()
root_layer.subLayerPaths.append(sublayer.identifier)
missing_identifier = "non_existed_sublayer_identifier.usd"
root_layer.subLayerPaths.append(missing_identifier)
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
layers_widget.get_instance().set_current_focused_layer_item(sublayer.identifier)
# Wait several frames to make sure it's focused
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
# Make sure it's changed
focused_item = layers_widget.get_instance().get_current_focused_layer_item()
self.assertTrue(focused_item)
self.assertEqual(focused_item.identifier, sublayer.identifier)
layer_path_widget = layers_property.get_instance()._layer_path_widget
layer_path_widget._show_file_picker()
await self.wait_for_update()
layer_path_widget._on_file_selected(sublayer_replace.identifier)
await self.wait_for_update()
# Make sure it's replaced
self.assertTrue(root_layer.subLayerPaths[0], sublayer_replace.identifier)
omni.kit.undo.undo()
self.assertTrue(root_layer.subLayerPaths[0], sublayer.identifier)
# Focus and replace missing layer
layers_widget.get_instance().set_current_focused_layer_item(missing_identifier)
# Wait several frames to make sure it's focused
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
# Make sure it's changed
focused_item = layers_widget.get_instance().get_current_focused_layer_item()
self.assertTrue(focused_item and focused_item.missing)
self.assertEqual(focused_item.identifier, missing_identifier)
layer_path_widget = layers_property.get_instance()._layer_path_widget
layer_path_widget._show_file_picker()
await self.wait_for_update()
layer_path_widget._on_file_selected(sublayer_replace.identifier)
await self.wait_for_update()
# Make sure it's replaced
self.assertTrue(root_layer.subLayerPaths[0], sublayer_replace.identifier)
async def test_commands(self):
test_comment = "test comment"
test_doc = "test document"
test_start_time = "0.0"
test_end_time = "96.0"
test_timecodes_per_second = "24.0"
test_fps_per_second = "24.0"
test_units = "10.0"
test_kg_per_units = "10.0"
test_layer_offset = "1.0"
test_layer_scale = "10.0"
omni.usd.get_context().set_pending_edit(False)
stage = self._usd_context.get_stage()
root_layer = stage.GetRootLayer()
layers_widget.get_instance().set_current_focused_layer_item(root_layer.identifier)
await self.wait_for_update()
meta_models = layers_property.get_instance()._meta_widget._models
modified_metadata = {}
old_up_index = new_up_index = None
for token, model in meta_models.items():
if isinstance(model, LayerMetaModel):
new_value = None
if model._meta_type == LayerMetaType.COMMENT:
new_value = test_comment
elif model._meta_type == LayerMetaType.DOC:
new_value = test_doc
elif model._meta_type == LayerMetaType.START_TIME:
new_value = test_start_time
elif model._meta_type == LayerMetaType.END_TIME:
new_value = test_end_time
elif model._meta_type == LayerMetaType.TIMECODES_PER_SECOND:
new_value = test_timecodes_per_second
elif model._meta_type == LayerMetaType.UNITS:
new_value = test_units
elif model._meta_type == LayerMetaType.KG_PER_UNIT:
new_value = test_kg_per_units
elif model._meta_type == LayerMetaType.FPS_PER_SECOND and root_layer.HasFramesPerSecond():
new_value = test_fps_per_second
if new_value:
model.set_value(new_value)
model.end_edit()
modified_metadata[model._meta_type] = model
elif isinstance(model, LayerWorldAxisModel):
old_up_index = model._current_index.get_value_as_int()
if old_up_index == 0: # up_axis is UsdGeom.Tokens.y
new_up_index = 1
else: # up_axis is UsdGeom.Tokens.z
new_up_index = 0
model._current_index.set_value(new_up_index)
# Wait several frames to make sure it's focused
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
# Check if the metadata is set correctly
for meta_type, model in modified_metadata.items():
if meta_type == LayerMetaType.COMMENT:
self.assertEqual(test_comment, str(root_layer.comment))
elif meta_type == LayerMetaType.DOC:
self.assertEqual(test_doc, str(root_layer.documentation))
elif meta_type == LayerMetaType.START_TIME:
self.assertEqual(test_start_time, str(root_layer.startTimeCode))
elif meta_type == LayerMetaType.END_TIME:
self.assertEqual(test_end_time, str(root_layer.endTimeCode))
elif meta_type == LayerMetaType.TIMECODES_PER_SECOND:
self.assertEqual(test_timecodes_per_second, str(root_layer.timeCodesPerSecond))
elif meta_type == LayerMetaType.UNITS:
meters = UsdGeom.GetStageMetersPerUnit(stage)
self.assertEqual(test_units, str(meters))
elif meta_type == LayerMetaType.KG_PER_UNIT:
kilograms = UsdPhysics.GetStageKilogramsPerUnit(stage)
self.assertEqual(test_kg_per_units, str(kilograms))
elif meta_type == LayerMetaType.FPS_PER_SECOND and root_layer.HasFramesPerSecond():
self.assertEqual(test_fps_per_second, str(root_layer.framesPerSecond))
if new_up_index is not None:
up_axis = UsdGeom.GetStageUpAxis(stage)
if new_up_index == 0:
self.assertEqual(up_axis, UsdGeom.Tokens.y)
elif new_up_index == 1:
self.assertEqual(up_axis, UsdGeom.Tokens.z)
# Testing metadata for sublayers
sublayer = Sdf.Layer.CreateAnonymous()
root_layer.subLayerPaths.append(sublayer.identifier)
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
layers_widget.get_instance().set_current_focused_layer_item(sublayer.identifier)
# Wait several frames to make sure it's focused
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
await omni.kit.app.get_app().next_update_async()
# Make sure it's changed
focused_item = layers_widget.get_instance().get_current_focused_layer_item()
self.assertTrue(focused_item)
self.assertEqual(focused_item.identifier, sublayer.identifier)
meta_models = layers_property.get_instance()._meta_widget._models
modified_metadata = {}
for token, model in meta_models.items():
if isinstance(model, LayerMetaModel):
new_value = None
if model._meta_type == LayerMetaType.LAYER_OFFSET and model._layer_item().parent:
new_value = test_layer_offset
elif model._meta_type == LayerMetaType.LAYER_SCALE and model._layer_item().parent:
new_value = test_layer_scale
if new_value:
model.set_value(new_value)
model.end_edit()
modified_metadata[model._meta_type] = model
# Check if the metadata is set correctly
for meta_type, model in modified_metadata.items():
parent = model._layer_item().parent
layer = model._layer_item().layer
layer_index = layers_widget.LayerUtils.get_sublayer_position_in_parent(parent.identifier, layer.identifier)
offset = parent.layer.subLayerOffsets[layer_index]
if meta_type == LayerMetaType.LAYER_OFFSET:
self.assertEqual(test_layer_offset, str(offset.offset))
elif meta_type == LayerMetaType.LAYER_SCALE and model._layer_item().parent:
self.assertEqual(test_layer_scale, str(offset.scale))
async def test_shut_down(self):
manager = omni.kit.app.get_app().get_extension_manager()
ext_id = "omni.kit.property.layer"
self.assertTrue(ext_id)
self.assertTrue(manager.is_extension_enabled(ext_id))
manager.set_extension_enabled(ext_id, False)
await self.wait_for_update()
self.assertTrue(not manager.is_extension_enabled(ext_id))
manager.set_extension_enabled(ext_id, True)
await self.wait_for_update()
self.assertTrue(manager.is_extension_enabled(ext_id))
|
omniverse-code/kit/exts/omni.kit.property.layer/omni/kit/property/layer/tests/__init__.py | from .test_property_window import * |
omniverse-code/kit/exts/omni.kit.property.layer/docs/CHANGELOG.md | # Changelog
The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
## [1.1.4] - 2023-01-17
### Changes
- Delay frames until layer item is initialized after replacing.
## [1.1.3] - 2022-03-31
### Changes
- Integrate new omni.kit.usd.layers interfaces to replace layers interfaces from omni.usd.
## [1.1.2] - 2021-06-11
### Fixes
- Fix regression to replace missing layer.
## [1.1.1] - 2021-04-23
### Changes
- Disabled large selection optimization
## [1.1.0] - 2021-03-25
### Added
- Added checkpoint dropdown to Layer Path Widget. Requires `omni.kit.widget.versioning` to be enabled.
## [1.0.1] - 2020-12-09
### Changes
- Added extension icon
- Updated preview image
## [1.0.0] - 2020-10-07
### Added
- Layer Widgets Released.
|
omniverse-code/kit/exts/omni.kit.property.layer/docs/index.rst | omni.kit.property.layer
###########################
Layer Property Window Widgets
.. toctree::
:maxdepth: 1
CHANGELOG
|
omniverse-code/kit/exts/omni.graph.io/ogn/nodes.json | {
"nodes": {
"omni.graph.BundleToUSDA": {
"description": "Outputs a represention of the content of a bundle as usda text",
"version": 1,
"extension": "omni.graph.io",
"language": "C++"
},
"omni.graph.ExportUSDPrim": {
"description": "Exports data from an input bundle into a USD prim",
"version": 1,
"extension": "omni.graph.io",
"language": "C++"
},
"omni.graph.ImportUSDPrim": {
"description": "Imports data from a USD prim into attributes in an output bundle",
"version": 1,
"extension": "omni.graph.io",
"language": "C++"
},
"omni.graph.TransformBundle": {
"description": "Applies a transform to an input bundle, storing the result in an output bundle",
"version": 1,
"extension": "omni.graph.io",
"language": "C++"
}
}
}
|
omniverse-code/kit/exts/omni.graph.io/ogn/docs/OgnImportUSDPrim.rst | .. _omni_graph_ImportUSDPrim_1:
.. _omni_graph_ImportUSDPrim:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: import USD prim data
:keywords: lang-en omnigraph node graph import-u-s-d-prim
import USD prim data
====================
.. <description>
Imports data from a USD prim into attributes in an output bundle
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.io<ext_omni_graph_io>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"inputs:applySkelBinding", "``bool``", "If the input USD prim is a Mesh, and has SkelBindingAPI schema applied, compute skinned points and normals.", "True"
"", "*displayGroup*", "parameters", ""
"inputs:applyTransform", "``bool``", "If importAttributes is true, apply the transform necessary to transform any transforming attributes into the space of this node.", "False"
"", "*displayGroup*", "parameters", ""
"Attributes To Import (*inputs:attrNamesToImport*)", "``token``", "Comma or space separated text, listing the names of attributes in the input data to be imported or empty to import all attributes.", ""
"", "*displayGroup*", "parameters", ""
"inputs:computeBoundingBox", "``bool``", "Compute and store local bounding box of a prim and its children.", "False"
"", "*displayGroup*", "parameters", ""
"inputs:importAttributes", "``bool``", "Import attribute data from the USD prim.", "True"
"", "*displayGroup*", "parameters", ""
"inputs:importPath", "``bool``", "Record the input USD prim's path into the output bundle in an attribute named ""primPath"".", "True"
"", "*displayGroup*", "parameters", ""
"inputs:importPrimvarMetadata", "``bool``", "Import metadata like the interpolation type for primvars, and store it as attributes in the output bundle.", "True"
"", "*displayGroup*", "parameters", ""
"inputs:importTime", "``bool``", "Record the usdTimecode above into the output bundle in an attribute named ""primTime"".", "True"
"", "*displayGroup*", "parameters", ""
"inputs:importTransform", "``bool``", "Record the transform required to take any attributes of the input USD prim into the space of this node, i.e. the world transform of the input prim times the inverse world transform of this node, into the output bundle in an attribute named ""transform"".", "True"
"", "*displayGroup*", "parameters", ""
"inputs:importType", "``bool``", "Deprecated, prim type is always imported", "True"
"", "*hidden*", "true", ""
"", "*displayGroup*", "parameters", ""
"Attributes To Rename (*inputs:inputAttrNames*)", "``token``", "Comma or space separated text, listing the names of attributes in the input data to be renamed", ""
"inputs:keepPrimsSeparate", "``bool``", "Prefix output attribute names with ""prim"" followed by a unique number and a colon, to keep the attributes for separate input prims separate. The prim paths will be in the ""primPaths"" token array attribute.", "True"
"", "*displayGroup*", "parameters", ""
"New Attribute Names (*inputs:outputAttrNames*)", "``token``", "Comma or space separated text, listing the new names for the attributes listed in inputAttrNames", ""
"inputs:prim", "``bundle``", "The USD prim from which to import data.", "None"
"inputs:renameAttributes", "``bool``", "If true, attributes listed in ""inputAttrNames"" will be imported to attributes with the names specified in ""outputAttrNames"".", "False"
"", "*displayGroup*", "parameters", ""
"inputs:timeVaryingAttributes", "``bool``", "Check whether the USD attributes are time-varying and if so, import their data at the time ""usdTimecode"".", "True"
"", "*displayGroup*", "parameters", ""
"inputs:usdTimecode", "``double``", "The time at which to evaluate the transform of the USD prim.", "0"
"", "*displayGroup*", "parameters", ""
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"outputs:output", "``bundle``", "Output bundle containing all of the imported data.", "None"
State
-----
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"state:prevApplySkelBinding", "``bool``", "Value of ""applySkelBinding"" input from previous run", "None"
"state:prevApplyTransform", "``bool``", "Value of ""applyTransform"" input from previous run", "None"
"state:prevAttrNamesToImport", "``token``", "Value of ""attrNamesToImport"" input from previous run", "None"
"state:prevComputeBoundingBox", "``bool``", "Value of ""computeBoundingBox"" input from previous run", "None"
"state:prevImportAttributes", "``bool``", "Value of ""importAttributes"" input from previous run", "None"
"state:prevImportPath", "``bool``", "Value of ""importPath"" input from previous run", "None"
"state:prevImportPrimvarMetadata", "``bool``", "Value of ""importPrimvarMetadata"" input from previous run", "None"
"state:prevImportTime", "``bool``", "Value of ""importTime"" input from previous run", "None"
"state:prevImportTransform", "``bool``", "Value of ""importTransform"" input from previous run", "None"
"state:prevImportType", "``bool``", "Value of ""importType"" input from previous run", "None"
"state:prevInputAttrNames", "``token``", "Value of ""inputAttrNames"" input from previous run", "None"
"state:prevInvNodeTransform", "``matrixd[4]``", "Inverse transform of the node prim from the previous run.", "None"
"state:prevKeepPrimsSeparate", "``bool``", "Value of ""keepPrimsSeparate"" input from previous run", "None"
"state:prevOnlyImportSpecified", "``bool``", "Value of ""onlyImportSpecified"" input from previous run", "None"
"state:prevOutputAttrNames", "``token``", "Value of ""outputAttrNames"" input from previous run", "None"
"state:prevPaths", "``token[]``", "Array of paths from the previous run.", "None"
"state:prevRenameAttributes", "``bool``", "Value of ""renameAttributes"" input from previous run", "None"
"state:prevTimeVaryingAttributes", "``bool``", "Value of ""timeVaryingAttributes"" input from previous run", "None"
"state:prevTransforms", "``matrixd[4][]``", "Array of transforms from the previous run.", "None"
"state:prevUsdTimecode", "``double``", "Value of ""usdTimecode"" input from previous run", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.ImportUSDPrim"
"Version", "1"
"Extension", "omni.graph.io"
"Icon", "ogn/icons/omni.graph.ImportUSDPrim.svg"
"Has State?", "True"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "None"
"uiName", "import USD prim data"
"Generated Class Name", "OgnImportUSDPrimDatabase"
"Python Module", "omni.graph.io"
|
omniverse-code/kit/exts/omni.graph.io/ogn/docs/OgnTransformBundle.rst | .. _omni_graph_TransformBundle_1:
.. _omni_graph_TransformBundle:
.. ================================================================================
.. THIS PAGE IS AUTO-GENERATED. DO NOT MANUALLY EDIT.
.. ================================================================================
:orphan:
.. meta::
:title: transform bundle
:keywords: lang-en omnigraph node graph transform-bundle
transform bundle
================
.. <description>
Applies a transform to an input bundle, storing the result in an output bundle
.. </description>
Installation
------------
To use this node enable :ref:`omni.graph.io<ext_omni_graph_io>` in the Extension Manager.
Inputs
------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"inputs:input", "``bundle``", "Input bundle containing the attributes to be transformed.", "None"
"inputs:transform", "``matrixd[4]``", "The transform to apply to the bundle", "[[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]]"
"", "*displayGroup*", "parameters", ""
Outputs
-------
.. csv-table::
:header: "Name", "Type", "Descripton", "Default"
:widths: 20, 20, 50, 10
"outputs:output", "``bundle``", "Output bundle containing all of the transformed attributes", "None"
Metadata
--------
.. csv-table::
:header: "Name", "Value"
:widths: 30,70
"Unique ID", "omni.graph.TransformBundle"
"Version", "1"
"Extension", "omni.graph.io"
"Icon", "ogn/icons/omni.graph.TransformBundle.svg"
"Has State?", "False"
"Implementation Language", "C++"
"Default Memory Type", "cpu"
"Generated Code Exclusions", "None"
"uiName", "transform bundle"
"Generated Class Name", "OgnTransformBundleDatabase"
"Python Module", "omni.graph.io"
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.