Added description for PillarCredentialsUpdate operator.

The bl_info['version'] value is just a tuple of numbers, so there is no
room for beta version info. I did add a warning, though.

.gitignore

@@ -1,10 +1,10 @@
 *.pyc
 *.swp
-*.blend
-*.blend[1-9]
+/*.blend*
 blender_cloud/wheels/*.whl
 /textures*/
 /test_*.py
 /dist/
 /build/
 /addon-bundle/*.zip
+__pycache__

addon-bundle/bundle.sh

@@ -1,10 +1,30 @@
 #!/bin/bash
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
 
 cd $(dirname $(readlink -f $0))
 
 BCLOUD=$(ls ../dist/blender_cloud-*.addon.zip | tail -n 1)
 BID=$(ls ../../../blender-id-addon/dist/blender_id-*.addon.zip | tail -n 1)
 
+[ -z "$BCLOUD" ] && echo "BCloud addon not found" >&2
+[ -z "$BID" ] && echo "B'ID addon not found" >&2
+
 cp -va $BCLOUD $BID .
 
 BUNDLE=$(basename $BCLOUD)

blender_cloud/__init__.py

@@ -20,8 +20,8 @@
 
 bl_info = {
     'name': 'Blender Cloud',
-    'author': 'Sybren A. Stüvel and Francesco Siddi',
-    'version': (1, 3, 3),
+    "author": "Sybren A. Stüvel, Francesco Siddi, Inês Almeida, Antony Riakiotakis",
+    'version': (1, 4, 99),
     'blender': (2, 77, 0),
     'location': 'Addon Preferences panel, and Ctrl+Shift+Alt+A anywhere for texture browser',
     'description': 'Texture library browser and Blender Sync. Requires the Blender ID addon '
@@ -29,7 +29,7 @@ bl_info = {
     'wiki_url': 'http://wiki.blender.org/index.php/Extensions:2.6/Py/'
                 'Scripts/System/BlenderCloud',
     'category': 'System',
-    'support': 'OFFICIAL'
+    'warning': 'This is a beta version; the first to support Attract.'
 }
 
 import logging
@@ -72,15 +72,17 @@ def register():
 
         reload_mod('blendfile')
         reload_mod('home_project')
+        reload_mod('utils')
 
         blender = reload_mod('blender')
         async_loop = reload_mod('async_loop')
         texture_browser = reload_mod('texture_browser')
         settings_sync = reload_mod('settings_sync')
         image_sharing = reload_mod('image_sharing')
+        attract = reload_mod('attract')
     else:
         from . import (blender, texture_browser, async_loop, settings_sync, blendfile, home_project,
-                       image_sharing)
+                       image_sharing, attract)
 
     async_loop.setup_asyncio_executor()
     async_loop.register()
@@ -89,6 +91,7 @@ def register():
     blender.register()
     settings_sync.register()
     image_sharing.register()
+    attract.register()
 
 
 def _monkey_patch_requests():
@@ -109,9 +112,10 @@ def _monkey_patch_requests():
 
 
 def unregister():
-    from . import blender, texture_browser, async_loop, settings_sync, image_sharing
+    from . import blender, texture_browser, async_loop, settings_sync, image_sharing, attract
 
     image_sharing.unregister()
+    attract.unregister()
     settings_sync.unregister()
     blender.unregister()
     texture_browser.unregister()

blender_cloud/async_loop.py

@@ -1,3 +1,21 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
 """Manages the asyncio loop."""
 
 import asyncio
@@ -160,12 +178,31 @@ class AsyncModalOperatorMixin:
     log = logging.getLogger('%s.AsyncModalOperatorMixin' % __name__)
 
     _state = 'INITIALIZING'
+    stop_upon_exception = False
 
     def invoke(self, context, event):
         context.window_manager.modal_handler_add(self)
         self.timer = context.window_manager.event_timer_add(1 / 15, context.window)
+
+        self.log.info('Starting')
+        self._new_async_task(self.async_execute(context))
+
         return {'RUNNING_MODAL'}
 
+    async def async_execute(self, context):
+        """Entry point of the asynchronous operator.
+
+        Implement in a subclass.
+        """
+        return
+
+    def quit(self):
+        """Signals the state machine to stop this operator from running."""
+        self._state = 'QUIT'
+
+    def execute(self, context):
+        return self.invoke(context, None)
+
     def modal(self, context, event):
         task = self.async_task
 
@@ -174,6 +211,11 @@ class AsyncModalOperatorMixin:
             if ex is not None:
                 self._state = 'EXCEPTION'
                 self.log.error('Exception while running task: %s', ex)
+                if self.stop_upon_exception:
+                    self.quit()
+                    self._finish(context)
+                    return {'FINISHED'}
+
                 return {'RUNNING_MODAL'}
 
         if self._state == 'QUIT':

blender_cloud/attract/__init__.py

@@ -0,0 +1,446 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+# <pep8 compliant>
+
+# Old info, kept here for reference, so that we can merge wiki pages,
+# descriptions, etc.
+#
+# bl_info = {
+#     "name": "Attract",
+#     "author": "Francesco Siddi, Inês Almeida, Antony Riakiotakis",
+#     "version": (0, 2, 0),
+#     "blender": (2, 76, 0),
+#     "location": "Video Sequence Editor",
+#     "description":
+#         "Blender integration with the Attract task tracking service"
+#         ". *requires the Blender ID add-on",
+#     "wiki_url": "http://wiki.blender.org/index.php/Extensions:2.6/Py/"
+#                 "Scripts/Workflow/Attract",
+#     "category": "Workflow",
+#     "support": "TESTING"
+# }
+
+import functools
+import logging
+
+if "bpy" in locals():
+    import importlib
+
+    importlib.reload(draw)
+else:
+    from . import draw
+
+import bpy
+from pillarsdk.nodes import Node
+from pillarsdk.projects import Project
+from pillarsdk import exceptions as sdk_exceptions
+
+from bpy.types import Operator, Panel, AddonPreferences
+
+log = logging.getLogger(__name__)
+
+
+def active_strip(context):
+    try:
+        return context.scene.sequence_editor.active_strip
+    except AttributeError:
+        return None
+
+
+def remove_atc_props(strip):
+    """Resets the attract custom properties assigned to a VSE strip"""
+
+    strip.atc_name = ""
+    strip.atc_description = ""
+    strip.atc_object_id = ""
+    strip.atc_is_synced = False
+
+
+class ToolsPanel(Panel):
+    bl_label = 'Attract'
+    bl_space_type = 'SEQUENCE_EDITOR'
+    bl_region_type = 'UI'
+
+    def draw_header(self, context):
+        strip = active_strip(context)
+        if strip and strip.atc_object_id:
+            self.layout.prop(strip, 'atc_is_synced', text='')
+
+    def draw(self, context):
+        strip = active_strip(context)
+        layout = self.layout
+        strip_types = {'MOVIE', 'IMAGE'}
+        if strip and strip.atc_object_id and strip.type in strip_types:
+            layout.prop(strip, 'atc_name', text='Name')
+            layout.prop(strip, 'atc_status', text='Status')
+
+            # Create a special sub-layout for read-only properties.
+            ro_sub = layout.column(align=True)
+            ro_sub.enabled = False
+            ro_sub.prop(strip, 'atc_description', text='Description')
+            ro_sub.prop(strip, 'atc_notes', text='Notes')
+
+            if strip.atc_is_synced:
+                row = layout.row(align=True)
+                row.operator('attract.shot_submit_update')
+                row.operator(AttractShotFetchUpdate.bl_idname,
+                             text='', icon='FILE_REFRESH')
+
+                # Group more dangerous operations.
+                dangerous_sub = layout.column(align=True)
+                dangerous_sub.operator('attract.shot_delete')
+                dangerous_sub.operator('attract.strip_unlink')
+
+        elif strip and strip.type in strip_types:
+            layout.operator('attract.shot_submit_new')
+            layout.operator('attract.shot_relink')
+        else:
+            layout.label(text='Select a Movie or Image strip')
+
+        layout.operator(AttractShotSubmitSelected.bl_idname)
+
+
+class AttractOperatorMixin:
+    """Mix-in class for all Attract operators."""
+
+    def _project_needs_setup_error(self):
+        self.report({'ERROR'}, 'Your Blender Cloud project is not set up for Attract.')
+        return {'CANCELLED'}
+
+    @functools.lru_cache()
+    def find_project(self, project_uuid: str) -> Project:
+        """Finds a single project.
+
+        Caches the result in memory to prevent more than one call to Pillar.
+        """
+
+        from .. import pillar
+
+        project = pillar.sync_call(Project.find_one, {'where': {'_id': project_uuid}})
+        return project
+
+    def find_node_type(self, node_type_name: str) -> dict:
+        from .. import pillar, blender
+
+        prefs = blender.preferences()
+        project = self.find_project(prefs.attract_project.project)
+
+        # FIXME: Eve doesn't seem to handle the $elemMatch projection properly,
+        # even though it works fine in MongoDB itself. As a result, we have to
+        # search for the node type.
+        node_type_list = project['node_types']
+        node_type = next((nt for nt in node_type_list if nt['name'] == node_type_name), None)
+
+        if not node_type:
+            return self._project_needs_setup_error()
+
+        return node_type
+
+    def submit_new_strip(self, strip):
+        from .. import pillar, blender
+
+        # Define the shot properties
+        user_uuid = pillar.pillar_user_uuid()
+        if not user_uuid:
+            self.report({'ERROR'}, 'Your Blender Cloud user ID is not known, '
+                                   'update your credentials.')
+            return {'CANCELLED'}
+
+        prop = {'name': strip.name,
+                'description': '',
+                'properties': {'status': 'todo',
+                               'notes': '',
+                               'trim_start_in_frames': strip.frame_offset_start,
+                               'duration_in_edit_in_frames': strip.frame_final_duration,
+                               'cut_in_timeline_in_frames': strip.frame_final_start},
+                'order': 0,
+                'node_type': 'attract_shot',
+                'project': blender.preferences().attract_project.project,
+                'user': user_uuid}
+
+        # Create a Node item with the attract API
+        node = Node(prop)
+        post = pillar.sync_call(node.create)
+
+        # Populate the strip with the freshly generated ObjectID and info
+        if not post:
+            self.report({'ERROR'}, 'Error creating node! Check the console for now.')
+            return {'CANCELLED'}
+
+        strip.atc_object_id = node['_id']
+        strip.atc_is_synced = True
+        strip.atc_name = node['name']
+        strip.atc_description = node['description']
+        strip.atc_notes = node['properties']['notes']
+        strip.atc_status = node['properties']['status']
+
+        draw.tag_redraw_all_sequencer_editors()
+
+    def submit_update(self, strip):
+        import pillarsdk
+        from .. import pillar
+
+        patch = {
+            'op': 'from-blender',
+            '$set': {
+                'name': strip.atc_name,
+                'properties.trim_start_in_frames': strip.frame_offset_start,
+                'properties.duration_in_edit_in_frames': strip.frame_final_duration,
+                'properties.cut_in_timeline_in_frames': strip.frame_final_start,
+                'properties.status': strip.atc_status,
+            }
+        }
+
+        node = pillarsdk.Node({'_id': strip.atc_object_id})
+        result = pillar.sync_call(node.patch, patch)
+        log.info('PATCH result: %s', result)
+
+    def relink(self, strip, atc_object_id):
+        from .. import pillar
+
+        try:
+            node = pillar.sync_call(Node.find, atc_object_id)
+        except (sdk_exceptions.ResourceNotFound, sdk_exceptions.MethodNotAllowed):
+            self.report({'ERROR'}, 'Shot %r not found on the Attract server, unable to relink.'
+                        % atc_object_id)
+            return {'CANCELLED'}
+
+        strip.atc_is_synced = True
+        strip.atc_name = node.name
+        strip.atc_object_id = node['_id']
+
+        # We do NOT set the position/cuts of the shot, that always has to come from Blender.
+        strip.atc_status = node.properties.status
+        strip.atc_notes = node.properties.notes or ''
+        strip.atc_description = node.description or ''
+
+        draw.tag_redraw_all_sequencer_editors()
+
+
+class AttractShotSubmitNew(AttractOperatorMixin, Operator):
+    bl_idname = "attract.shot_submit_new"
+    bl_label = "Submit to Attract"
+
+    @classmethod
+    def poll(cls, context):
+        strip = active_strip(context)
+        return not strip.atc_object_id
+
+    def execute(self, context):
+        strip = active_strip(context)
+        if strip.atc_object_id:
+            return
+
+        node_type = self.find_node_type('attract_shot')
+        if isinstance(node_type, set):  # in case of error
+            return node_type
+
+        return self.submit_new_strip(strip) or {'FINISHED'}
+
+
+class AttractShotFetchUpdate(AttractOperatorMixin, Operator):
+    bl_idname = "attract.shot_fetch_update"
+    bl_label = "Fetch update from Attract"
+
+    @classmethod
+    def poll(cls, context):
+        strip = active_strip(context)
+        return strip is not None and getattr(strip, 'atc_object_id', None)
+
+    def execute(self, context):
+        strip = active_strip(context)
+
+        status = self.relink(strip, strip.atc_object_id)
+        if isinstance(status, set):
+            return status
+
+        self.report({'INFO'}, "Shot {0} refreshed".format(strip.atc_name))
+        return {'FINISHED'}
+
+
+class AttractShotRelink(AttractShotFetchUpdate):
+    bl_idname = "attract.shot_relink"
+    bl_label = "Relink with Attract"
+
+    strip_atc_object_id = bpy.props.StringProperty()
+
+    @classmethod
+    def poll(cls, context):
+        strip = active_strip(context)
+        return strip is not None and not getattr(strip, 'atc_object_id', None)
+
+    def execute(self, context):
+        strip = active_strip(context)
+
+        status = self.relink(strip, self.strip_atc_object_id)
+        if isinstance(status, set):
+            return status
+
+        strip.atc_object_id = self.strip_atc_object_id
+        self.report({'INFO'}, "Shot {0} relinked".format(strip.atc_name))
+
+        return {'FINISHED'}
+
+    def invoke(self, context, event):
+        return context.window_manager.invoke_props_dialog(self)
+
+    def draw(self, context):
+        layout = self.layout
+        col = layout.column()
+        col.prop(self, 'strip_atc_object_id', text='Shot ID')
+
+
+class AttractShotSubmitUpdate(AttractOperatorMixin, Operator):
+    bl_idname = 'attract.shot_submit_update'
+    bl_label = 'Submit update'
+    bl_description = 'Sends local changes to Attract'
+
+    def execute(self, context):
+        strip = active_strip(context)
+        self.submit_update(strip)
+
+        self.report({'INFO'}, 'Shot was updated on Attract')
+        return {'FINISHED'}
+
+
+class AttractShotDelete(AttractOperatorMixin, Operator):
+    bl_idname = 'attract.shot_delete'
+    bl_label = 'Delete'
+    bl_description = 'Remove from Attract'
+
+    confirm = bpy.props.BoolProperty(name='confirm')
+
+    def execute(self, context):
+        from .. import pillar
+
+        if not self.confirm:
+            self.report({'WARNING'}, 'Delete aborted.')
+            return {'CANCELLED'}
+
+        strip = active_strip(context)
+        node = pillar.sync_call(Node.find, strip.atc_object_id)
+        if not pillar.sync_call(node.delete):
+            print('Unable to delete the strip node on Attract.')
+            return {'CANCELLED'}
+
+        remove_atc_props(strip)
+        draw.tag_redraw_all_sequencer_editors()
+        return {'FINISHED'}
+
+    def invoke(self, context, event):
+        return context.window_manager.invoke_props_dialog(self)
+
+    def draw(self, context):
+        layout = self.layout
+        col = layout.column()
+        col.prop(self, 'confirm', text="I hereby confirm I want to delete this shot.")
+
+
+class AttractStripUnlink(AttractOperatorMixin, Operator):
+    bl_idname = 'attract.strip_unlink'
+    bl_label = 'Unlink'
+    bl_description = 'Remove Attract props from the selected strip(s)'
+
+    def execute(self, context):
+        for strip in context.selected_sequences:
+            atc_object_id = getattr(strip, 'atc_object_id')
+            remove_atc_props(strip)
+
+            if atc_object_id:
+                self.report({'INFO'}, 'Shot %s has been unlinked from Attract.' % atc_object_id)
+
+        draw.tag_redraw_all_sequencer_editors()
+        return {'FINISHED'}
+
+
+class AttractShotSubmitSelected(AttractOperatorMixin, Operator):
+    bl_idname = 'attract.submit_selected'
+    bl_label = 'Submit all selected'
+    bl_description = 'Submits all selected strips to Attract'
+
+    @classmethod
+    def poll(cls, context):
+        return bool(context.selected_sequences)
+
+    def execute(self, context):
+        # Check that the project is set up for Attract.
+        node_type = self.find_node_type('attract_shot')
+        if isinstance(node_type, set):
+            return node_type
+
+        for strip in context.selected_sequences:
+            status = self.submit(strip)
+            if isinstance(status, set):
+                return status
+
+        self.report({'INFO'}, 'All selected strips sent to Attract.')
+
+        return {'FINISHED'}
+
+    def submit(self, strip):
+        atc_object_id = getattr(strip, 'atc_object_id', None)
+
+        # Submit as new?
+        if not atc_object_id:
+            return self.submit_new_strip(strip)
+
+        # Or just save to Attract.
+        return self.submit_update(strip)
+
+
+def register():
+    bpy.types.Sequence.atc_is_synced = bpy.props.BoolProperty(name="Is synced")
+    bpy.types.Sequence.atc_object_id = bpy.props.StringProperty(name="Attract Object ID")
+    bpy.types.Sequence.atc_name = bpy.props.StringProperty(name="Shot Name")
+    bpy.types.Sequence.atc_description = bpy.props.StringProperty(name="Shot description")
+    bpy.types.Sequence.atc_notes = bpy.props.StringProperty(name="Shot notes")
+
+    # TODO: get this from the project's node type definition.
+    bpy.types.Sequence.atc_status = bpy.props.EnumProperty(
+        items=[
+            ('on_hold', 'On hold', 'The shot is on hold'),
+            ('todo', 'Todo', 'Waiting'),
+            ('in_progress', 'In progress', 'The show has been assigned'),
+            ('review', 'Review', ''),
+            ('final', 'Final', ''),
+        ],
+        name="Status")
+    bpy.types.Sequence.atc_order = bpy.props.IntProperty(name="Order")
+
+    bpy.utils.register_class(ToolsPanel)
+    bpy.utils.register_class(AttractShotSubmitNew)
+    bpy.utils.register_class(AttractShotRelink)
+    bpy.utils.register_class(AttractShotSubmitUpdate)
+    bpy.utils.register_class(AttractShotDelete)
+    bpy.utils.register_class(AttractStripUnlink)
+    bpy.utils.register_class(AttractShotFetchUpdate)
+    bpy.utils.register_class(AttractShotSubmitSelected)
+    draw.callback_enable()
+
+
+def unregister():
+    draw.callback_disable()
+    del bpy.types.Sequence.atc_is_synced
+    del bpy.types.Sequence.atc_object_id
+    del bpy.types.Sequence.atc_name
+    del bpy.types.Sequence.atc_description
+    del bpy.types.Sequence.atc_notes
+    del bpy.types.Sequence.atc_status
+    del bpy.types.Sequence.atc_order
+    bpy.utils.unregister_module(__name__)

blender_cloud/attract/draw.py

@@ -0,0 +1,148 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+# <pep8-80 compliant>
+
+import bpy
+import logging
+import collections
+
+log = logging.getLogger(__name__)
+
+strip_status_colour = {
+    None: (0.7, 0.7, 0.7),
+    'approved': (0.6392156862745098, 0.8784313725490196, 0.30196078431372547),
+    'final': (0.9058823529411765, 0.9607843137254902, 0.8274509803921568),
+    'in_progress': (1.0, 0.7450980392156863, 0.0),
+    'on_hold': (0.796078431372549, 0.6196078431372549, 0.08235294117647059),
+    'review': (0.8941176470588236, 0.9607843137254902, 0.9764705882352941),
+    'todo': (1.0, 0.5019607843137255, 0.5019607843137255)
+}
+
+
+def get_strip_rectf(strip, pixel_size_y):
+    # Get x and y in terms of the grid's frames and channels
+    x1 = strip.frame_final_start
+    x2 = strip.frame_final_end
+    y1 = strip.channel + 0.2 - pixel_size_y
+    y2 = y1 + 2 * pixel_size_y
+
+    return (x1, y1, x2, y2)
+
+
+def draw_underline_in_strip(strip_coords, pixel_size, color):
+    from bgl import glColor4f, glRectf, glEnable, glDisable, GL_BLEND
+
+    context = bpy.context
+
+    # Strip coords
+    s_x1, s_y1, s_x2, s_y2 = strip_coords
+
+    # be careful not to draw over the current frame line
+    cf_x = context.scene.frame_current_final
+
+    glColor4f(*color)
+    glEnable(GL_BLEND)
+
+    if s_x1 < cf_x < s_x2:
+        # Bad luck, the line passes our strip
+        glRectf(s_x1, s_y1, cf_x - pixel_size, s_y2)
+        glRectf(cf_x + pixel_size, s_y1, s_x2, s_y2)
+    else:
+        # Normal, full rectangle draw
+        glRectf(s_x1, s_y1, s_x2, s_y2)
+
+    glDisable(GL_BLEND)
+
+
+def draw_callback_px():
+    context = bpy.context
+
+    if not context.scene.sequence_editor:
+        return
+
+    region = context.region
+    xwin1, ywin1 = region.view2d.region_to_view(0, 0)
+    xwin2, ywin2 = region.view2d.region_to_view(region.width, region.height)
+    one_pixel_further_x, one_pixel_further_y = region.view2d.region_to_view(1, 1)
+    pixel_size_x = one_pixel_further_x - xwin1
+    pixel_size_y = one_pixel_further_y - ywin1
+
+    if context.scene.sequence_editor.meta_stack:
+        strips = context.scene.sequence_editor.meta_stack[-1].sequences
+    else:
+        strips = context.scene.sequence_editor.sequences
+
+    for strip in strips:
+        if not strip.atc_object_id:
+            continue
+
+        # Get corners (x1, y1), (x2, y2) of the strip rectangle in px region coords
+        strip_coords = get_strip_rectf(strip, pixel_size_y)
+
+        # check if any of the coordinates are out of bounds
+        if strip_coords[0] > xwin2 or strip_coords[2] < xwin1 or strip_coords[1] > ywin2 or \
+                        strip_coords[3] < ywin1:
+            continue
+
+        # Draw
+        status = strip.atc_status
+        if status in strip_status_colour:
+            color = strip_status_colour[status]
+        else:
+            color = strip_status_colour[None]
+
+        alpha = 1.0 if strip.atc_is_synced else 0.5
+
+        draw_underline_in_strip(strip_coords, pixel_size_x, color + (alpha, ))
+
+
+def tag_redraw_all_sequencer_editors():
+    context = bpy.context
+
+    # Py cant access notifiers
+    for window in context.window_manager.windows:
+        for area in window.screen.areas:
+            if area.type == 'SEQUENCE_EDITOR':
+                for region in area.regions:
+                    if region.type == 'WINDOW':
+                        region.tag_redraw()
+
+
+# This is a list so it can be changed instead of set
+# if it is only changed, it does not have to be declared as a global everywhere
+cb_handle = []
+
+
+def callback_enable():
+    if cb_handle:
+        return
+
+    cb_handle[:] = bpy.types.SpaceSequenceEditor.draw_handler_add(
+        draw_callback_px, (), 'WINDOW', 'POST_VIEW'),
+
+    tag_redraw_all_sequencer_editors()
+
+
+def callback_disable():
+    if not cb_handle:
+        return
+
+    bpy.types.SpaceSequenceEditor.draw_handler_remove(cb_handle[0], 'WINDOW')
+
+    tag_redraw_all_sequencer_editors()

blender_cloud/blender.py

@@ -1,3 +1,21 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
 """Blender-specific code.
 
 Separated from __init__.py so that we can import & run from non-Blender environments.
@@ -9,11 +27,12 @@ import os.path
 import bpy
 from bpy.types import AddonPreferences, Operator, WindowManager, Scene, PropertyGroup
 from bpy.props import StringProperty, EnumProperty, PointerProperty, BoolProperty
+import rna_prop_ui
 
-from . import pillar
+from . import pillar, async_loop
 
-PILLAR_SERVER_URL = 'https://cloudapi.blender.org/'
-# PILLAR_SERVER_URL = 'http://localhost:5000/'
+PILLAR_SERVER_URL = 'https://cloud.blender.org/api/'
+# PILLAR_SERVER_URL = 'http://pillar:5001/api/'
 
 ADDON_NAME = 'blender_cloud'
 log = logging.getLogger(__name__)
@@ -26,6 +45,8 @@ def redraw(self, context):
 
 
 def blender_syncable_versions(self, context):
+    """Returns the list of items used by SyncStatusProperties.version EnumProperty."""
+
     bss = context.window_manager.blender_sync_status
     versions = bss.available_blender_versions
     if not versions:
@@ -85,6 +106,42 @@ class SyncStatusProperties(PropertyGroup):
         self['available_blender_versions'] = new_versions
 
 
+def bcloud_available_projects(self, context):
+    """Returns the list of items used by BlenderCloudProjectGroup.project EnumProperty."""
+
+    attr_proj = preferences().attract_project
+    projs = attr_proj.available_projects
+    if not projs:
+        return [('', 'No projects available in your Blender Cloud', '')]
+    return [(p['_id'], p['name'], '') for p in projs]
+
+
+class BlenderCloudProjectGroup(PropertyGroup):
+    status = EnumProperty(
+        items=[
+            ('NONE', 'NONE', 'We have done nothing at all yet'),
+            ('IDLE', 'IDLE', 'User requested something, which is done, and we are now idle'),
+            ('FETCHING', 'FETCHING', 'Fetching available projects from Blender Cloud'),
+        ],
+        name='status',
+        update=redraw)
+
+    project = EnumProperty(
+        items=bcloud_available_projects,
+        name='Cloud project',
+        description='Which Blender Cloud project to work with')
+
+    # List of projects is stored in 'available_projects' ID property,
+    # because I don't know how to store a variable list of strings in a proper RNA property.
+    @property
+    def available_projects(self) -> list:
+        return self.get('available_projects', [])
+
+    @available_projects.setter
+    def available_projects(self, new_projects):
+        self['available_projects'] = new_projects
+
+
 class BlenderCloudPreferences(AddonPreferences):
     bl_idname = ADDON_NAME
 
@@ -108,6 +165,8 @@ class BlenderCloudPreferences(AddonPreferences):
         default=True
     )
 
+    attract_project = PointerProperty(type=BlenderCloudProjectGroup)
+
     def draw(self, context):
         import textwrap
 
@@ -186,9 +245,16 @@ class BlenderCloudPreferences(AddonPreferences):
         # Image Share stuff
         share_box = layout.box()
         share_box.label('Image Sharing on Blender Cloud', icon_value=icon('CLOUD'))
-        texture_box.enabled = msg_icon != 'ERROR'
+        share_box.enabled = msg_icon != 'ERROR'
         share_box.prop(self, 'open_browser_after_share')
 
+        # Attract stuff
+        attract_box = layout.box()
+        attract_box.enabled = msg_icon != 'ERROR'
+        attract_row = attract_box.row(align=True)
+        attract_row.label('Attract', icon_value=icon('CLOUD'))
+        self.draw_attract_buttons(attract_row, self.attract_project)
+
     def draw_subscribe_button(self, layout):
         layout.operator('pillar.subscribe', icon='WORLD')
 
@@ -223,12 +289,32 @@ class BlenderCloudPreferences(AddonPreferences):
         else:
             row_pull.label('Cloud Sync is running.')
 
+    def draw_attract_buttons(self, layout, bcp: BlenderCloudProjectGroup):
+        layout.enabled = bcp.status in {'NONE', 'IDLE'}
+        row_buttons = layout.row(align=True)
+
+        projects = bcp.available_projects
+        project = bcp.project
+        if bcp.status in {'NONE', 'IDLE'}:
+            if not projects or not project:
+                row_buttons.operator('pillar.projects',
+                                     text='Find project to load',
+                                     icon='FILE_REFRESH')
+            else:
+                row_buttons.prop(bcp, 'project')
+                row_buttons.operator('pillar.projects',
+                                     text='',
+                                     icon='FILE_REFRESH')
+        else:
+            row_buttons.label('Fetching available projects.')
+
 
 class PillarCredentialsUpdate(pillar.PillarOperatorMixin,
                               Operator):
     """Updates the Pillar URL and tests the new URL."""
     bl_idname = 'pillar.credentials_update'
     bl_label = 'Update credentials'
+    bl_description = 'Resynchronises your Blender ID login with Blender Cloud'
 
     log = logging.getLogger('bpy.ops.%s' % bl_idname)
 
@@ -285,6 +371,78 @@ class PILLAR_OT_subscribe(Operator):
         return {'FINISHED'}
 
 
+class PILLAR_OT_projects(async_loop.AsyncModalOperatorMixin,
+                         pillar.PillarOperatorMixin,
+                         Operator):
+    """Fetches the projects available to the user, and ."""
+    bl_idname = 'pillar.projects'
+    bl_label = 'Fetch available projects'
+
+    stop_upon_exception = True
+    _log = logging.getLogger('bpy.ops.%s' % bl_idname)
+
+    async def async_execute(self, context):
+        import pillarsdk
+        from .pillar import pillar_call
+
+        self._log.info('Checking credentials')
+        try:
+            db_user = await self.check_credentials(context, ())
+        except pillar.UserNotLoggedInError as ex:
+            self._log.info('Not logged in error raised: %s', ex)
+            self.report({'ERROR'}, 'Please log in on Blender ID first.')
+            self.quit()
+            return
+
+        user_id = db_user['_id']
+        self.log.info('Going to fetch projects for user %s', user_id)
+
+        preferences().attract_project.status = 'FETCHING'
+
+        # Get all projects, except the home project.
+        projects_user = await pillar_call(
+            pillarsdk.Project.all,
+            {'where': {'user': user_id,
+                       'category': {'$ne': 'home'}},
+             'sort': '-_created',
+             'projection': {'_id': True,
+                            'name': True},
+             })
+
+        projects_shared = await pillar_call(
+            pillarsdk.Project.all,
+            {'where': {'user': {'$ne': user_id},
+                       'permissions.groups.group': {'$in': db_user.groups}},
+             'sort': '-_created',
+             'projection': {'_id': True,
+                            'name': True},
+             })
+
+        # We need to convert to regular dicts before storing in ID properties.
+        # Also don't store more properties than we need.
+        projects = [{'_id': p['_id'], 'name': p['name']} for p in projects_user['_items']] + \
+                   [{'_id': p['_id'], 'name': p['name']} for p in projects_shared['_items']]
+
+        preferences().attract_project.available_projects = projects
+
+        self.quit()
+
+    def quit(self):
+        preferences().attract_project.status = 'IDLE'
+        super().quit()
+
+
+class PILLAR_PT_image_custom_properties(rna_prop_ui.PropertyPanel, bpy.types.Panel):
+    """Shows custom properties in the image editor."""
+
+    bl_space_type = 'IMAGE_EDITOR'
+    bl_region_type = 'UI'
+    bl_label = 'Custom Properties'
+
+    _context_path = 'edit_image'
+    _property_type = bpy.types.Image
+
+
 def preferences() -> BlenderCloudPreferences:
     return bpy.context.user_preferences.addons[ADDON_NAME].preferences
 
@@ -323,10 +481,13 @@ def icon(icon_name: str) -> int:
 
 
 def register():
+    bpy.utils.register_class(BlenderCloudProjectGroup)
     bpy.utils.register_class(BlenderCloudPreferences)
     bpy.utils.register_class(PillarCredentialsUpdate)
     bpy.utils.register_class(SyncStatusProperties)
     bpy.utils.register_class(PILLAR_OT_subscribe)
+    bpy.utils.register_class(PILLAR_OT_projects)
+    bpy.utils.register_class(PILLAR_PT_image_custom_properties)
 
     addon_prefs = preferences()
 
@@ -354,10 +515,13 @@ def register():
 def unregister():
     unload_custom_icons()
 
+    bpy.utils.unregister_class(BlenderCloudProjectGroup)
     bpy.utils.unregister_class(PillarCredentialsUpdate)
     bpy.utils.unregister_class(BlenderCloudPreferences)
     bpy.utils.unregister_class(SyncStatusProperties)
     bpy.utils.unregister_class(PILLAR_OT_subscribe)
+    bpy.utils.unregister_class(PILLAR_OT_projects)
+    bpy.utils.unregister_class(PILLAR_PT_image_custom_properties)
 
     del WindowManager.last_blender_cloud_location
     del WindowManager.blender_sync_status

blender_cloud/cache.py

@@ -1,3 +1,21 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
 """HTTP Cache management.
 
 This module configures a cached session for the Requests package.

blender_cloud/home_project.py

@@ -1,3 +1,21 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
 import logging
 
 import pillarsdk

blender_cloud/image_sharing.py

@@ -1,3 +1,21 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
 import logging
 import os.path
 import tempfile
@@ -89,14 +107,7 @@ class PILLAR_OT_image_share(pillar.PillarOperatorMixin,
                 self.report({'ERROR'}, 'Datablock is dirty, save it first.')
                 return {'CANCELLED'}
 
-        async_loop.AsyncModalOperatorMixin.invoke(self, context, event)
-
-        self.log.info('Starting sharing')
-        self._new_async_task(self.async_execute(context))
-        return {'RUNNING_MODAL'}
-
-    def execute(self, context):
-        return self.invoke(context, None)
+        return async_loop.AsyncModalOperatorMixin.invoke(self, context, event)
 
     async def async_execute(self, context):
         """Entry point of the asynchronous operator."""
@@ -106,15 +117,15 @@ class PILLAR_OT_image_share(pillar.PillarOperatorMixin,
         try:
             # Refresh credentials
             try:
-                self.user_id = await self.check_credentials(context,
-                                                            REQUIRES_ROLES_FOR_IMAGE_SHARING)
+                db_user = await self.check_credentials(context, REQUIRES_ROLES_FOR_IMAGE_SHARING)
+                self.user_id = db_user['_id']
                 self.log.debug('Found user ID: %s', self.user_id)
             except pillar.NotSubscribedToCloudError:
                 self.log.exception('User not subscribed to cloud.')
                 self.report({'ERROR'}, 'Please subscribe to the Blender Cloud.')
                 self._state = 'QUIT'
                 return
-            except pillar.CredentialsNotSyncedError:
+            except pillar.UserNotLoggedInError:
                 self.log.exception('Error checking/refreshing credentials.')
                 self.report({'ERROR'}, 'Please log in on Blender ID first.')
                 self._state = 'QUIT'
@@ -272,7 +283,7 @@ class PILLAR_OT_image_share(pillar.PillarOperatorMixin,
     async def upload_screenshot(self, context) -> pillarsdk.Node:
         """Takes a screenshot, saves it to a temp file, and uploads it."""
 
-        self.name = datetime.datetime.now().strftime('Screenshot-%Y-%m-%d-%H:%M:%S.png')
+        self.name = datetime.datetime.now().strftime('Screenshot-%Y-%m-%d-%H%M%S.png')
         self.report({'INFO'}, "Uploading %s '%s'" % (self.target.lower(), self.name))
 
         with tempfile.TemporaryDirectory() as tmpdir:

blender_cloud/pillar.py

@@ -1,4 +1,23 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
 import asyncio
+import datetime
 import json
 import os
 import functools
@@ -17,6 +36,9 @@ from pillarsdk.utils import sanitize_filename
 from . import cache
 
 SUBCLIENT_ID = 'PILLAR'
+TEXTURE_NODE_TYPES = {'texture', 'hdri'}
+
+RFC1123_DATE_FORMAT = '%a, %d %b %Y %H:%M:%S GMT'
 
 _pillar_api = {}  # will become a mapping from bool (cached/non-cached) to pillarsdk.Api objects.
 log = logging.getLogger(__name__)
@@ -124,6 +146,13 @@ def blender_id_subclient() -> dict:
     return subclient
 
 
+def pillar_user_uuid() -> str:
+    """Returns the UUID of the Pillar user."""
+
+    import blender_id
+    return blender_id.get_subclient_user_id(SUBCLIENT_ID)
+
+
 def pillar_api(pillar_endpoint: str = None, caching=True) -> pillarsdk.Api:
     """Returns the Pillar SDK API object for the current user.
 
@@ -157,6 +186,12 @@ def pillar_api(pillar_endpoint: str = None, caching=True) -> pillarsdk.Api:
                                         token=subclient['token'])
         _noncaching_api.requests_session = uncached_session
 
+        # Send the addon version as HTTP header.
+        from blender_cloud import bl_info
+        addon_version = '.'.join(str(v) for v in bl_info['version'])
+        _caching_api.global_headers['Blender-Cloud-Addon'] = addon_version
+        _noncaching_api.global_headers['Blender-Cloud-Addon'] = addon_version
+
         _pillar_api = {
             True: _caching_api,
             False: _noncaching_api,
@@ -170,6 +205,12 @@ pillar_semaphore = asyncio.Semaphore(3)
 
 
 async def pillar_call(pillar_func, *args, caching=True, **kwargs):
+    """Calls a Pillar function.
+
+    A semaphore is used to ensure that there won't be too many
+    calls to Pillar simultaneously.
+    """
+
     partial = functools.partial(pillar_func, *args, api=pillar_api(caching=caching), **kwargs)
     loop = asyncio.get_event_loop()
 
@@ -177,6 +218,12 @@ async def pillar_call(pillar_func, *args, caching=True, **kwargs):
         return await loop.run_in_executor(None, partial)
 
 
+def sync_call(pillar_func, *args, **kwargs):
+    """Synchronous call to Pillar, ensures the correct Api object is used."""
+
+    return pillar_func(*args, api=pillar_api(), **kwargs)
+
+
 async def check_pillar_credentials(required_roles: set):
     """Tries to obtain the user at Pillar using the user's credentials.
 
@@ -213,7 +260,7 @@ async def check_pillar_credentials(required_roles: set):
         profile.save_json()
         raise NotSubscribedToCloudError()
 
-    return pillar_user_id
+    return db_user
 
 
 async def refresh_pillar_credentials(required_roles: set):
@@ -228,7 +275,7 @@ async def refresh_pillar_credentials(required_roles: set):
     import blender_id
 
     from . import blender
-    pillar_endpoint = blender.preferences().pillar_server.rstrip('/')
+    pillar_endpoint = blender.preferences().pillar_server
 
     # Create a subclient token and send it to Pillar.
     # May raise a blender_id.BlenderIdCommError
@@ -288,7 +335,8 @@ async def get_nodes(project_uuid: str = None, parent_node_uuid: str = None,
         if isinstance(node_type, str):
             where['node_type'] = node_type
         else:
-            where['node_type'] = {'$in': node_type}
+            # Convert set & tuple to list
+            where['node_type'] = {'$in': list(node_type)}
 
     params = {'projection': {'name': 1, 'parent': 1, 'node_type': 1, 'properties.order': 1,
                              'properties.status': 1, 'properties.files': 1,
@@ -472,7 +520,7 @@ async def fetch_texture_thumbs(parent_node_uuid: str, desired_size: str,
     # Download all texture nodes in parallel.
     log.debug('Getting child nodes of node %r', parent_node_uuid)
     texture_nodes = await get_nodes(parent_node_uuid=parent_node_uuid,
-                                    node_type='texture')
+                                    node_type=TEXTURE_NODE_TYPES)
 
     if is_cancelled(future):
         log.warning('fetch_texture_thumbs: Texture downloading cancelled')
@@ -498,7 +546,7 @@ async def download_texture_thumbnail(texture_node, desired_size: str,
                                      thumbnail_loaded: callable,
                                      future: asyncio.Future = None):
     # Skip non-texture nodes, as we can't thumbnail them anyway.
-    if texture_node['node_type'] != 'texture':
+    if texture_node['node_type'] not in TEXTURE_NODE_TYPES:
         return
 
     if is_cancelled(future):
@@ -526,7 +574,8 @@ async def download_texture_thumbnail(texture_node, desired_size: str,
     # Load the File that belongs to this texture node's picture.
     loop.call_soon_threadsafe(thumbnail_loading, texture_node, texture_node)
     file_desc = await pillar_call(pillarsdk.File.find, pic_uuid, params={
-        'projection': {'filename': 1, 'variations': 1, 'width': 1, 'height': 1},
+        'projection': {'filename': 1, 'variations': 1, 'width': 1, 'height': 1,
+                       'length': 1},
     })
 
     if file_desc is None:
@@ -555,15 +604,80 @@ async def download_texture_thumbnail(texture_node, desired_size: str,
     loop.call_soon_threadsafe(thumbnail_loaded, texture_node, file_desc, thumb_path)
 
 
+async def fetch_node_files(node: pillarsdk.Node,
+                           *,
+                           file_doc_loading: callable,
+                           file_doc_loaded: callable,
+                           future: asyncio.Future = None):
+    """Fetches all files of a texture/hdri node.
+
+    @param node: Node document to fetch all file docs for.
+    @param file_doc_loading: callback function that takes (file_id, ) parameters,
+        which is called before a file document will be downloaded. This allows you to
+        show a "downloading" indicator.
+    @param file_doc_loaded: callback function that takes (file_id, pillarsdk.File object)
+        parameters, which is called for every thumbnail after it's been downloaded.
+    @param future: Future that's inspected; if it is not None and cancelled, texture downloading
+        is aborted.
+    """
+
+    # Download all thumbnails in parallel.
+    if is_cancelled(future):
+        log.warning('fetch_texture_thumbs: Texture downloading cancelled')
+        return
+
+    coros = (download_file_doc(file_ref.file,
+                               file_doc_loading=file_doc_loading,
+                               file_doc_loaded=file_doc_loaded,
+                               future=future)
+             for file_ref in node.properties.files)
+
+    # raises any exception from failed handle_texture_node() calls.
+    await asyncio.gather(*coros)
+
+    log.info('fetch_node_files: Done downloading %i files', len(node.properties.files))
+
+
+async def download_file_doc(file_id,
+                            *,
+                            file_doc_loading: callable,
+                            file_doc_loaded: callable,
+                            future: asyncio.Future = None):
+
+    if is_cancelled(future):
+        log.debug('fetch_texture_thumbs cancelled before finding File for file_id %s', file_id)
+        return
+
+    loop = asyncio.get_event_loop()
+
+    # Load the File that belongs to this texture node's picture.
+    loop.call_soon_threadsafe(file_doc_loading, file_id)
+    file_desc = await pillar_call(pillarsdk.File.find, file_id, params={
+        'projection': {'filename': 1, 'variations': 1, 'width': 1, 'height': 1,
+                       'length': 1},
+    })
+
+    if file_desc is None:
+        log.warning('Unable to find File for file_id %s', file_id)
+
+    loop.call_soon_threadsafe(file_doc_loaded, file_id, file_desc)
+
+
 async def download_file_by_uuid(file_uuid,
                                 target_directory: str,
                                 metadata_directory: str,
                                 *,
+                                filename: str = None,
                                 map_type: str = None,
                                 file_loading: callable = None,
                                 file_loaded: callable = None,
                                 file_loaded_sync: callable = None,
                                 future: asyncio.Future):
+    """Downloads a file from Pillar by its UUID.
+
+    :param filename: overrules the filename in file_doc['filename'] if given.
+        The extension from file_doc['filename'] is still used, though.
+    """
     if is_cancelled(future):
         log.debug('download_file_by_uuid(%r) cancelled.', file_uuid)
         return
@@ -572,15 +686,18 @@ async def download_file_by_uuid(file_uuid,
 
     # Find the File document.
     file_desc = await pillar_call(pillarsdk.File.find, file_uuid, params={
-        'projection': {'link': 1, 'filename': 1},
+        'projection': {'link': 1, 'filename': 1, 'length': 1},
     })
 
     # Save the file document to disk
     metadata_file = os.path.join(metadata_directory, 'files', '%s.json' % file_uuid)
     save_as_json(file_desc, metadata_file)
 
+    # Let the caller override the filename root.
     root, ext = os.path.splitext(file_desc['filename'])
-    if map_type is None or root.endswith(map_type):
+    if filename:
+        root, _ = os.path.splitext(filename)
+    if not map_type or root.endswith(map_type):
         target_filename = '%s%s' % (root, ext)
     else:
         target_filename = '%s-%s%s' % (root, map_type, ext)
@@ -589,7 +706,7 @@ async def download_file_by_uuid(file_uuid,
     file_url = file_desc['link']
     # log.debug('Texture %r:\n%s', file_uuid, pprint.pformat(file_desc.to_dict()))
     if file_loading is not None:
-        loop.call_soon_threadsafe(file_loading, file_path, file_desc)
+        loop.call_soon_threadsafe(file_loading, file_path, file_desc, map_type)
 
     # Cached headers are stored in the project space
     header_store = os.path.join(metadata_directory, 'files',
@@ -598,9 +715,9 @@ async def download_file_by_uuid(file_uuid,
     await download_to_file(file_url, file_path, header_store=header_store, future=future)
 
     if file_loaded is not None:
-        loop.call_soon_threadsafe(file_loaded, file_path, file_desc)
+        loop.call_soon_threadsafe(file_loaded, file_path, file_desc, map_type)
     if file_loaded_sync is not None:
-        await file_loaded_sync(file_path, file_desc)
+        await file_loaded_sync(file_path, file_desc, map_type)
 
 
 async def download_texture(texture_node,
@@ -610,18 +727,25 @@ async def download_texture(texture_node,
                            texture_loading: callable,
                            texture_loaded: callable,
                            future: asyncio.Future):
-    if texture_node['node_type'] != 'texture':
-        raise TypeError("Node type should be 'texture', not %r" % texture_node['node_type'])
+    node_type_name = texture_node['node_type']
+    if node_type_name not in TEXTURE_NODE_TYPES:
+        raise TypeError("Node type should be in %r, not %r" %
+                        (TEXTURE_NODE_TYPES, node_type_name))
+
+    filename = '%s.taken_from_file' % sanitize_filename(texture_node['name'])
 
     # Download every file. Eve doesn't support embedding from a list-of-dicts.
-    downloaders = (download_file_by_uuid(file_info['file'],
-                                         target_directory,
-                                         metadata_directory,
-                                         map_type=file_info['map_type'],
-                                         file_loading=texture_loading,
-                                         file_loaded=texture_loaded,
-                                         future=future)
-                   for file_info in texture_node['properties']['files'])
+    downloaders = []
+    for file_info in texture_node['properties']['files']:
+        dlr = download_file_by_uuid(file_info['file'],
+                                    target_directory,
+                                    metadata_directory,
+                                    filename=filename,
+                                    map_type=file_info.map_type or file_info.resolution,
+                                    file_loading=texture_loading,
+                                    file_loaded=texture_loaded,
+                                    future=future)
+        downloaders.append(dlr)
 
     return await asyncio.gather(*downloaders, return_exceptions=True)
 
@@ -675,15 +799,16 @@ def is_cancelled(future: asyncio.Future) -> bool:
 
 class PillarOperatorMixin:
     async def check_credentials(self, context, required_roles) -> bool:
-        """Checks credentials with Pillar, and if ok returns the user ID.
+        """Checks credentials with Pillar, and if ok returns the user document from Pillar/MongoDB.
 
-        Returns None if the user cannot be found, or if the user is not a Cloud subscriber.
+        :raises UserNotLoggedInError: if the user is not logged in
+        :raises NotSubscribedToCloudError: if the user does not have any of the required roles
         """
 
         # self.report({'INFO'}, 'Checking Blender Cloud credentials')
 
         try:
-            user_id = await check_pillar_credentials(required_roles)
+            db_user = await check_pillar_credentials(required_roles)
         except NotSubscribedToCloudError:
             self._log_subscription_needed()
             raise
@@ -691,20 +816,22 @@ class PillarOperatorMixin:
             self.log.info('Credentials not synced, re-syncing automatically.')
         else:
             self.log.info('Credentials okay.')
-            return user_id
+            return db_user
 
         try:
-            user_id = await refresh_pillar_credentials(required_roles)
+            db_user = await refresh_pillar_credentials(required_roles)
         except NotSubscribedToCloudError:
             self._log_subscription_needed()
             raise
+        except CredentialsNotSyncedError:
+            self.log.info('Credentials not synced after refreshing, handling as not logged in.')
+            raise UserNotLoggedInError('Not logged in.')
         except UserNotLoggedInError:
             self.log.error('User not logged in on Blender ID.')
+            raise
         else:
             self.log.info('Credentials refreshed and ok.')
-            return user_id
-
-        return None
+            return db_user
 
     def _log_subscription_needed(self):
         self.log.warning(
@@ -763,6 +890,25 @@ async def attach_file_to_group(file_path: pathlib.Path,
                              group_node_id,
                              'file',
                              str(file_path),
-                             extra_where=user_id and {'user': user_id})
+                             extra_where=user_id and {'user': user_id},
+                             caching=False)
 
     return node
+
+
+def node_to_id(node: pillarsdk.Node) -> dict:
+    """Converts a Node to a dict we can store in an ID property.
+
+    ID properties only support a handful of Python classes, so we have
+    to convert datetime.datetime to a string and remove None values.
+    """
+
+    def to_rna(value):
+        if isinstance(value, dict):
+            return {k: to_rna(v) for k, v in value.items()}
+        if isinstance(value, datetime.datetime):
+            return value.strftime(RFC1123_DATE_FORMAT)
+        return value
+
+    as_dict = to_rna(node.to_dict())
+    return pillarsdk.utils.remove_none_attributes(as_dict)

blender_cloud/settings_sync.py

@@ -1,3 +1,21 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
 """Synchronises settings & startup file with the Cloud.
 Caching is disabled on many PillarSDK calls, as synchronisation can happen
 rapidly between multiple machines. This means that information can be outdated
@@ -216,11 +234,7 @@ class PILLAR_OT_sync(pillar.PillarOperatorMixin,
             self.bss_report({'ERROR'}, 'No Blender version to sync for was given.')
             return {'CANCELLED'}
 
-        async_loop.AsyncModalOperatorMixin.invoke(self, context, event)
-
-        self.log.info('Starting synchronisation')
-        self._new_async_task(self.async_execute(context))
-        return {'RUNNING_MODAL'}
+        return async_loop.AsyncModalOperatorMixin.invoke(self, context, event)
 
     def action_select(self, context):
         """Allows selection of the Blender version to use.
@@ -267,14 +281,15 @@ class PILLAR_OT_sync(pillar.PillarOperatorMixin,
         try:
             # Refresh credentials
             try:
-                self.user_id = await self.check_credentials(context, REQUIRES_ROLES_FOR_SYNC)
+                db_user = await self.check_credentials(context, REQUIRES_ROLES_FOR_SYNC)
+                self.user_id = db_user['_id']
                 log.debug('Found user ID: %s', self.user_id)
             except pillar.NotSubscribedToCloudError:
                 self.log.exception('User not subscribed to cloud.')
                 self.bss_report({'SUBSCRIBE'}, 'Please subscribe to the Blender Cloud.')
                 self._state = 'QUIT'
                 return
-            except pillar.CredentialsNotSyncedError:
+            except pillar.UserNotLoggedInError:
                 self.log.exception('Error checking/refreshing credentials.')
                 self.bss_report({'ERROR'}, 'Please log in on Blender ID first.')
                 self._state = 'QUIT'
@@ -427,7 +442,7 @@ class PILLAR_OT_sync(pillar.PillarOperatorMixin,
             self.log.info('Unable to find node on Blender Cloud for %s', fname)
             return
 
-        async def file_downloaded(file_path: str, file_desc: pillarsdk.File):
+        async def file_downloaded(file_path: str, file_desc: pillarsdk.File, map_type: str):
             # Allow the caller to adjust the file before we move it into place.
 
             if fname.lower() == 'userpref.blend':

blender_cloud/texture_browser.py

@@ -1,23 +1,21 @@
 # ##### BEGIN GPL LICENSE BLOCK #####
 #
-#  Copyright (C) 2014 Blender Aid
-#  http://www.blendearaid.com
-#  blenderaid@gmail.com
-
-#  This program is free software: you can redistribute it and/or modify
-#  it under the terms of the GNU General Public License as published by
-#  the Free Software Foundation, either version 3 of the License, or
-#  (at your option) any later version.
-
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
 #  This program is distributed in the hope that it will be useful,
 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 #  GNU General Public License for more details.
-
+#
 #  You should have received a copy of the GNU General Public License
-#  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 #
 # ##### END GPL LICENSE BLOCK #####
+
 import asyncio
 import logging
 import threading
@@ -28,7 +26,7 @@ import bgl
 import blf
 
 import pillarsdk
-from . import async_loop, pillar, cache
+from . import async_loop, pillar, cache, blender, utils
 
 REQUIRED_ROLES_FOR_TEXTURE_BROWSER = {'subscriber', 'demo'}
 MOUSE_SCROLL_PIXELS_PER_TICK = 50
@@ -43,27 +41,32 @@ ITEM_PADDING_X = 5
 
 library_path = '/tmp'
 library_icons_path = os.path.join(os.path.dirname(__file__), "icons")
+log = logging.getLogger(__name__)
 
 
 class SpecialFolderNode(pillarsdk.Node):
-    pass
+    NODE_TYPE = 'SPECIAL'
 
 
 class UpNode(SpecialFolderNode):
+    NODE_TYPE = 'UP'
+
     def __init__(self):
         super().__init__()
         self['_id'] = 'UP'
-        self['node_type'] = 'UP'
+        self['node_type'] = self.NODE_TYPE
 
 
 class ProjectNode(SpecialFolderNode):
+    NODE_TYPE = 'PROJECT'
+
     def __init__(self, project):
         super().__init__()
 
         assert isinstance(project, pillarsdk.Project), 'wrong type for project: %r' % type(project)
 
         self.merge(project.to_dict())
-        self['node_type'] = 'PROJECT'
+        self['node_type'] = self.NODE_TYPE
 
 
 class MenuItem:
@@ -81,7 +84,8 @@ class MenuItem:
         'SPINNER': os.path.join(library_icons_path, 'spinner.png'),
     }
 
-    SUPPORTED_NODE_TYPES = {'UP', 'PROJECT', 'group_texture', 'texture'}
+    FOLDER_NODE_TYPES = {'group_texture', 'group_hdri', UpNode.NODE_TYPE, ProjectNode.NODE_TYPE}
+    SUPPORTED_NODE_TYPES = {'texture', 'hdri'}.union(FOLDER_NODE_TYPES)
 
     def __init__(self, node, file_desc, thumb_path: str, label_text):
         self.log = logging.getLogger('%s.MenuItem' % __name__)
@@ -97,8 +101,8 @@ class MenuItem:
         self.label_text = label_text
         self._thumb_path = ''
         self.icon = None
-        self._is_folder = (node['node_type'] == 'group_texture' or
-                           isinstance(node, SpecialFolderNode))
+        self._is_folder = node['node_type'] in self.FOLDER_NODE_TYPES
+        self._is_spinning = False
 
         # Determine sorting order.
         # by default, sort all the way at the end and folders first.
@@ -124,6 +128,8 @@ class MenuItem:
 
     @thumb_path.setter
     def thumb_path(self, new_thumb_path: str):
+        self._is_spinning = new_thumb_path == 'SPINNER'
+
         self._thumb_path = self.DEFAULT_ICONS.get(new_thumb_path, new_thumb_path)
         if self._thumb_path:
             self.icon = bpy.data.images.load(filepath=self._thumb_path)
@@ -134,7 +140,13 @@ class MenuItem:
     def node_uuid(self) -> str:
         return self.node['_id']
 
-    def update(self, node, file_desc, thumb_path: str, label_text):
+    def represents(self, node) -> bool:
+        """Returns True iff this MenuItem represents the given node."""
+
+        node_uuid = node['_id']
+        return self.node_uuid == node_uuid
+
+    def update(self, node, file_desc, thumb_path: str, label_text=None):
         # We can get updated information about our Node, but a MenuItem should
         # always represent one node, and it shouldn't be shared between nodes.
         if self.node_uuid != node['_id']:
@@ -143,12 +155,18 @@ class MenuItem:
         self.node = node
         self.file_desc = file_desc  # pillarsdk.File object, or None if a 'folder' node.
         self.thumb_path = thumb_path
-        self.label_text = label_text
+
+        if label_text is not None:
+            self.label_text = label_text
 
     @property
     def is_folder(self) -> bool:
         return self._is_folder
 
+    @property
+    def is_spinning(self) -> bool:
+        return self._is_spinning
+
     def update_placement(self, x, y, width, height):
         """Use OpenGL to draw this one menu item."""
 
@@ -220,11 +238,14 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
     # This contains a stack of Node objects that lead up to the currently browsed node.
     path_stack = []
 
+    # This contains a stack of MenuItem objects that lead up to the currently browsed node.
+    menu_item_stack = []
+
     timer = None
     log = logging.getLogger('%s.BlenderCloudBrowser' % __name__)
 
     _menu_item_lock = threading.Lock()
-    current_display_content = []
+    current_display_content = []  # list of MenuItems currently displayed
     loaded_images = set()
     thumbnails_cache = ''
     maximized_area = False
@@ -237,8 +258,9 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
     scroll_offset_space_left = 0
 
     def invoke(self, context, event):
-        # Refuse to start if the file hasn't been saved.
-        if context.blend_data.is_dirty:
+        # Refuse to start if the file hasn't been saved. It's okay if
+        # it's dirty, we just need to know where '//' points to.
+        if not os.path.exists(context.blend_data.filepath):
             self.report({'ERROR'}, 'Please save your Blend file before using '
                                    'the Blender Cloud addon.')
             return {'CANCELLED'}
@@ -267,10 +289,7 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
         self._scroll_reset()
 
         context.window.cursor_modal_set('DEFAULT')
-        async_loop.AsyncModalOperatorMixin.invoke(self, context, event)
-        self._new_async_task(self.async_execute(context))
-
-        return {'RUNNING_MODAL'}
+        return async_loop.AsyncModalOperatorMixin.invoke(self, context, event)
 
     def modal(self, context, event):
         result = async_loop.AsyncModalOperatorMixin.modal(self, context, event)
@@ -301,7 +320,10 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
             selected = self.get_clicked()
 
             if selected:
-                context.window.cursor_set('HAND')
+                if selected.is_spinning:
+                    context.window.cursor_set('WAIT')
+                else:
+                    context.window.cursor_set('HAND')
             else:
                 context.window.cursor_set('DEFAULT')
 
@@ -322,15 +344,13 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
                     # No item clicked, ignore it.
                     return {'RUNNING_MODAL'}
 
+                if selected.is_spinning:
+                    # This can happen when the thumbnail information isn't loaded yet.
+                    return {'RUNNING_MODAL'}
+
                 if selected.is_folder:
-                    self.descend_node(selected.node)
+                    self.descend_node(selected)
                 else:
-                    if selected.file_desc is None:
-                        # This can happen when the thumbnail information isn't loaded yet.
-                        # Just ignore the click for now.
-                        # TODO: think of a way to handle this properly.
-                        self.log.debug('Selected item %r has no file_desc', selected)
-                        return {'RUNNING_MODAL'}
                     self.handle_item_selection(context, selected)
 
         if event.type in {'RIGHTMOUSE', 'ESC'}:
@@ -344,13 +364,13 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
         self.log.debug('Checking credentials')
 
         try:
-            user_id = await self.check_credentials(context, REQUIRED_ROLES_FOR_TEXTURE_BROWSER)
+            db_user = await self.check_credentials(context, REQUIRED_ROLES_FOR_TEXTURE_BROWSER)
         except pillar.NotSubscribedToCloudError:
             self.log.info('User not subscribed to Blender Cloud.')
             self._show_subscribe_screen()
             return None
 
-        if user_id is None:
+        if db_user is None:
             raise pillar.UserNotLoggedInError()
 
         await self.async_download_previews()
@@ -361,12 +381,13 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
         self._state = 'PLEASE_SUBSCRIBE'
         bpy.context.window.cursor_set('HAND')
 
-    def descend_node(self, node):
-        """Descends the node hierarchy by visiting this node.
+    def descend_node(self, menu_item: MenuItem):
+        """Descends the node hierarchy by visiting this menu item's node.
 
         Also keeps track of the current node, so that we know where the "up" button should go.
         """
 
+        node = menu_item.node
         assert isinstance(node, pillarsdk.Node), 'Wrong type %s' % node
 
         if isinstance(node, UpNode):
@@ -375,6 +396,8 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
             self.current_path = self.current_path.parent
             if self.path_stack:
                 self.path_stack.pop()
+            if self.menu_item_stack:
+                self.menu_item_stack.pop()
             if not self.path_stack:
                 self.project_name = ''
         else:
@@ -385,6 +408,7 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
             self.current_path /= node['_id']
             self.log.debug('Going down to %r', self.current_path)
             self.path_stack.append(node)
+            self.menu_item_stack.append(menu_item)
 
         self.browse_assets()
 
@@ -439,7 +463,7 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
         # Just make this thread-safe to be on the safe side.
         with self._menu_item_lock:
             for menu_item in self.current_display_content:
-                if menu_item.node_uuid == node_uuid:
+                if menu_item.represents(node):
                     menu_item.update(node, *args)
                     self.loaded_images.add(menu_item.icon.filepath_raw)
                     break
@@ -466,12 +490,6 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
         self.clear_images()
         self._scroll_reset()
 
-        def thumbnail_loading(node, texture_node):
-            self.add_menu_item(node, None, 'SPINNER', texture_node['name'])
-
-        def thumbnail_loaded(node, file_desc, thumb_path):
-            self.update_menu_item(node, file_desc, thumb_path, file_desc['filename'])
-
         project_uuid = self.current_path.project_uuid
         node_uuid = self.current_path.node_uuid
 
@@ -479,13 +497,13 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
             # Query for sub-nodes of this node.
             self.log.debug('Getting subnodes for parent node %r', node_uuid)
             children = await pillar.get_nodes(parent_node_uuid=node_uuid,
-                                              node_type='group_texture')
+                                              node_type={'group_texture', 'group_hdri'})
         elif project_uuid:
             # Query for top-level nodes.
             self.log.debug('Getting subnodes for project node %r', project_uuid)
             children = await pillar.get_nodes(project_uuid=project_uuid,
                                               parent_node_uuid='',
-                                              node_type='group_texture')
+                                              node_type={'group_texture', 'group_hdri'})
         else:
             # Query for projects
             self.log.debug('No node UUID and no project UUID, listing available projects')
@@ -515,6 +533,13 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
         os.makedirs(directory, exist_ok=True)
 
         self.log.debug('Fetching texture thumbnails for node %r', node_uuid)
+
+        def thumbnail_loading(node, texture_node):
+            self.add_menu_item(node, None, 'SPINNER', texture_node['name'])
+
+        def thumbnail_loaded(node, file_desc, thumb_path):
+            self.update_menu_item(node, file_desc, thumb_path)
+
         await pillar.fetch_texture_thumbs(node_uuid, 's', directory,
                                           thumbnail_loading=thumbnail_loading,
                                           thumbnail_loaded=thumbnail_loaded,
@@ -595,11 +620,6 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
                     item.draw(highlighted=item.hits(self.mouse_x, self.mouse_y))
 
                 bottom_y = min(y, bottom_y)
-            bgl.glColor4f(0.24, 0.68, 0.91, 1)
-            bgl.glRectf(0,
-                        bottom_y - ITEM_MARGIN_Y,
-                        window_region.width,
-                        bottom_y+1 - ITEM_MARGIN_Y)
             self.scroll_offset_space_left = window_region.height - bottom_y
             self.scroll_offset_max = (self.scroll_offset -
                                       self.scroll_offset_space_left +
@@ -725,23 +745,53 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
         self.log.debug('Metadata will be stored at %s', meta_path)
 
         file_paths = []
+        select_dblock = None
+        node = item.node
 
-        def texture_downloading(file_path, file_desc, *args):
+        def texture_downloading(file_path, *_):
             self.log.info('Texture downloading to %s', file_path)
 
-        def texture_downloaded(file_path, file_desc, *args):
+        def texture_downloaded(file_path, file_desc, map_type):
+            nonlocal select_dblock
+
             self.log.info('Texture downloaded to %r.', file_path)
+
+            if context.scene.local_texture_dir.startswith('//'):
+                file_path = bpy.path.relpath(file_path)
+
             image_dblock = bpy.data.images.load(filepath=file_path)
             image_dblock['bcloud_file_uuid'] = file_desc['_id']
-            image_dblock['bcloud_texture_node_uuid'] = item.node_uuid
+            image_dblock['bcloud_node_uuid'] = node['_id']
+            image_dblock['bcloud_node_type'] = node['node_type']
+            image_dblock['bcloud_node'] = pillar.node_to_id(node)
+
+            if node['node_type'] == 'hdri':
+                # All HDRi variations should use the same image datablock, hence once name.
+                image_dblock.name = node['name']
+            else:
+                # All texture variations are loaded at once, and thus need the map type in the name.
+                image_dblock.name = '%s-%s' % (node['name'], map_type)
+
+            # Select the image in the image editor (if the context is right).
+            # Just set the first image we download,
+            if context.area.type == 'IMAGE_EDITOR':
+                if select_dblock is None or file_desc.map_type == 'color':
+                    select_dblock = image_dblock
+                    context.space_data.image = select_dblock
+
             file_paths.append(file_path)
 
         def texture_download_completed(_):
             self.log.info('Texture download complete, inspect:\n%s', '\n'.join(file_paths))
             self._state = 'QUIT'
 
+        # For HDRi nodes: only download the first file.
+        download_node = pillarsdk.Node.new(node)
+        if node['node_type'] == 'hdri':
+            download_node.properties.files = [download_node.properties.files[0]]
+
         signalling_future = asyncio.Future()
-        self._new_async_task(pillar.download_texture(item.node, local_path,
+        self._new_async_task(pillar.download_texture(download_node, local_path,
                                                      metadata_directory=meta_path,
                                                      texture_loading=texture_downloading,
                                                      texture_loaded=texture_downloaded,
@@ -782,19 +832,182 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
         self.scroll_offset_target = self.scroll_offset = 0
 
 
+class PILLAR_OT_switch_hdri(pillar.PillarOperatorMixin,
+                            async_loop.AsyncModalOperatorMixin,
+                            bpy.types.Operator):
+    bl_idname = 'pillar.switch_hdri'
+    bl_label = 'Switch with another variation'
+    bl_description = 'Downloads the selected variation of an HDRi, ' \
+                     'replacing the current image'
+
+    log = logging.getLogger('bpy.ops.%s' % bl_idname)
+
+    image_name = bpy.props.StringProperty(name='image_name',
+                                          description='Name of the image block to replace')
+
+    file_uuid = bpy.props.StringProperty(name='file_uuid',
+                                         description='File ID to download')
+
+    async def async_execute(self, context):
+        """Entry point of the asynchronous operator."""
+
+        self.report({'INFO'}, 'Communicating with Blender Cloud')
+
+        try:
+            try:
+                db_user = await self.check_credentials(context, REQUIRED_ROLES_FOR_TEXTURE_BROWSER)
+                user_id = db_user['_id']
+            except pillar.NotSubscribedToCloudError:
+                self.log.exception('User not subscribed to cloud.')
+                self.report({'ERROR'}, 'Please subscribe to the Blender Cloud.')
+                self._state = 'QUIT'
+                return
+            except pillar.UserNotLoggedInError:
+                self.log.exception('Error checking/refreshing credentials.')
+                self.report({'ERROR'}, 'Please log in on Blender ID first.')
+                self._state = 'QUIT'
+                return
+
+            if not user_id:
+                raise pillar.UserNotLoggedInError()
+
+            await self.download_and_replace(context)
+        except Exception as ex:
+            self.log.exception('Unexpected exception caught.')
+            self.report({'ERROR'}, 'Unexpected error %s: %s' % (type(ex), ex))
+
+        self._state = 'QUIT'
+
+    async def download_and_replace(self, context):
+        from .pillar import sanitize_filename
+
+        self._state = 'DOWNLOADING_TEXTURE'
+
+        current_image = bpy.data.images[self.image_name]
+        node = current_image['bcloud_node']
+        filename = '%s.taken_from_file' % sanitize_filename(node['name'])
+
+        local_path = os.path.dirname(bpy.path.abspath(current_image.filepath))
+        top_texture_directory = bpy.path.abspath(context.scene.local_texture_dir)
+        meta_path = os.path.join(top_texture_directory, '.blender_cloud')
+
+        file_uuid = self.file_uuid
+        resolution = next(file_ref['resolution'] for file_ref in node['properties']['files']
+                          if file_ref['file'] == file_uuid)
+
+        self.log.info('Downloading file %r-%s to %s', file_uuid, resolution, local_path)
+        self.log.debug('Metadata will be stored at %s', meta_path)
+
+        def file_loading(file_path, file_desc, map_type):
+            self.log.info('Texture downloading to %s (%s)',
+                          file_path, utils.sizeof_fmt(file_desc['length']))
+
+        async def file_loaded(file_path, file_desc, map_type):
+            if context.scene.local_texture_dir.startswith('//'):
+                file_path = bpy.path.relpath(file_path)
+
+            self.log.info('Texture downloaded to %s', file_path)
+            current_image['bcloud_file_uuid'] = file_uuid
+            current_image.filepath = file_path  # This automatically reloads the image from disk.
+
+        await pillar.download_file_by_uuid(file_uuid,
+                                           local_path,
+                                           meta_path,
+                                           filename=filename,
+                                           map_type=resolution,
+                                           file_loading=file_loading,
+                                           file_loaded_sync=file_loaded,
+                                           future=self.signalling_future)
+
+        self.report({'INFO'}, 'Image download complete')
+
+
 # store keymaps here to access after registration
 addon_keymaps = []
 
 
-def menu_draw(self, context):
-    layout = self.layout
-    layout.separator()
-    layout.operator(BlenderCloudBrowser.bl_idname, icon='MOD_SCREW')
+def image_editor_menu(self, context):
+    self.layout.operator(BlenderCloudBrowser.bl_idname,
+                         text='Get image from Blender Cloud',
+                         icon_value=blender.icon('CLOUD'))
+
+
+def hdri_download_panel__image_editor(self, context):
+    _hdri_download_panel(self, context.edit_image)
+
+
+def hdri_download_panel__node_editor(self, context):
+    if context.active_node.type not in {'TEX_ENVIRONMENT', 'TEX_IMAGE'}:
+        return
+
+    _hdri_download_panel(self, context.active_node.image)
+
+
+def _hdri_download_panel(self, current_image):
+    if not current_image:
+        return
+    if 'bcloud_node_type' not in current_image:
+        return
+    if current_image['bcloud_node_type'] != 'hdri':
+        return
+    try:
+        current_variation = current_image['bcloud_file_uuid']
+    except KeyError:
+        log.warning('Image %r has a bcloud_node_type but no bcloud_file_uuid property.',
+                    current_image.name)
+        return
+
+    row = self.layout.row(align=True).split(0.3)
+    row.label('HDRi', icon_value=blender.icon('CLOUD'))
+    row.prop(current_image, 'hdri_variation', text='')
+
+    if current_image.hdri_variation != current_variation:
+        props = row.operator(PILLAR_OT_switch_hdri.bl_idname,
+                             text='Replace',
+                             icon='FILE_REFRESH')
+        props.image_name = current_image.name
+        props.file_uuid = current_image.hdri_variation
+
+
+# Storage for variation labels, as the strings in EnumProperty items
+# MUST be kept in Python memory.
+variation_label_storage = {}
+
+
+def hdri_variation_choices(self, context):
+    if context.area.type == 'IMAGE_EDITOR':
+        image = context.edit_image
+    elif context.area.type == 'NODE_EDITOR':
+        image = context.active_node.image
+    else:
+        return []
+
+    if 'bcloud_node' not in image:
+        return []
+
+    choices = []
+    for file_doc in image['bcloud_node']['properties']['files']:
+        label = file_doc['resolution']
+        variation_label_storage[label] = label
+        choices.append((file_doc['file'], label, ''))
+
+    return choices
 
 
 def register():
     bpy.utils.register_class(BlenderCloudBrowser)
-    # bpy.types.INFO_MT_mesh_add.append(menu_draw)
+    bpy.utils.register_class(PILLAR_OT_switch_hdri)
+    bpy.types.IMAGE_MT_image.prepend(image_editor_menu)
+    bpy.types.IMAGE_PT_image_properties.append(hdri_download_panel__image_editor)
+    bpy.types.NODE_PT_active_node_properties.append(hdri_download_panel__node_editor)
+
+    # HDRi resolution switcher/chooser.
+    # TODO: when an image is selected, switch this property to its current resolution.
+    bpy.types.Image.hdri_variation = bpy.props.EnumProperty(
+        name='HDRi variations',
+        items=hdri_variation_choices,
+        description='Select a variation with which to replace this image'
+    )
 
     # handle the keymap
     wm = bpy.context.window_manager
@@ -814,4 +1027,11 @@ def unregister():
         km.keymap_items.remove(kmi)
     addon_keymaps.clear()
 
+    if hasattr(bpy.types.Image, 'hdri_variation'):
+        del bpy.types.Image.hdri_variation
+
+    bpy.types.IMAGE_MT_image.remove(image_editor_menu)
+    bpy.types.IMAGE_PT_image_properties.remove(hdri_download_panel__image_editor)
+    bpy.types.NODE_PT_active_node_properties.remove(hdri_download_panel__node_editor)
     bpy.utils.unregister_class(BlenderCloudBrowser)
+    bpy.utils.unregister_class(PILLAR_OT_switch_hdri)

blender_cloud/utils.py

@@ -0,0 +1,31 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+
+def sizeof_fmt(num: int, suffix='B') -> str:
+    """Returns a human-readable size.
+
+    Source: http://stackoverflow.com/a/1094933/875379
+    """
+
+    for unit in ['', 'Ki', 'Mi', 'Gi', 'Ti', 'Pi', 'Ei', 'Zi']:
+        if abs(num) < 1024:
+            return '%.1f %s%s' % (num, unit, suffix)
+        num /= 1024
+
+    return '%.1f Yi%s' % (num, suffix)

blender_cloud/wheels/__init__.py

@@ -1,3 +1,21 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
 """External dependencies loader."""
 
 import glob

requirements.txt

@@ -1,7 +1,7 @@
 # Primary requirements:
 -e git+https://github.com/sybrenstuvel/cachecontrol.git@sybren-filecache-delete-crash-fix#egg=CacheControl
 lockfile==0.12.2
-pillarsdk==1.4.0
+pillarsdk==1.6.0
 wheel==0.29.0
 
 # Secondary requirements:

setup.py

@@ -1,4 +1,21 @@
 #!/usr/bin/env python3
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
 
 import glob
 import sys
@@ -179,7 +196,7 @@ setup(
               'wheels': BuildWheels},
     name='blender_cloud',
     description='The Blender Cloud addon allows browsing the Blender Cloud from Blender.',
-    version='1.3.3',
+    version='1.4.99',
     author='Sybren A. Stüvel',
     author_email='sybren@stuvel.eu',
     packages=find_packages('.'),