Bumped pillarsdk version to 1.6.1

Previously it would always send 'unlink', even when a duplicate strip was
removed.

.gitignore

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

addon-bundle/README.txt

@@ -0,0 +1,52 @@
+Blender Cloud Addon
+===================
+
+Congratulations on downloading the Blender Cloud addon. For your
+convenience, we have bundled it with the Blender ID addon.
+
+To use the Blender Cloud addon, perform the following steps:
+
+- Use Blender (File, User Preferences, Addons, Install from file)
+  to install blender_id-x.x.x.addon.zip
+
+- If you had a previous version of the Blender Cloud addon installed,
+  restart Blender now.
+
+- Log in with your Blender ID.
+
+- Use Blender to install blender_cloud-x.x.x.addon.zip
+
+    If you don't see the addon in the list, enable the Testing
+    category.
+
+- Press Ctrl+Alt+Shift+A to start the texture browser.
+
+- Visit the User Preferences, Addons panel, to use the Blender Sync
+  feature.
+
+
+Support for Blenders not from blender.org
+-----------------------------------------
+
+Maybe you use Blender from another source than blender.org, such as an
+Ubuntu package. If that is the case, you have to make sure that the
+Python package "requests" is installed. On Ubuntu Linux this can be
+done with the command
+
+    sudo apt-get install python3-requests
+
+On other platforms & distributions this might be different.
+
+Blender uses Python 3.5, so make sure you install the package for the
+correct version of Python.
+
+
+Subscribing to the Blender Cloud
+--------------------------------
+
+The Blender Sync feature is free to use for everybody with a Blender
+ID account. In order to use the Texture Browser you need to have a
+Blender Cloud subscription. If you didn't subscribe yet, go to:
+
+    https://cloud.blender.org/join
+

addon-bundle/bundle.sh

@@ -0,0 +1,36 @@
+#!/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)
+BUNDLE=${BUNDLE/.addon.zip/-bundle-UNZIP_ME_FIRST.zip}
+
+zip -9 $BUNDLE $(basename $BCLOUD) $(basename $BID) README.txt
+
+dolphin --select $BUNDLE 2>/dev/null >/dev/null & disown
+echo "CREATED: $BUNDLE"

blender_cloud/__init__.py

@@ -20,8 +20,8 @@
 
 bl_info = {
     'name': 'Blender Cloud',
-    'author': 'Sybren A. Stüvel and Francesco Siddi',
-    'version': (1, 2, 2),
+    "author": "Sybren A. Stüvel, Francesco Siddi, Inês Almeida, Antony Riakiotakis",
+    'version': (1, 4, 999),
     '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
@@ -70,20 +70,28 @@ def register():
             sys.modules[modname] = module
             return module
 
-        blender = reload_mod('blender')
-        gui = reload_mod('gui')
-        async_loop = reload_mod('async_loop')
-        settings_sync = reload_mod('settings_sync')
         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, gui, async_loop, settings_sync, blendfile
+        from . import (blender, texture_browser, async_loop, settings_sync, blendfile, home_project,
+                       image_sharing, attract)
 
     async_loop.setup_asyncio_executor()
     async_loop.register()
 
-    gui.register()
+    texture_browser.register()
     blender.register()
     settings_sync.register()
+    image_sharing.register()
+    attract.register()
 
 
 def _monkey_patch_requests():
@@ -104,9 +112,11 @@ def _monkey_patch_requests():
 
 
 def unregister():
-    from . import blender, gui, async_loop, settings_sync
+    from . import blender, texture_browser, async_loop, settings_sync, image_sharing, attract
 
+    image_sharing.unregister()
+    attract.unregister()
     settings_sync.unregister()
     blender.unregister()
-    gui.unregister()
+    texture_browser.unregister()
     async_loop.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,845 @@
+# ##### 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 contextlib
+import functools
+import logging
+
+if "bpy" in locals():
+    import importlib
+
+    draw = importlib.reload(draw)
+    pillar = importlib.reload(pillar)
+    async_loop = importlib.reload(async_loop)
+else:
+    from . import draw
+    from .. import pillar, async_loop
+
+import bpy
+import pillarsdk
+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 selected_shots(context):
+    """Generator, yields selected strips if they are Attract shots."""
+
+    for strip in context.selected_sequences:
+        atc_object_id = getattr(strip, 'atc_object_id')
+        if not atc_object_id:
+            continue
+
+        yield strip
+
+
+def all_shots(context):
+    """Generator, yields all strips if they are Attract shots."""
+
+    for strip in context.scene.sequence_editor.sequences_all:
+        atc_object_id = getattr(strip, 'atc_object_id')
+        if not atc_object_id:
+            continue
+
+        yield strip
+
+
+def shown_strips(context):
+    """Returns the strips from the current meta-strip-stack, or top-level strips.
+
+    What is returned depends on what the user is currently editing.
+    """
+
+    if context.scene.sequence_editor.meta_stack:
+        return context.scene.sequence_editor.meta_stack[-1].sequences
+
+    return context.scene.sequence_editor.sequences
+
+
+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
+
+
+def shot_id_use(strips):
+    """Returns a mapping from shot Object ID to a list of strips that use it."""
+
+    import collections
+
+    # Count the number of uses per Object ID, so that we can highlight double use.
+    ids_in_use = collections.defaultdict(list)
+    for strip in strips:
+        if not getattr(strip, 'atc_is_synced', False):
+            continue
+
+        ids_in_use[strip.atc_object_id].append(strip)
+
+    return ids_in_use
+
+
+def compute_strip_conflicts(context):
+    """Sets the strip property atc_object_id_conflict for each strip."""
+
+    ids_in_use = shot_id_use(context.scene.sequence_editor.sequences_all)
+    for strips in ids_in_use.values():
+        is_conflict = len(strips) > 1
+        for strip in strips:
+            strip.atc_object_id_conflict = is_conflict
+
+    return ids_in_use
+
+
+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'}
+
+        selshots = list(selected_shots(context))
+        if strip and strip.type in strip_types and strip.atc_object_id:
+            if len(selshots) > 1:
+                noun = 'Selected Shots'
+            else:
+                noun = 'This Shot'
+
+            if strip.atc_object_id_conflict:
+                warnbox = layout.box()
+                warnbox.alert = True
+                warnbox.label('Warning: This shot is linked to multiple sequencer strips.',
+                              icon='ERROR')
+
+            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:
+                sub = layout.column(align=True)
+                row = sub.row(align=True)
+                if bpy.ops.attract.submit_selected.poll():
+                    row.operator('attract.submit_selected', text='Submit %s' % noun)
+                else:
+                    row.operator(ATTRACT_OT_submit_all.bl_idname)
+                row.operator(AttractShotFetchUpdate.bl_idname,
+                             text='', icon='FILE_REFRESH')
+                row.operator(ATTRACT_OT_shot_open_in_browser.bl_idname,
+                             text='', icon='WORLD')
+                sub.operator(ATTRACT_OT_make_shot_thumbnail.bl_idname,
+                             text='Render Thumbnail for %s' % noun)
+
+                # Group more dangerous operations.
+                dangerous_sub = layout.column(align=True)
+                dangerous_sub.operator(AttractShotDelete.bl_idname)
+                dangerous_sub.operator('attract.strip_unlink')
+
+        elif context.selected_sequences:
+            if len(context.selected_sequences) > 1:
+                noun = 'selected strips'
+            else:
+                noun = 'this strip'
+            layout.operator(AttractShotSubmitSelected.bl_idname,
+                            text='Submit %s as New Shot' % noun)
+            layout.operator('attract.shot_relink')
+        else:
+            layout.operator(ATTRACT_OT_submit_all.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': '',
+                               'used_in_edit': True,
+                               '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']
+
+        compute_strip_conflicts(bpy.context)
+        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,
+                'properties.used_in_edit': True,
+            }
+        }
+
+        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, *, refresh=False):
+        from .. import pillar
+
+        try:
+            node = pillar.sync_call(Node.find, atc_object_id, caching=False)
+        except (sdk_exceptions.ResourceNotFound, sdk_exceptions.MethodNotAllowed):
+            verb = 'refresh' if refresh else 'relink'
+            self.report({'ERROR'}, 'Shot %r not found on the Attract server, unable to %s.'
+                        % (atc_object_id, verb))
+            strip.atc_is_synced = False
+            return {'CANCELLED'}
+
+        pillar.sync_call(node.patch, {'op': 'relink'})
+        strip.atc_is_synced = True
+        if not refresh:
+            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 ''
+
+        compute_strip_conflicts(bpy.context)
+        draw.tag_redraw_all_sequencer_editors()
+
+
+class AttractShotFetchUpdate(AttractOperatorMixin, Operator):
+    bl_idname = "attract.shot_fetch_update"
+    bl_label = "Fetch Update From Attract"
+    bl_description = 'Update status, description & notes from Attract'
+
+    @classmethod
+    def poll(cls, context):
+        return any(selected_shots(context))
+
+    def execute(self, context):
+        for strip in selected_shots(context):
+            status = self.relink(strip, strip.atc_object_id, refresh=True)
+            # We don't abort when one strip fails. All selected shots should be
+            # refreshed, even if one can't be found (for example).
+            if not isinstance(status, set):
+                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):
+        maybe_id = context.window_manager.clipboard
+        if len(maybe_id) == 24:
+            try:
+                int(maybe_id, 16)
+            except ValueError:
+                pass
+            else:
+                self.strip_atc_object_id = maybe_id
+
+        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 ATTRACT_OT_shot_open_in_browser(AttractOperatorMixin, Operator):
+    bl_idname = 'attract.shot_open_in_browser'
+    bl_label = 'Open in Browser'
+    bl_description = 'Opens a webbrowser to show the shot on Attract'
+
+    def execute(self, context):
+        from ..blender import PILLAR_WEB_SERVER_URL
+        import webbrowser
+        import urllib.parse
+
+        strip = active_strip(context)
+
+        url = urllib.parse.urljoin(PILLAR_WEB_SERVER_URL,
+                                   'nodes/%s/redir' % strip.atc_object_id)
+        webbrowser.open_new_tab(url)
+        self.report({'INFO'}, 'Opened a browser at %s' % url)
+
+        return {'FINISHED'}
+
+
+class AttractShotDelete(AttractOperatorMixin, Operator):
+    bl_idname = 'attract.shot_delete'
+    bl_label = 'Delete Shot'
+    bl_description = 'Remove this shot 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 from The Edit.")
+
+
+class AttractStripUnlink(AttractOperatorMixin, Operator):
+    bl_idname = 'attract.strip_unlink'
+    bl_label = 'Unlink Shot From This Strip'
+    bl_description = 'Remove Attract props from the selected strip(s)'
+
+    def execute(self, context):
+        unlinked_ids = set()
+
+        # First remove the Attract properties from the strips.
+        for strip in context.selected_sequences:
+            atc_object_id = getattr(strip, 'atc_object_id')
+            remove_atc_props(strip)
+
+            if atc_object_id:
+                unlinked_ids.add(atc_object_id)
+
+        # For all Object IDs that are no longer in use in the edit, let Attract know.
+        # This should be done with care, as the shot could have been attached to multiple
+        # strips.
+        id_to_shots = compute_strip_conflicts(context)
+        for oid in unlinked_ids:
+            if len(id_to_shots[oid]):
+                # Still in use
+                continue
+
+            node = Node({'_id': oid})
+            pillar.sync_call(node.patch, {'op': 'unlink'})
+            self.report({'INFO'}, 'Shot %s has been marked as Unused.' % oid)
+
+        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.
+        maybe_error = self.find_node_type('attract_shot')
+        if isinstance(maybe_error, set):
+            return maybe_error
+
+        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)
+
+
+class ATTRACT_OT_submit_all(AttractOperatorMixin, Operator):
+    bl_idname = 'attract.submit_all'
+    bl_label = 'Submit All Shots to Attract'
+    bl_description = 'Updates Attract with the current state of the edit'
+
+    def execute(self, context):
+        # Check that the project is set up for Attract.
+        maybe_error = self.find_node_type('attract_shot')
+        if isinstance(maybe_error, set):
+            return maybe_error
+
+        for strip in all_shots(context):
+            status = self.submit_update(strip)
+            if isinstance(status, set):
+                return status
+
+        self.report({'INFO'}, 'All strips re-sent to Attract.')
+
+        return {'FINISHED'}
+
+
+class ATTRACT_OT_open_meta_blendfile(AttractOperatorMixin, Operator):
+    bl_idname = 'attract.open_meta_blendfile'
+    bl_label = 'Open Blendfile'
+    bl_description = 'Open Blendfile from movie strip metadata'
+
+    @classmethod
+    def poll(cls, context):
+        return bool(any(cls.filename_from_metadata(s) for s in context.selected_sequences))
+
+    @staticmethod
+    def filename_from_metadata(strip):
+        """Returns the blendfile name from the strip metadata, or None."""
+
+        # Metadata is a dict like:
+        # meta = {'END_FRAME': '88',
+        #         'BLEND_FILE': 'metadata-test.blend',
+        #         'SCENE': 'SüperSčene',
+        #         'FRAME_STEP': '1',
+        #         'START_FRAME': '32'}
+
+        meta = strip.get('metadata', None)
+        if not meta:
+            return None
+
+        return meta.get('BLEND_FILE', None) or None
+
+    def execute(self, context):
+        for strip in context.selected_sequences:
+            meta = strip.get('metadata', None)
+            if not meta:
+                continue
+
+            fname = meta.get('BLEND_FILE', None)
+            if not fname: continue
+
+            scene = meta.get('SCENE', None)
+            self.open_in_new_blender(fname, scene)
+
+        return {'FINISHED'}
+
+    def open_in_new_blender(self, fname, scene):
+        """
+        :type fname: str
+        :type scene: str
+        """
+        import subprocess
+        import sys
+
+        cmd = [
+            bpy.app.binary_path,
+            str(fname),
+        ]
+
+        cmd[1:1] = [v for v in sys.argv if v.startswith('--enable-')]
+
+        if scene:
+            cmd.extend(['--python-expr',
+                        'import bpy; bpy.context.screen.scene = bpy.data.scenes["%s"]' % scene])
+            cmd.extend(['--scene', scene])
+
+        subprocess.Popen(cmd)
+
+
+class ATTRACT_OT_make_shot_thumbnail(AttractOperatorMixin,
+                                     async_loop.AsyncModalOperatorMixin,
+                                     Operator):
+    bl_idname = 'attract.make_shot_thumbnail'
+    bl_label = 'Render Shot Thumbnail'
+    bl_description = 'Renders the current frame, and uploads it as thumbnail for the shot'
+
+    stop_upon_exception = True
+
+    @classmethod
+    def poll(cls, context):
+        return bool(context.selected_sequences)
+
+    @contextlib.contextmanager
+    def thumbnail_render_settings(self, context, thumbnail_width=512):
+        # Remember current settings so we can restore them later.
+        orig_res_x = context.scene.render.resolution_x
+        orig_res_y = context.scene.render.resolution_y
+        orig_percentage = context.scene.render.resolution_percentage
+        orig_file_format = context.scene.render.image_settings.file_format
+        orig_quality = context.scene.render.image_settings.quality
+
+        try:
+            # Update the render size to something thumbnaily.
+            factor = orig_res_y / orig_res_x
+            context.scene.render.resolution_x = thumbnail_width
+            context.scene.render.resolution_y = round(thumbnail_width * factor)
+            context.scene.render.resolution_percentage = 100
+            context.scene.render.image_settings.file_format = 'JPEG'
+            context.scene.render.image_settings.quality = 85
+
+            yield
+        finally:
+            # Return the render settings to normal.
+            context.scene.render.resolution_x = orig_res_x
+            context.scene.render.resolution_y = orig_res_y
+            context.scene.render.resolution_percentage = orig_percentage
+            context.scene.render.image_settings.file_format = orig_file_format
+            context.scene.render.image_settings.quality = orig_quality
+
+    @contextlib.contextmanager
+    def temporary_current_frame(self, context):
+        current_frame = context.scene.frame_current
+        try:
+            yield
+        finally:
+            context.scene.frame_current = current_frame
+
+    async def async_execute(self, context):
+        nr_of_strips = len(context.selected_sequences)
+        do_multishot = nr_of_strips > 1
+
+        with self.temporary_current_frame(context):
+            if do_multishot:
+                context.window_manager.progress_begin(0, nr_of_strips)
+                try:
+                    self.report({'INFO'}, 'Rendering thumbnails for %i selected shots.' %
+                                nr_of_strips)
+
+                    for idx, strip in enumerate(context.selected_sequences):
+                        context.window_manager.progress_update(idx)
+                        # For multi-shot we can't just use the current frame (each thumb would be
+                        # identical), so instead we use the middle frame. The first/last frames
+                        # cannot be reliably used due to transitions with other shots.
+                        self.set_middle_frame(context, strip)
+                        await self.thumbnail_strip(context, strip)
+
+                        if self._state == 'QUIT':
+                            return
+                    context.window_manager.progress_update(nr_of_strips)
+                finally:
+                    context.window_manager.progress_end()
+
+            else:
+                strip = active_strip(context)
+                if not strip.frame_final_start <= context.scene.frame_current <= strip.frame_final_end:
+                    self.report({'WARNING'}, 'Rendering middle frame as thumbnail for active shot.')
+                    self.set_middle_frame(context, strip)
+                else:
+                    self.report({'INFO'}, 'Rendering current frame as thumbnail for active shot.')
+
+                context.window_manager.progress_begin(0, 1)
+                context.window_manager.progress_update(0)
+                try:
+                    await self.thumbnail_strip(context, strip)
+                finally:
+                    context.window_manager.progress_update(1)
+                    context.window_manager.progress_end()
+
+                if self._state == 'QUIT':
+                    return
+
+        self.report({'INFO'}, 'Thumbnail uploaded to Attract')
+        self.quit()
+
+    def set_middle_frame(self, context, strip):
+        """Sets the current frame to the middle frame of the strip."""
+
+        middle = round((strip.frame_final_start + strip.frame_final_end) / 2)
+        context.scene.frame_set(middle)
+
+    async def thumbnail_strip(self, context, strip):
+        atc_object_id = getattr(strip, 'atc_object_id', None)
+        if not atc_object_id:
+            self.report({'ERROR'}, 'Strip %s not set up for Attract' % strip.name)
+            self.quit()
+            return
+
+        with self.thumbnail_render_settings(context):
+            bpy.ops.render.render()
+        file_id = await self.upload_via_tempdir(bpy.data.images['Render Result'],
+                                                'attract_shot_thumbnail.jpg')
+
+        if file_id is None:
+            self.quit()
+            return
+
+        # Update the shot to include this file as the picture.
+        node = pillarsdk.Node({'_id': atc_object_id})
+        await pillar.pillar_call(
+            node.patch,
+            {
+                'op': 'from-blender',
+                '$set': {
+                    'picture': file_id,
+                }
+            })
+
+    async def upload_via_tempdir(self, datablock, filename_on_cloud) -> pillarsdk.Node:
+        """Saves the datablock to file, and uploads it to the cloud.
+
+        Saving is done to a temporary directory, which is removed afterwards.
+
+        Returns the node.
+        """
+        import tempfile
+        import os.path
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            filepath = os.path.join(tmpdir, filename_on_cloud)
+            self.log.debug('Saving %s to %s', datablock, filepath)
+            datablock.save_render(filepath)
+            return await self.upload_file(filepath)
+
+    async def upload_file(self, filename: str, fileobj=None):
+        """Uploads a file to the cloud, attached to the image sharing node.
+
+        Returns the node.
+        """
+        from .. import blender
+
+        prefs = blender.preferences()
+        project = self.find_project(prefs.attract_project.project)
+
+        self.log.info('Uploading file %s', filename)
+        resp = await pillar.pillar_call(
+            pillarsdk.File.upload_to_project,
+            project['_id'],
+            'image/jpeg',
+            filename,
+            fileobj=fileobj)
+
+        self.log.debug('Returned data: %s', resp)
+        try:
+            file_id = resp['file_id']
+        except KeyError:
+            self.log.error('Upload did not succeed, response: %s', resp)
+            self.report({'ERROR'}, 'Unable to upload thumbnail to Attract: %s' % resp)
+            return None
+
+        self.log.info('Created file %s', file_id)
+        self.report({'INFO'}, 'File succesfully uploaded to the cloud!')
+
+        return file_id
+
+
+def draw_strip_movie_meta(self, context):
+    strip = active_strip(context)
+    if not strip:
+        return
+
+    meta = strip.get('metadata', None)
+    if not meta:
+        return None
+
+    box = self.layout.column(align=True)
+    row = box.row(align=True)
+    fname = meta.get('BLEND_FILE', None) or None
+    if fname:
+        row.label('Original Blendfile: %s' % fname)
+        row.operator(ATTRACT_OT_open_meta_blendfile.bl_idname,
+                     text='', icon='FILE_BLEND')
+    sfra = meta.get('START_FRAME', '?')
+    efra = meta.get('END_FRAME', '?')
+    box.label('Original Frame Range: %s-%s' % (sfra, efra))
+
+
+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_object_id_conflict = bpy.props.BoolProperty(
+        name='Object ID Conflict',
+        description='Attract Object ID used multiple times',
+        default=False)
+    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.types.SEQUENCER_PT_edit.append(draw_strip_movie_meta)
+
+    bpy.utils.register_class(ToolsPanel)
+    bpy.utils.register_class(AttractShotRelink)
+    bpy.utils.register_class(AttractShotDelete)
+    bpy.utils.register_class(AttractStripUnlink)
+    bpy.utils.register_class(AttractShotFetchUpdate)
+    bpy.utils.register_class(AttractShotSubmitSelected)
+    bpy.utils.register_class(ATTRACT_OT_submit_all)
+    bpy.utils.register_class(ATTRACT_OT_open_meta_blendfile)
+    bpy.utils.register_class(ATTRACT_OT_shot_open_in_browser)
+    bpy.utils.register_class(ATTRACT_OT_make_shot_thumbnail)
+    draw.callback_enable()
+
+
+def unregister():
+    draw.callback_disable()
+    bpy.utils.unregister_module(__name__)
+    del bpy.types.Sequence.atc_is_synced
+    del bpy.types.Sequence.atc_object_id
+    del bpy.types.Sequence.atc_object_id_conflict
+    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

blender_cloud/attract/draw.py

@@ -0,0 +1,185 @@
+# ##### 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)
+}
+
+CONFLICT_COLOUR = (0.576, 0.118, 0.035)  # RGB tuple
+
+
+def get_strip_rectf(strip):
+    # 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
+    y2 = strip.channel - 0.2 + 1
+
+    return x1, y1, x2, y2
+
+
+def draw_underline_in_strip(strip_coords, pixel_size_x, color):
+    from bgl import glColor4f, glRectf, glEnable, glDisable, GL_BLEND
+    import bgl
+
+    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
+
+    bgl.glPushAttrib(bgl.GL_COLOR_BUFFER_BIT | bgl.GL_LINE_BIT)
+
+    glColor4f(*color)
+    glEnable(GL_BLEND)
+    bgl.glLineWidth(2)
+    bgl.glBegin(bgl.GL_LINES)
+
+    bgl.glVertex2f(s_x1, s_y1)
+    if s_x1 < cf_x < s_x2:
+        # Bad luck, the line passes our strip
+        bgl.glVertex2f(cf_x - pixel_size_x, s_y1)
+        bgl.glVertex2f(cf_x + pixel_size_x, s_y1)
+    bgl.glVertex2f(s_x2, s_y1)
+
+    bgl.glEnd()
+    bgl.glPopAttrib()
+
+
+def draw_strip_conflict(strip_coords, pixel_size_x):
+    """Draws conflicting states between strips."""
+
+    import bgl
+
+    s_x1, s_y1, s_x2, s_y2 = strip_coords
+    bgl.glPushAttrib(bgl.GL_COLOR_BUFFER_BIT | bgl.GL_LINE_BIT)
+
+    # Always draw the full rectangle, the conflict should be resolved and thus stand out.
+    bgl.glColor3f(*CONFLICT_COLOUR)
+    bgl.glLineWidth(3)
+    bgl.glPointSize(10)
+
+    bgl.glBegin(bgl.GL_LINE_LOOP)
+    bgl.glVertex2f(s_x1, s_y1)
+    bgl.glVertex2f(s_x2, s_y1)
+    bgl.glVertex2f(s_x2, s_y2)
+    bgl.glVertex2f(s_x1, s_y2)
+    bgl.glEnd()
+
+    bgl.glBegin(bgl.GL_POINTS)
+    bgl.glVertex2f(s_x1, s_y1)
+    bgl.glVertex2f(s_x2, s_y1)
+    bgl.glVertex2f(s_x2, s_y2)
+    bgl.glVertex2f(s_x1, s_y2)
+    bgl.glEnd()
+
+    bgl.glPopAttrib()
+
+
+def draw_callback_px():
+    context = bpy.context
+
+    if not context.scene.sequence_editor:
+        return
+
+    from . import shown_strips
+
+    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
+
+    strips = shown_strips(context)
+
+    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)
+
+        # 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,))
+        if strip.atc_is_synced and strip.atc_object_id_conflict:
+            draw_strip_conflict(strip_coords, pixel_size_x)
+
+
+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,28 +1,83 @@
+# ##### 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.
 """
 
 import logging
+import os.path
 
 import bpy
 from bpy.types import AddonPreferences, Operator, WindowManager, Scene, PropertyGroup
-from bpy.props import StringProperty, EnumProperty, PointerProperty
+from bpy.props import StringProperty, EnumProperty, PointerProperty, BoolProperty
+import rna_prop_ui
 
-from . import pillar, gui
+from . import pillar, async_loop
 
-PILLAR_SERVER_URL = 'https://cloudapi.blender.org/'
-# PILLAR_SERVER_URL = 'http://localhost:5000/'
+PILLAR_WEB_SERVER_URL = 'https://cloud.blender.org/'
+# PILLAR_WEB_SERVER_URL = 'http://pillar-web:5001/'
+PILLAR_SERVER_URL = '%sapi/' % PILLAR_WEB_SERVER_URL
 
 ADDON_NAME = 'blender_cloud'
 log = logging.getLogger(__name__)
 
+icons = None
+
 
 def redraw(self, context):
     context.area.tag_redraw()
 
 
+def pyside_cache(propname):
+
+    if callable(propname):
+        raise TypeError('Usage: pyside_cache("property_name")')
+
+    def decorator(wrapped):
+        """Stores the result of the callable in Python-managed memory.
+
+        This is to work around the warning at
+        https://www.blender.org/api/blender_python_api_master/bpy.props.html#bpy.props.EnumProperty
+        """
+
+        import functools
+
+        @functools.wraps(wrapped)
+        # We can't use (*args, **kwargs), because EnumProperty explicitly checks
+        # for the number of fixed positional arguments.
+        def wrapper(self, context):
+            result = None
+            try:
+                result = wrapped(self, context)
+                return result
+            finally:
+                rna_type, rna_info = getattr(self.bl_rna, propname)
+                rna_info['_cached_result'] = result
+        return wrapper
+    return decorator
+
+
+@pyside_cache('version')
 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:
@@ -38,7 +93,7 @@ class SyncStatusProperties(PropertyGroup):
             ('SYNCING', 'SYNCING', 'Synchronising with Blender Cloud.'),
         ],
         name='status',
-        description='Current status of Blender Sync.',
+        description='Current status of Blender Sync',
         update=redraw)
 
     version = EnumProperty(
@@ -82,6 +137,43 @@ class SyncStatusProperties(PropertyGroup):
         self['available_blender_versions'] = new_versions
 
 
+@pyside_cache('project')
+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
 
@@ -99,6 +191,22 @@ class BlenderCloudPreferences(AddonPreferences):
         subtype='DIR_PATH',
         default='//textures')
 
+    open_browser_after_share = BoolProperty(
+        name='Open browser after sharing file',
+        description='When enabled, Blender will open a webbrowser',
+        default=True
+    )
+
+    # TODO: store local path with the Attract project, so that people
+    # can switch projects and the local path switches with it.
+    attract_project = PointerProperty(type=BlenderCloudProjectGroup)
+    attract_project_local_path = StringProperty(
+        name='Local project path',
+        description='Local path of your Attract project, used to search for blend files; '
+                    'usually best to set to an absolute path',
+        subtype='DIR_PATH',
+        default='//../')
+
     def draw(self, context):
         import textwrap
 
@@ -114,28 +222,28 @@ class BlenderCloudPreferences(AddonPreferences):
             blender_id_profile = blender_id.get_active_profile()
 
         if blender_id is None:
-            icon = 'ERROR'
+            msg_icon = 'ERROR'
             text = 'This add-on requires Blender ID'
             help_text = 'Make sure that the Blender ID add-on is installed and activated'
         elif not blender_id_profile:
-            icon = 'ERROR'
+            msg_icon = 'ERROR'
             text = 'You are logged out.'
             help_text = 'To login, go to the Blender ID add-on preferences.'
         elif bpy.app.debug and pillar.SUBCLIENT_ID not in blender_id_profile.subclients:
-            icon = 'QUESTION'
+            msg_icon = 'QUESTION'
             text = 'No Blender Cloud credentials.'
             help_text = ('You are logged in on Blender ID, but your credentials have not '
                          'been synchronized with Blender Cloud yet. Press the Update '
                          'Credentials button.')
         else:
-            icon = 'WORLD_DATA'
+            msg_icon = 'WORLD_DATA'
             text = 'You are logged in as %s.' % blender_id_profile.username
             help_text = ('To logout or change profile, '
                          'go to the Blender ID add-on preferences.')
 
         # Authentication stuff
         auth_box = layout.box()
-        auth_box.label(text=text, icon=icon)
+        auth_box.label(text=text, icon=msg_icon)
 
         help_lines = textwrap.wrap(help_text, 80)
         for line in help_lines:
@@ -145,18 +253,18 @@ class BlenderCloudPreferences(AddonPreferences):
 
         # Texture browser stuff
         texture_box = layout.box()
-        texture_box.enabled = icon != 'ERROR'
+        texture_box.enabled = msg_icon != 'ERROR'
         sub = texture_box.column()
-        sub.label(text='Local directory for downloaded textures')
+        sub.label(text='Local directory for downloaded textures', icon_value=icon('CLOUD'))
         sub.prop(self, "local_texture_dir", text='Default')
         sub.prop(context.scene, "local_texture_dir", text='Current scene')
 
         # Blender Sync stuff
         bss = context.window_manager.blender_sync_status
         bsync_box = layout.box()
-        bsync_box.enabled = icon != 'ERROR'
+        bsync_box.enabled = msg_icon != 'ERROR'
         row = bsync_box.row().split(percentage=0.33)
-        row.label('Blender Sync with Blender Cloud')
+        row.label('Blender Sync with Blender Cloud', icon_value=icon('CLOUD'))
 
         icon_for_level = {
             'INFO': 'NONE',
@@ -164,16 +272,26 @@ class BlenderCloudPreferences(AddonPreferences):
             'ERROR': 'ERROR',
             'SUBSCRIBE': 'ERROR',
         }
-        icon = icon_for_level[bss.level] if bss.message else 'NONE'
+        msg_icon = icon_for_level[bss.level] if bss.message else 'NONE'
         message_container = row.row()
-        message_container.label(bss.message, icon=icon)
+        message_container.label(bss.message, icon=msg_icon)
 
         sub = bsync_box.column()
 
         if bss.level == 'SUBSCRIBE':
             self.draw_subscribe_button(sub)
-        else:
-            self.draw_sync_buttons(sub, bss)
+        self.draw_sync_buttons(sub, bss)
+
+        # Image Share stuff
+        share_box = layout.box()
+        share_box.label('Image Sharing on Blender Cloud', icon_value=icon('CLOUD'))
+        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'
+        self.draw_attract_buttons(attract_box, self.attract_project)
 
     def draw_subscribe_button(self, layout):
         layout.operator('pillar.subscribe', icon='WORLD')
@@ -209,12 +327,39 @@ class BlenderCloudPreferences(AddonPreferences):
         else:
             row_pull.label('Cloud Sync is running.')
 
+    def draw_attract_buttons(self, attract_box, bcp: BlenderCloudProjectGroup):
+        attract_row = attract_box.row(align=True)
+        attract_row.label('Attract', icon_value=icon('CLOUD'))
+
+        attract_row.enabled = bcp.status in {'NONE', 'IDLE'}
+        row_buttons = attract_row.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.')
+
+        attract_box.prop(self, 'attract_project_local_path')
+
 
 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)
 
     @classmethod
     def poll(cls, context):
@@ -259,6 +404,7 @@ class PILLAR_OT_subscribe(Operator):
     """Opens a browser to subscribe the user to the Cloud."""
     bl_idname = 'pillar.subscribe'
     bl_label = 'Subscribe to the Cloud'
+    bl_description = "Opens a page in a web browser to subscribe to the Blender Cloud"
 
     def execute(self, context):
         import webbrowser
@@ -269,15 +415,123 @@ class PILLAR_OT_subscribe(Operator):
         return {'FINISHED'}
 
 
+class PILLAR_OT_projects(async_loop.AsyncModalOperatorMixin,
+                         pillar.PillarOperatorMixin,
+                         Operator):
+    """Fetches the projects available to the user"""
+    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
 
 
+def load_custom_icons():
+    global icons
+
+    if icons is not None:
+        # Already loaded
+        return
+
+    import bpy.utils.previews
+    icons = bpy.utils.previews.new()
+    my_icons_dir = os.path.join(os.path.dirname(__file__), 'icons')
+    icons.load('CLOUD', os.path.join(my_icons_dir, 'icon-cloud.png'), 'IMAGE')
+
+
+def unload_custom_icons():
+    global icons
+
+    if icons is None:
+        # Already unloaded
+        return
+
+    bpy.utils.previews.remove(icons)
+    icons = None
+
+
+def icon(icon_name: str) -> int:
+    """Returns the icon ID for the named icon.
+
+    Use with layout.operator('pillar.image_share', icon_value=icon('CLOUD'))
+    """
+
+    return icons[icon_name].icon_id
+
+
 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()
 
@@ -299,14 +553,19 @@ def register():
 
     WindowManager.blender_sync_status = PointerProperty(type=SyncStatusProperties)
 
+    load_custom_icons()
+
 
 def unregister():
-    gui.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

@@ -0,0 +1,50 @@
+# ##### 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
+from pillarsdk import exceptions as sdk_exceptions
+from .pillar import pillar_call
+
+log = logging.getLogger(__name__)
+HOME_PROJECT_ENDPOINT = '/bcloud/home-project'
+
+
+async def get_home_project(params=None) -> pillarsdk.Project:
+    """Returns the home project."""
+
+    log.debug('Getting home project')
+    try:
+        return await pillar_call(pillarsdk.Project.find_from_endpoint,
+                                 HOME_PROJECT_ENDPOINT, params=params)
+    except sdk_exceptions.ForbiddenAccess:
+        log.warning('Access to the home project was denied. '
+                    'Double-check that you are logged in with valid BlenderID credentials.')
+        raise
+    except sdk_exceptions.ResourceNotFound:
+        log.warning('No home project available.')
+        raise
+
+
+async def get_home_project_id() -> str:
+    """Returns just the ID of the home project."""
+
+    home_proj = await get_home_project({'projection': {'_id': 1}})
+    home_proj_id = home_proj['_id']
+    return home_proj_id

blender_cloud/image_sharing.py

@@ -0,0 +1,334 @@
+# ##### 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
+import datetime
+
+import bpy
+import pillarsdk
+from pillarsdk import exceptions as sdk_exceptions
+from .pillar import pillar_call
+from . import async_loop, pillar, home_project, blender
+
+REQUIRES_ROLES_FOR_IMAGE_SHARING = {'subscriber', 'demo'}
+IMAGE_SHARING_GROUP_NODE_NAME = 'Image sharing'
+log = logging.getLogger(__name__)
+
+
+async def find_image_sharing_group_id(home_project_id, user_id):
+    # Find the top-level image sharing group node.
+    try:
+        share_group, created = await pillar.find_or_create_node(
+            where={'project': home_project_id,
+                   'node_type': 'group',
+                   'parent': None,
+                   'name': IMAGE_SHARING_GROUP_NODE_NAME},
+            additional_create_props={
+                'user': user_id,
+                'properties': {},
+            },
+            projection={'_id': 1},
+            may_create=True)
+    except pillar.PillarError:
+        log.exception('Pillar error caught')
+        raise pillar.PillarError('Unable to find image sharing folder on the Cloud')
+
+    return share_group['_id']
+
+
+class PILLAR_OT_image_share(pillar.PillarOperatorMixin,
+                            async_loop.AsyncModalOperatorMixin,
+                            bpy.types.Operator):
+    bl_idname = 'pillar.image_share'
+    bl_label = 'Share an image/screenshot via Blender Cloud'
+    bl_description = 'Uploads an image for sharing via Blender Cloud'
+
+    log = logging.getLogger('bpy.ops.%s' % bl_idname)
+
+    home_project_id = None
+    home_project_url = 'home'
+    share_group_id = None  # top-level share group node ID
+    user_id = None
+
+    target = bpy.props.EnumProperty(
+        items=[
+            ('FILE', 'File', 'Share an image file'),
+            ('DATABLOCK', 'Datablock', 'Share an image datablock'),
+            ('SCREENSHOT', 'Screenshot', 'Share a screenshot'),
+        ],
+        name='target',
+        default='SCREENSHOT')
+
+    name = bpy.props.StringProperty(name='name',
+                                    description='File or datablock name to sync')
+
+    screenshot_show_multiview = bpy.props.BoolProperty(
+        name='screenshot_show_multiview',
+        description='Enable Multi-View',
+        default=False)
+
+    screenshot_use_multiview = bpy.props.BoolProperty(
+        name='screenshot_use_multiview',
+        description='Use Multi-View',
+        default=False)
+
+    screenshot_full = bpy.props.BoolProperty(
+        name='screenshot_full',
+        description='Full Screen, Capture the whole window (otherwise only capture the active area)',
+        default=False)
+
+    def invoke(self, context, event):
+        # Do a quick test on datablock dirtyness. If it's not packed and dirty,
+        # the user should save it first.
+        if self.target == 'DATABLOCK':
+            if not self.name:
+                self.report({'ERROR'}, 'No name given of the datablock to share.')
+                return {'CANCELLED'}
+
+            datablock = bpy.data.images[self.name]
+            if datablock.type == 'IMAGE' and datablock.is_dirty and not datablock.packed_file:
+                self.report({'ERROR'}, 'Datablock is dirty, save it first.')
+                return {'CANCELLED'}
+
+        return async_loop.AsyncModalOperatorMixin.invoke(self, context, event)
+
+    async def async_execute(self, context):
+        """Entry point of the asynchronous operator."""
+
+        self.report({'INFO'}, 'Communicating with Blender Cloud')
+
+        try:
+            # Refresh credentials
+            try:
+                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.UserNotLoggedInError:
+                self.log.exception('Error checking/refreshing credentials.')
+                self.report({'ERROR'}, 'Please log in on Blender ID first.')
+                self._state = 'QUIT'
+                return
+
+            # Find the home project.
+            try:
+                home_proj = await home_project.get_home_project({
+                    'projection': {'_id': 1, 'url': 1}
+                })
+            except sdk_exceptions.ForbiddenAccess:
+                self.log.exception('Forbidden access to home project.')
+                self.report({'ERROR'}, 'Did not get access to home project.')
+                self._state = 'QUIT'
+                return
+            except sdk_exceptions.ResourceNotFound:
+                self.report({'ERROR'}, 'Home project not found.')
+                self._state = 'QUIT'
+                return
+
+            self.home_project_id = home_proj['_id']
+            self.home_project_url = home_proj['url']
+
+            try:
+                gid = await find_image_sharing_group_id(self.home_project_id,
+                                                        self.user_id)
+                self.share_group_id = gid
+                self.log.debug('Found group node ID: %s', self.share_group_id)
+            except sdk_exceptions.ForbiddenAccess:
+                self.log.exception('Unable to find Group ID')
+                self.report({'ERROR'}, 'Unable to find sync folder.')
+                self._state = 'QUIT'
+                return
+
+            await self.share_image(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 share_image(self, context):
+        """Sends files to the Pillar server."""
+
+        if self.target == 'FILE':
+            self.report({'INFO'}, "Uploading %s '%s'" % (self.target.lower(), self.name))
+            node = await self.upload_file(self.name)
+        elif self.target == 'SCREENSHOT':
+            node = await self.upload_screenshot(context)
+        else:
+            self.report({'INFO'}, "Uploading %s '%s'" % (self.target.lower(), self.name))
+            node = await self.upload_datablock(context)
+
+        self.report({'INFO'}, 'Upload complete, creating link to share.')
+        share_info = await pillar_call(node.share)
+        url = share_info.get('short_link')
+        context.window_manager.clipboard = url
+        self.report({'INFO'}, 'The link has been copied to your clipboard: %s' % url)
+
+        await self.maybe_open_browser(url)
+
+    async def upload_file(self, filename: str, fileobj=None) -> pillarsdk.Node:
+        """Uploads a file to the cloud, attached to the image sharing node.
+
+        Returns the node.
+        """
+
+        self.log.info('Uploading file %s', filename)
+        node = await pillar_call(pillarsdk.Node.create_asset_from_file,
+                                 self.home_project_id,
+                                 self.share_group_id,
+                                 'image',
+                                 filename,
+                                 extra_where={'user': self.user_id},
+                                 always_create_new_node=True,
+                                 fileobj=fileobj,
+                                 caching=False)
+        node_id = node['_id']
+        self.log.info('Created node %s', node_id)
+        self.report({'INFO'}, 'File succesfully uploaded to the cloud!')
+
+        return node
+
+    async def maybe_open_browser(self, url):
+        prefs = blender.preferences()
+        if not prefs.open_browser_after_share:
+            return
+
+        import webbrowser
+
+        self.log.info('Opening browser at %s', url)
+        webbrowser.open_new_tab(url)
+
+    async def upload_datablock(self, context) -> pillarsdk.Node:
+        """Saves a datablock to file if necessary, then upload.
+
+        Returns the node.
+        """
+
+        self.log.info("Uploading datablock '%s'" % self.name)
+        datablock = bpy.data.images[self.name]
+
+        if datablock.type == 'RENDER_RESULT':
+            # Construct a sensible name for this render.
+            filename = '%s-%s-render%s' % (
+                os.path.splitext(os.path.basename(context.blend_data.filepath))[0],
+                context.scene.name,
+                context.scene.render.file_extension)
+            return await self.upload_via_tempdir(datablock, filename)
+
+        if datablock.packed_file is not None:
+            return await self.upload_packed_file(datablock)
+
+        if datablock.is_dirty:
+            # We can handle dirty datablocks like this if we want.
+            # However, I (Sybren) do NOT think it's a good idea to:
+            # - Share unsaved data to the cloud; users can assume it's saved
+            #   to disk and close blender, losing their file.
+            # - Save unsaved data first; this can overwrite a file a user
+            #   didn't want to overwrite.
+            filename = bpy.path.basename(datablock.filepath)
+            return await self.upload_via_tempdir(datablock, filename)
+
+        filepath = bpy.path.abspath(datablock.filepath)
+        return await self.upload_file(filepath)
+
+    async def upload_via_tempdir(self, datablock, filename_on_cloud) -> pillarsdk.Node:
+        """Saves the datablock to file, and uploads it to the cloud.
+
+        Saving is done to a temporary directory, which is removed afterwards.
+
+        Returns the node.
+        """
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            filepath = os.path.join(tmpdir, filename_on_cloud)
+            self.log.debug('Saving %s to %s', datablock, filepath)
+            datablock.save_render(filepath)
+            return await self.upload_file(filepath)
+
+    async def upload_packed_file(self, datablock) -> pillarsdk.Node:
+        """Uploads a packed file directly from memory.
+
+        Returns the node.
+        """
+
+        import io
+
+        filename = '%s.%s' % (datablock.name, datablock.file_format.lower())
+        fileobj = io.BytesIO(datablock.packed_file.data)
+        fileobj.seek(0)  # ensure PillarSDK reads the file from the beginning.
+        self.log.info('Uploading packed file directly from memory to %r.', filename)
+        return await self.upload_file(filename, fileobj=fileobj)
+
+    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.report({'INFO'}, "Uploading %s '%s'" % (self.target.lower(), self.name))
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            filepath = os.path.join(tmpdir, self.name)
+            self.log.debug('Saving screenshot to %s', filepath)
+            bpy.ops.screen.screenshot(filepath=filepath,
+                                      show_multiview=self.screenshot_show_multiview,
+                                      use_multiview=self.screenshot_use_multiview,
+                                      full=self.screenshot_full)
+            return await self.upload_file(filepath)
+
+
+def image_editor_menu(self, context):
+    image = context.space_data.image
+
+    box = self.layout.row()
+    if image and image.has_data:
+        text = 'Share on Blender Cloud'
+        if image.type == 'IMAGE' and image.is_dirty and not image.packed_file:
+            box.enabled = False
+            text = 'Save image before sharing on Blender Cloud'
+
+        props = box.operator(PILLAR_OT_image_share.bl_idname, text=text,
+                             icon_value=blender.icon('CLOUD'))
+        props.target = 'DATABLOCK'
+        props.name = image.name
+
+
+def window_menu(self, context):
+    props = self.layout.operator(PILLAR_OT_image_share.bl_idname,
+                                 text='Share screenshot via Blender Cloud',
+                                 icon_value=blender.icon('CLOUD'))
+    props.target = 'SCREENSHOT'
+    props.screenshot_full = True
+
+
+def register():
+    bpy.utils.register_class(PILLAR_OT_image_share)
+
+    bpy.types.IMAGE_MT_image.append(image_editor_menu)
+    bpy.types.INFO_MT_window.append(window_menu)
+
+
+def unregister():
+    bpy.utils.unregister_class(PILLAR_OT_image_share)
+
+    bpy.types.IMAGE_MT_image.remove(image_editor_menu)
+    bpy.types.INFO_MT_window.remove(window_menu)

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, caching=True, **kwargs):
+    """Synchronous call to Pillar, ensures the correct Api object is used."""
+
+    return pillar_func(*args, api=pillar_api(caching=caching), **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
@@ -260,7 +307,7 @@ async def get_project_uuid(project_url: str) -> str:
 
 
 async def get_nodes(project_uuid: str = None, parent_node_uuid: str = None,
-                    node_type=None) -> list:
+                    node_type=None, max_results=None) -> list:
     """Gets nodes for either a project or given a parent node.
 
     @param project_uuid: the UUID of the project, or None if only querying by parent_node_uuid.
@@ -288,25 +335,37 @@ 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)}
 
-    children = await pillar_call(pillarsdk.Node.all, {
-        'projection': {'name': 1, 'parent': 1, 'node_type': 1,
-                       'properties.order': 1, 'properties.status': 1,
-                       'properties.files': 1,
-                       'properties.content_type': 1, 'picture': 1},
-        'where': where,
-        'embed': ['parent']})
+    params = {'projection': {'name': 1, 'parent': 1, 'node_type': 1, 'properties.order': 1,
+                             'properties.status': 1, 'properties.files': 1,
+                             'properties.content_type': 1, 'picture': 1},
+              'where': where,
+              'embed': ['parent']}
+
+    # Pagination
+    if max_results:
+        params['max_results'] = int(max_results)
+
+    children = await pillar_call(pillarsdk.Node.all, params)
 
     return children['_items']
 
 
-async def get_texture_projects() -> list:
+async def get_texture_projects(max_results=None) -> list:
     """Returns project dicts that contain textures."""
 
+    params = {}
+
+    # Pagination
+    if max_results:
+        params['max_results'] = int(max_results)
+
     try:
         children = await pillar_call(pillarsdk.Project.all_from_endpoint,
-                                     '/bcloud/texture-libraries')
+                                     '/bcloud/texture-libraries',
+                                     params=params)
     except pillarsdk.ResourceNotFound as ex:
         log.warning('Unable to find texture projects: %s', ex)
         raise PillarError('Unable to find texture projects: %s' % ex)
@@ -461,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')
@@ -487,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):
@@ -515,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:
@@ -544,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
@@ -561,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)
@@ -578,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',
@@ -587,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,
@@ -599,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)
 
@@ -664,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
@@ -680,23 +816,99 @@ 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(
             'Please subscribe to the blender cloud at https://cloud.blender.org/join')
         self.report({'INFO'},
                     'Please subscribe to the blender cloud at https://cloud.blender.org/join')
+
+
+async def find_or_create_node(where: dict,
+                              additional_create_props: dict = None,
+                              projection: dict = None,
+                              may_create: bool = True) -> (pillarsdk.Node, bool):
+    """Finds a node by the `filter_props`, creates it using the additional props.
+
+    :returns: tuple (node, created), where 'created' is a bool indicating whether
+              a new node was created, or an exising one is returned.
+    """
+
+    params = {
+        'where': where,
+    }
+    if projection:
+        params['projection'] = projection
+
+    found_node = await pillar_call(pillarsdk.Node.find_first, params, caching=False)
+
+    if found_node is not None:
+        return found_node, False
+
+    if not may_create:
+        return None, False
+
+    # Augment the node properties to form a complete node.
+    node_props = where.copy()
+    if additional_create_props:
+        node_props.update(additional_create_props)
+
+    log.debug('Creating new node %s', node_props)
+    created_node = pillarsdk.Node.new(node_props)
+    created_ok = await pillar_call(created_node.create)
+    if not created_ok:
+        log.error('Blender Cloud addon: unable to create node on the Cloud.')
+        raise PillarError('Unable to create node on the Cloud')
+
+    return created_node, True
+
+
+async def attach_file_to_group(file_path: pathlib.Path,
+                               home_project_id: str,
+                               group_node_id: str,
+                               user_id: str = None) -> pillarsdk.Node:
+    """Creates an Asset node and attaches a file document to it."""
+
+    node = await pillar_call(pillarsdk.Node.create_asset_from_file,
+                             home_project_id,
+                             group_node_id,
+                             'file',
+                             str(file_path),
+                             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
@@ -16,7 +34,7 @@ import asyncio
 import pillarsdk
 from pillarsdk import exceptions as sdk_exceptions
 from .pillar import pillar_call
-from . import async_loop, pillar, cache, blendfile
+from . import async_loop, pillar, cache, blendfile, home_project
 
 SETTINGS_FILES_TO_UPLOAD = ['userpref.blend', 'startup.blend']
 
@@ -40,7 +58,6 @@ LOCAL_SETTINGS_RNA = [
 ]
 
 REQUIRES_ROLES_FOR_SYNC = set()  # no roles needed.
-HOME_PROJECT_ENDPOINT = '/bcloud/home-project'
 SYNC_GROUP_NODE_NAME = 'Blender Sync'
 SYNC_GROUP_NODE_DESC = 'The [Blender Cloud Addon](https://cloud.blender.org/services' \
                        '#blender-addon) will synchronize your Blender settings here.'
@@ -79,28 +96,6 @@ def async_set_blender_sync_status(set_status: str):
     return decorator
 
 
-async def get_home_project(params=None) -> pillarsdk.Project:
-    """Returns the home project."""
-
-    log.debug('Getting home project')
-    try:
-        return await pillar_call(pillarsdk.Project.find_from_endpoint,
-                                 HOME_PROJECT_ENDPOINT, params=params)
-    except sdk_exceptions.ForbiddenAccess:
-        log.warning('Access to the home project was denied. '
-                    'Double-check that you are logged in with valid BlenderID credentials.')
-        raise
-    except sdk_exceptions.ResourceNotFound:
-        log.warning('No home project available.')
-        raise
-
-
-async def get_home_project_id():
-    home_proj = await get_home_project({'projection': {'_id': 1}})
-    home_proj_id = home_proj['_id']
-    return home_proj_id
-
-
 async def find_sync_group_id(home_project_id: str,
                              user_id: str,
                              blender_version: str,
@@ -114,7 +109,7 @@ async def find_sync_group_id(home_project_id: str,
     # Find the top-level sync group node. This should have been
     # created by Pillar while creating the home project.
     try:
-        sync_group, created = await find_or_create_node(
+        sync_group, created = await pillar.find_or_create_node(
             where={'project': home_project_id,
                    'node_type': 'group',
                    'parent': None,
@@ -131,7 +126,7 @@ async def find_sync_group_id(home_project_id: str,
 
     # Find/create the sub-group for the requested Blender version
     try:
-        sub_sync_group, created = await find_or_create_node(
+        sub_sync_group, created = await pillar.find_or_create_node(
             where={'project': home_project_id,
                    'node_type': 'group',
                    'parent': sync_group['_id'],
@@ -154,84 +149,6 @@ async def find_sync_group_id(home_project_id: str,
     return sync_group['_id'], sub_sync_group['_id']
 
 
-async def find_or_create_node(where: dict,
-                              additional_create_props: dict = None,
-                              projection: dict = None,
-                              may_create: bool = True) -> (pillarsdk.Node, bool):
-    """Finds a node by the `filter_props`, creates it using the additional props.
-
-    :returns: tuple (node, created), where 'created' is a bool indicating whether
-              a new node was created, or an exising one is returned.
-    """
-
-    params = {
-        'where': where,
-    }
-    if projection:
-        params['projection'] = projection
-
-    found_node = await pillar_call(pillarsdk.Node.find_first, params, caching=False)
-
-    created = False
-    if found_node is None:
-        if not may_create:
-            return None, False
-
-        log.info('Creating new sync group node')
-
-        # Augment the node properties to form a complete node.
-        node_props = where.copy()
-        if additional_create_props:
-            node_props.update(additional_create_props)
-
-        found_node = pillarsdk.Node.new(node_props)
-        created_ok = await pillar_call(found_node.create)
-        if not created_ok:
-            log.error('Blender Cloud addon: unable to create node on the Cloud.')
-            raise pillar.PillarError('Unable to create node on the Cloud')
-        created = True
-
-    return found_node, created
-
-
-async def attach_file_to_group(file_path: pathlib.Path,
-                               home_project_id: str,
-                               group_node_id: str,
-                               user_id: str,
-                               *,
-                               future=None) -> pillarsdk.Node:
-    """Creates an Asset node and attaches a file document to it."""
-
-    # First upload the file...
-    file_id = await pillar.upload_file(home_project_id, file_path,
-                                       future=future)
-
-    # Then attach it to a node.
-    node, created = await find_or_create_node(
-        where={
-            'project': home_project_id,
-            'node_type': 'asset',
-            'parent': group_node_id,
-            'name': file_path.name,
-            'user': user_id},
-        additional_create_props={
-            'properties': {'file': file_id},
-        })
-
-    if not created:
-        # Update the existing node.
-        node.properties = {'file': file_id}
-        updated_ok = await pillar_call(node.update)
-        if not updated_ok:
-            log.error(
-                'Blender Cloud addon: unable to update asset node on the Cloud for file %s.',
-                file_path)
-            raise pillar.PillarError(
-                'Unable to update asset node on the Cloud for file %s' % file_path.name)
-
-    return node
-
-
 @functools.lru_cache()
 async def available_blender_versions(home_project_id: str, user_id: str) -> list:
     bss = bpy.context.window_manager.blender_sync_status
@@ -317,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.
@@ -368,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'
@@ -383,7 +297,7 @@ class PILLAR_OT_sync(pillar.PillarOperatorMixin,
 
             # Find the home project.
             try:
-                self.home_project_id = await get_home_project_id()
+                self.home_project_id = await home_project.get_home_project_id()
             except sdk_exceptions.ForbiddenAccess:
                 self.log.exception('Forbidden access to home project.')
                 self.bss_report({'ERROR'}, 'Did not get access to home project.')
@@ -439,12 +353,23 @@ class PILLAR_OT_sync(pillar.PillarOperatorMixin,
                 self.log.debug('Skipping non-existing %s', path)
                 continue
 
+            if self.signalling_future.cancelled():
+                self.bss_report({'WARNING'}, 'Upload aborted.')
+                return
+
             self.bss_report({'INFO'}, 'Uploading %s' % fname)
-            await attach_file_to_group(path,
-                                       self.home_project_id,
-                                       self.sync_group_versioned_id,
-                                       self.user_id,
-                                       future=self.signalling_future)
+            try:
+                await pillar.attach_file_to_group(path,
+                                                  self.home_project_id,
+                                                  self.sync_group_versioned_id,
+                                                  self.user_id)
+            except sdk_exceptions.RequestEntityTooLarge as ex:
+                self.log.error('File too big to upload: %s' % ex)
+                self.log.error('To upload larger files, please subscribe to Blender Cloud.')
+                self.bss_report({'SUBSCRIBE'}, 'File %s too big to upload. '
+                                               'Subscribe for unlimited space.' % fname)
+                self._state = 'QUIT'
+                return
 
         await self.action_refresh(context)
 
@@ -517,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,65 +1,72 @@
 # ##### 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
+import os
 
 import bpy
 import bgl
 import blf
-import os
 
 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
 
-icon_width = 128
-icon_height = 128
-target_item_width = 400
-target_item_height = 128
+ICON_WIDTH = 128
+ICON_HEIGHT = 128
+TARGET_ITEM_WIDTH = 400
+TARGET_ITEM_HEIGHT = 128
+ITEM_MARGIN_X = 5
+ITEM_MARGIN_Y = 5
+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:
@@ -77,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__)
@@ -93,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.
@@ -120,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)
@@ -130,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']:
@@ -139,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."""
 
@@ -179,11 +201,11 @@ class MenuItem:
         bgl.glTexCoord2d(0, 0)
         bgl.glVertex2d(self.x + self.icon_margin_x, self.y)
         bgl.glTexCoord2d(0, 1)
-        bgl.glVertex2d(self.x + self.icon_margin_x, self.y + icon_height)
+        bgl.glVertex2d(self.x + self.icon_margin_x, self.y + ICON_HEIGHT)
         bgl.glTexCoord2d(1, 1)
-        bgl.glVertex2d(self.x + self.icon_margin_x + icon_width, self.y + icon_height)
+        bgl.glVertex2d(self.x + self.icon_margin_x + ICON_WIDTH, self.y + ICON_HEIGHT)
         bgl.glTexCoord2d(1, 0)
-        bgl.glVertex2d(self.x + self.icon_margin_x + icon_width, self.y)
+        bgl.glVertex2d(self.x + self.icon_margin_x + ICON_WIDTH, self.y)
         bgl.glEnd()
         bgl.glDisable(bgl.GL_TEXTURE_2D)
         bgl.glDisable(bgl.GL_BLEND)
@@ -193,8 +215,8 @@ class MenuItem:
         # draw some text
         font_id = 0
         blf.position(font_id,
-                     self.x + self.icon_margin_x + icon_width + self.text_margin_x,
-                     self.y + icon_height * 0.5 - 0.25 * self.text_height, 0)
+                     self.x + self.icon_margin_x + ICON_WIDTH + self.text_margin_x,
+                     self.y + ICON_HEIGHT * 0.5 - 0.25 * self.text_height, 0)
         blf.size(font_id, self.text_height, self.text_width)
         blf.draw(font_id, self.label_text)
 
@@ -216,21 +238,29 @@ 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
 
     mouse_x = 0
     mouse_y = 0
+    scroll_offset = 0
+    scroll_offset_target = 0
+    scroll_offset_max = 0
+    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'}
@@ -256,12 +286,10 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
 
         self.current_display_content = []
         self.loaded_images = set()
+        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)
@@ -273,6 +301,7 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
             async_loop.ensure_async_loop()
 
         if event.type == 'TIMER':
+            self._scroll_smooth()
             context.area.tag_redraw()
             return {'RUNNING_MODAL'}
 
@@ -291,24 +320,37 @@ 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')
 
+            # Scrolling
+            if event.type == 'WHEELUPMOUSE':
+                self._scroll_by(MOUSE_SCROLL_PIXELS_PER_TICK)
+                context.area.tag_redraw()
+            elif event.type == 'WHEELDOWNMOUSE':
+                self._scroll_by(-MOUSE_SCROLL_PIXELS_PER_TICK)
+                context.area.tag_redraw()
+            elif event.type == 'TRACKPADPAN':
+                self._scroll_by(event.mouse_prev_y - event.mouse_y,
+                                smooth=False)
+                context.area.tag_redraw()
+
             if left_mouse_release:
                 if selected is None:
                     # 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'}:
@@ -322,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()
@@ -339,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):
@@ -353,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:
@@ -363,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()
 
@@ -417,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
@@ -442,12 +488,7 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
         self.log.info('Asynchronously downloading previews to %r', thumbnails_directory)
         self.log.info('Current BCloud path is %r', self.current_path)
         self.clear_images()
-
-        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'])
+        self._scroll_reset()
 
         project_uuid = self.current_path.project_uuid
         node_uuid = self.current_path.node_uuid
@@ -456,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')
@@ -492,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,
@@ -534,36 +582,49 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
     def _draw_browser(self, context):
         """OpenGL drawing code for the BROWSING state."""
 
-        margin_x = 5
-        margin_y = 5
-        padding_x = 5
-
         window_region = self._window_region(context)
-        content_width = window_region.width - margin_x * 2
-        content_height = window_region.height - margin_y * 2
+        content_width = window_region.width - ITEM_MARGIN_X * 2
+        content_height = window_region.height - ITEM_MARGIN_Y * 2
 
-        content_x = margin_x
-        content_y = context.area.height - margin_y - target_item_height
+        content_x = ITEM_MARGIN_X
+        content_y = context.area.height - ITEM_MARGIN_Y - TARGET_ITEM_HEIGHT
 
-        col_count = content_width // target_item_width
+        col_count = content_width // TARGET_ITEM_WIDTH
 
-        item_width = (content_width - (col_count * padding_x)) / col_count
-        item_height = target_item_height
+        item_width = (content_width - (col_count * ITEM_PADDING_X)) / col_count
+        item_height = TARGET_ITEM_HEIGHT
 
-        block_width = item_width + padding_x
-        block_height = item_height + margin_y
+        block_width = item_width + ITEM_PADDING_X
+        block_height = item_height + ITEM_MARGIN_Y
 
         bgl.glEnable(bgl.GL_BLEND)
         bgl.glColor4f(0.0, 0.0, 0.0, 0.6)
         bgl.glRectf(0, 0, window_region.width, window_region.height)
 
         if self.current_display_content:
+            bottom_y = float('inf')
+
+            # The -1 / +2 are for extra rows that are drawn only half at the top/bottom.
+            first_item_idx = max(0, int(-self.scroll_offset // block_height - 1) * col_count)
+            items_per_page = int(content_height // item_height + 2) * col_count
+            last_item_idx = first_item_idx + items_per_page
+
             for item_idx, item in enumerate(self.current_display_content):
                 x = content_x + (item_idx % col_count) * block_width
-                y = content_y - (item_idx // col_count) * block_height
+                y = content_y - (item_idx // col_count) * block_height - self.scroll_offset
 
                 item.update_placement(x, y, item_width, item_height)
-                item.draw(highlighted=item.hits(self.mouse_x, self.mouse_y))
+
+                if first_item_idx <= item_idx < last_item_idx:
+                    # Only draw if the item is actually on screen.
+                    item.draw(highlighted=item.hits(self.mouse_x, self.mouse_y))
+
+                bottom_y = min(y, bottom_y)
+            self.scroll_offset_space_left = window_region.height - bottom_y
+            self.scroll_offset_max = (self.scroll_offset -
+                                      self.scroll_offset_space_left +
+                                      0.25 * block_height)
+
         else:
             font_id = 0
             text = "Communicating with Blender Cloud"
@@ -684,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,
@@ -714,20 +805,209 @@ class BlenderCloudBrowser(pillar.PillarOperatorMixin,
 
         self.report({'INFO'}, 'We just started a browser for you.')
 
+    def _scroll_smooth(self):
+        diff = self.scroll_offset_target - self.scroll_offset
+        if diff == 0:
+            return
+
+        if abs(round(diff)) < 1:
+            self.scroll_offset = self.scroll_offset_target
+            return
+
+        self.scroll_offset += diff * 0.5
+
+    def _scroll_by(self, amount, *, smooth=True):
+        # Slow down scrolling up
+        if smooth and amount < 0 and -amount > self.scroll_offset_space_left / 4:
+            amount = -self.scroll_offset_space_left / 4
+
+        self.scroll_offset_target = min(0,
+                                        max(self.scroll_offset_max,
+                                            self.scroll_offset_target + amount))
+
+        if not smooth:
+            self._scroll_offset = self.scroll_offset_target
+
+    def _scroll_reset(self):
+        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
@@ -747,5 +1027,11 @@ def unregister():
         km.keymap_items.remove(kmi)
     addon_keymaps.clear()
 
-    if 'bl_rna' in BlenderCloudBrowser.__dict__:   # <-- check if we already removed!
-        bpy.utils.unregister_class(BlenderCloudBrowser)
+    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,64 @@
+# ##### 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 pathlib
+
+
+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)
+
+
+def find_in_path(path: pathlib.Path, filename: str) -> pathlib.Path:
+    """Performs a breadth-first search for the filename.
+
+    Returns the path that contains the file, or None if not found.
+    """
+
+    import collections
+
+    # Be lenient on our input type.
+    if isinstance(path, str):
+        path = pathlib.Path(path)
+
+    if not path.exists():
+        return None
+    assert path.is_dir()
+
+    to_visit = collections.deque([path])
+    while to_visit:
+        this_path = to_visit.popleft()
+
+        for subpath in this_path.iterdir():
+            if subpath.is_dir():
+                to_visit.append(subpath)
+                continue
+
+            if subpath.name == filename:
+                return subpath
+
+    return None

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-dev.txt

@@ -0,0 +1,8 @@
+-r requirements.txt
+
+# Primary requirements
+pytest==3.0.3
+
+# Secondary requirements
+py==1.4.31
+

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.3.0
+pillarsdk==1.6.1
 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.2.2',
+    version='1.4.999',
     author='Sybren A. Stüvel',
     author_email='sybren@stuvel.eu',
     packages=find_packages('.'),

tests/test_utils.py

@@ -0,0 +1,25 @@
+"""Unittests for blender_cloud.utils."""
+
+import pathlib
+import unittest
+
+from blender_cloud import utils
+
+
+class FindInPathTest(unittest.TestCase):
+    def test_nonexistant_path(self):
+        path = pathlib.Path('/doesnotexistreally')
+        self.assertFalse(path.exists())
+        self.assertIsNone(utils.find_in_path(path, 'jemoeder.blend'))
+
+    def test_really_breadth_first(self):
+        """A depth-first test might find dir_a1/dir_a2/dir_a3/find_me.txt first."""
+
+        path = pathlib.Path(__file__).parent / 'test_really_breadth_first'
+        found = utils.find_in_path(path, 'find_me.txt')
+        self.assertEqual(path / 'dir_b1' / 'dir_b2' / 'find_me.txt', found)
+
+    def test_nonexistant_file(self):
+        path = pathlib.Path(__file__).parent / 'test_really_breadth_first'
+        found = utils.find_in_path(path, 'do_not_find_me.txt')
+        self.assertEqual(None, found)