vse_toolbox/operators/imports.py

from pathlib import Path

import bpy
from bpy.types import Operator
from bpy.props import (CollectionProperty, BoolProperty, EnumProperty, StringProperty)

from vse_toolbox.constants import (EDITS, EDIT_SUFFIXES, MOVIES, MOVIE_SUFFIXES,
    SOUNDS, SOUND_SUFFIXES)

from vse_toolbox.sequencer_utils import (clean_sequencer, import_edit, import_movie,
    import_sound, get_strips)
       
from vse_toolbox.bl_utils import get_scene_settings
from vse_toolbox.file_utils import install_module


class VSETB_OT_auto_select_files(Operator):
    bl_idname = "import.auto_select_files"
    bl_label = "Auto Select"
    bl_description = "Auto Select Files"
    bl_options = {"REGISTER", "UNDO"}

    @classmethod
    def poll(cls, context):
        return True

    def get_items(self, items=[]):
        if not items:
            return [('NONE', 'None', '', 0)]
        return [(e, e, '', i) for i, e in enumerate(items)]

    def execute(self, context):
        params = context.space_data.params
        directory = Path(params.directory.decode())
        
        EDITS.clear()
        MOVIES.clear()
        SOUNDS.clear()
        
        edits = []
        movies = []
        sounds = []

        for file_entry in directory.glob('*'):
            if file_entry.is_dir():
                continue

            if file_entry.suffix in EDIT_SUFFIXES:
                edits.append(file_entry.name)
            elif file_entry.suffix in MOVIE_SUFFIXES:
                movies.append(file_entry.name)
            elif file_entry.suffix in SOUND_SUFFIXES:
                sounds.append(file_entry.name)

        edits.sort(reverse=True)
        movies.sort(reverse=True)
        sounds.sort(reverse=True)

        EDITS.extend(self.get_items(items=edits))
        MOVIES.extend(self.get_items(items=movies))
        SOUNDS.extend(self.get_items(items=sounds))

        return {'FINISHED'}


class VSETB_OT_import_files(Operator):
    bl_idname = "vse_toolbox.import_files"
    bl_label = "Import"
    bl_description = "Import Edit"
    bl_options = {"REGISTER", "UNDO"}
    
    directory : StringProperty(subtype='DIR_PATH')
    filepath: StringProperty(
        name="File Path",
        description="Filepath used for importing the file",
        maxlen=1024,
        subtype='FILE_PATH',
    )
    files : CollectionProperty(type=bpy.types.OperatorFileListElement)
    clean_sequencer : BoolProperty(
        name="Clean Sequencer",
        default=False,
        description="Clean all existing strips in sequencer",
    )
    
    import_edit : BoolProperty(name='', default=True)
    edit: EnumProperty(name='', items=lambda s, c: EDITS)

    import_movie : BoolProperty(name='', default=False)
    movie: EnumProperty(name='', items=lambda s, c: MOVIES)

    import_sound : BoolProperty(name='', default=False)
    sound: EnumProperty(name='', items=lambda s, c: SOUNDS)

    @classmethod
    def poll(cls, context):
        return True

    def draw(self, context):
        scn = context.scene
        settings = get_scene_settings()

        layout = self.layout
        layout.use_property_split = True 
        layout.use_property_decorate = False

        col = layout.column(align=True)
        col.operator('import.auto_select_files', text='Auto Select')

        row = self.layout.row(heading="Import Edit", align=True)
        row.prop(self, 'import_edit')
        sub = row.row(align=True)
        sub.active = self.import_edit
        sub.prop(self, 'edit')

        row = self.layout.row(heading="Import Movie", align=True)
        row.prop(self, 'import_movie')
        sub = row.row()
        sub.active = self.import_movie
        sub.prop(self, 'movie')

        row = self.layout.row(heading="Import Sound", align=True)
        row.prop(self, 'import_sound')
        sub = row.row()
        sub.active = self.import_sound
        sub.prop(self, 'sound')

        col = layout.column()
        col.separator()
        col.prop(self, 'clean_sequencer')

    def invoke(self, context, event):
        context.window_manager.fileselect_add(self)
        return {'RUNNING_MODAL'}

    def execute(self, context):
        sequencer = context.scene.sequence_editor.sequences

        edit_filepath = Path(self.directory, self.edit)
        if not edit_filepath.exists():
            self.import_edit = False

        movie_filepath = Path(self.directory, self.movie)
        if not movie_filepath.exists():
            self.import_movie = False
        
        sound_filepath = Path(self.directory, self.sound)
        if not sound_filepath.exists():
            self.import_sound = False
        
        if self.clean_sequencer:
            clean_sequencer(
                edit=self.import_edit,
                movie=self.import_movie,
                sound=self.import_sound,
            )
        
        if self.import_edit:
            print(f'[>.] Loading Edit from: {str(edit_filepath)}')

            import_edit(edit_filepath, adapter="cmx_3600")
        
        if self.import_movie:
            print(f'[>.] Loading Movie from: {str(movie_filepath)}')

            for strip in get_strips(channel='Movie'):
                sequencer.remove(strip)

            import_movie(movie_filepath)

        if self.import_sound or (not self.import_sound and self.import_movie):

            for strip in get_strips(channel='Audio'):
                sequencer.remove(strip)

            if self.import_sound:
                print(f'[>.] Loading Audio from: {str(sound_filepath)}')
                import_sound(sound_filepath)
            else:
                print(f'[>.] Loading Audio from: {str(movie_filepath)}')
                import_sound(movie_filepath)
        
        context.scene.sequence_editor.sequences.update()

        return {"FINISHED"}

classes = (
    VSETB_OT_auto_select_files,
    VSETB_OT_import_files,
)

def register(): 
    for cls in classes:
        bpy.utils.register_class(cls)

def unregister():
    for cls in reversed(classes):
        bpy.utils.unregister_class(cls)