@sequent-org/moodboard 1.0.23 → 1.1.0

package/src/tools/object-tools/SelectTool.js

@@ -4,7 +4,7 @@ import { ResizeHandles } from '../ResizeHandles.js';
 import * as PIXI from 'pixi.js';
 import { Events } from '../../core/events/Events.js';
 import { SelectionModel } from './selection/SelectionModel.js';
-import { HandlesSync } from './selection/HandlesSync.js';
+// import { HandlesSync } from './selection/HandlesSync.js';
 import { SimpleDragController } from './selection/SimpleDragController.js';
 import { ResizeController } from './selection/ResizeController.js';
 import { RotateController } from './selection/RotateController.js';
@@ -149,12 +149,10 @@ export class SelectTool extends BaseTool {
         // Инициализируем систему ручек изменения размера
         if (!this.resizeHandles && app) {
             this.resizeHandles = new ResizeHandles(app);
-            this._handlesSync = new HandlesSync({
-                app,
-                resizeHandles: this.resizeHandles,
-                selection: this.selection,
-                emit: (event, payload) => this.emit(event, payload)
-            });
+            // Полностью отключаем синхронизацию старых PIXI-ручек
+            if (this.resizeHandles && typeof this.resizeHandles.hideHandles === 'function') {
+                this.resizeHandles.hideHandles();
+            }
             this._dragCtrl = new SimpleDragController({
                 emit: (event, payload) => this.emit(event, payload)
             });
@@ -283,17 +281,77 @@ export class SelectTool extends BaseTool {
                 this.startBoxSelect(event);
             }
         } else if (hitResult.type === 'object') {
-            // Начинаем обычный drag исходника; Alt-режим включим на лету при движении
+            // Особая логика для фреймов: если у фрейма есть дети и клик внутри внутренней области (без 20px рамки),
+            // то не начинаем drag фрейма, а запускаем box-select для выбора объектов внутри
+            const req = { objectId: hitResult.object, pixiObject: null };
+            this.emit(Events.Tool.GetObjectPixi, req);
+            const mbType = req.pixiObject && req.pixiObject._mb && req.pixiObject._mb.type;
+            if (mbType === 'frame') {
+                // Получаем данные фрейма и его экранные границы
+                const objects = this.core?.state?.getObjects ? this.core.state.getObjects() : [];
+                const frameObj = objects.find(o => o.id === hitResult.object);
+                const hasChildren = !!(objects && objects.some(o => o.properties && o.properties.frameId === hitResult.object));
+                if (req.pixiObject && hasChildren && frameObj) {
+                    const bounds = req.pixiObject.getBounds(); // экранные координаты
+                    const inner = { x: bounds.x + 20, y: bounds.y + 20, width: Math.max(0, bounds.width - 40), height: Math.max(0, bounds.height - 40) };
+                    const insideInner = this.isPointInBounds({ x: event.x, y: event.y }, inner);
+                    // Если клик внутри внутренней области — запускаем box-select и выходим
+                    if (insideInner) {
+                        // Запускаем рамку выделения вместо drag фрейма
+                        this.startBoxSelect(event);
+                        return;
+                    }
+                    // Если клик на 20px рамке — позволяем перетягивать фрейм. Но запрещаем box-select от рамки.
+                    // Здесь ничего не делаем: ниже пойдёт обычная логика handleObjectSelect
+                }
+            }
+            // Обычная логика: начинаем drag выбранного объекта
             this.handleObjectSelect(hitResult.object, event);
         } else {
             // Клик по пустому месту — если есть одиночное выделение, разрешаем drag за пределами объекта в пределах рамки
             if (this.selection.size() === 1) {
                 const selId = this.selection.toArray()[0];
+                // Если выбран фрейм с детьми и клик внутри внутренней области — не начинаем drag, а box-select
+                const req = { objectId: selId, pixiObject: null };
+                this.emit(Events.Tool.GetObjectPixi, req);
+                const isFrame = !!(req.pixiObject && req.pixiObject._mb && req.pixiObject._mb.type === 'frame');
+                if (isFrame) {
+                    const objects = this.core?.state?.getObjects ? this.core.state.getObjects() : [];
+                    const frameObj = objects.find(o => o.id === selId);
+                    const hasChildren = !!(objects && objects.some(o => o.properties && o.properties.frameId === selId));
+                    if (frameObj && hasChildren) {
+                        const b = { x: frameObj.position.x, y: frameObj.position.y, width: frameObj.width || 0, height: frameObj.height || 0 };
+                        const inner = { x: b.x + 20, y: b.y + 20, width: Math.max(0, b.width - 40), height: Math.max(0, b.height - 40) };
+                        const insideInner = this.isPointInBounds({ x: event.x, y: event.y }, inner);
+                        if (insideInner) {
+                            this.startBoxSelect(event);
+                            return;
+                        }
+                    }
+                }
+                // Обычная логика: если клик внутри рамки выбранного — начинаем drag
                 const boundsReq = { objects: [] };
                 this.emit(Events.Tool.GetAllObjects, boundsReq);
                 const map = new Map(boundsReq.objects.map(o => [o.id, o.bounds]));
                 const b = map.get(selId);
                 if (b && this.isPointInBounds({ x: event.x, y: event.y }, b)) {
+                    // Для фрейма c детьми: отфильтруем клики внутри внутренней области (box-select)
+                    const req2 = { objectId: selId, pixiObject: null };
+                    this.emit(Events.Tool.GetObjectPixi, req2);
+                    const isFrame2 = !!(req2.pixiObject && req2.pixiObject._mb && req2.pixiObject._mb.type === 'frame');
+                    if (isFrame2) {
+                        const os = this.core?.state?.getObjects ? this.core.state.getObjects() : [];
+                        const fr = os.find(o => o.id === selId);
+                        const hasChildren2 = !!(os && os.some(o => o.properties && o.properties.frameId === selId));
+                        if (req2.pixiObject && fr && hasChildren2) {
+                            const bounds2 = req2.pixiObject.getBounds();
+                            const inner2 = { x: bounds2.x + 20, y: bounds2.y + 20, width: Math.max(0, bounds2.width - 40), height: Math.max(0, bounds2.height - 40) };
+                            if (this.isPointInBounds({ x: event.x, y: event.y }, inner2)) {
+                                this.startBoxSelect(event);
+                                return;
+                            }
+                        }
+                    }
                     // Старт перетаскивания как если бы кликнули по объекту
                     this.startDrag(selId, event);
                     return;
@@ -614,12 +672,23 @@ export class SelectTool extends BaseTool {
     startDrag(objectId, event) {
         this.isDragging = true;
         this.dragTarget = objectId;
+        // Сообщаем HtmlHandlesLayer о начале перетаскивания одиночного объекта
+        this.emit(Events.Tool.DragStart, { object: objectId });
         
         // Получаем текущую позицию объекта
         const objectData = { objectId, position: null };
         this.emit(Events.Tool.GetObjectPosition, objectData);
         // Нормализуем координаты в мировые (worldLayer), чтобы убрать влияние зума
         const w = this._toWorld(event.x, event.y);
+        // Запоминаем смещение точки захвата курсора относительно левого-верхнего угла объекта (в мировых координатах)
+        if (objectData.position) {
+            this._dragGrabOffset = {
+                x: w.x - objectData.position.x,
+                y: w.y - objectData.position.y
+            };
+        } else {
+            this._dragGrabOffset = null;
+        }
         const worldEvent = { ...event, x: w.x, y: w.y };
         if (this._dragCtrl) this._dragCtrl.start(objectId, worldEvent);
     }
@@ -639,13 +708,14 @@ export class SelectTool extends BaseTool {
             this.isAltCloneMode = true;
             this.cloneSourceId = this.dragTarget;
             this.clonePending = true;
-            // Запрашиваем текущую позицию исходного объекта
-            const positionData = { objectId: this.cloneSourceId, position: null };
-            this.emit(Events.Tool.GetObjectPosition, positionData);
-            // Сообщаем ядру о необходимости создать дубликат у позиции исходного объекта
+            // Создаём дубликат так, чтобы курсор захватывал ту же точку объекта
+            const wpos = this._toWorld(event.x, event.y);
+            const targetTopLeft = this._dragGrabOffset
+                ? { x: wpos.x - this._dragGrabOffset.x, y: wpos.y - this._dragGrabOffset.y }
+                : { x: wpos.x, y: wpos.y };
             this.emit(Events.Tool.DuplicateRequest, {
                 originalId: this.cloneSourceId,
-                position: positionData.position || { x: event.x, y: event.y }
+                position: targetTopLeft
             });
             // Не сбрасываем dragTarget, чтобы исходник продолжал двигаться до появления копии
             // Визуально это ок: копия появится и захватит drag в onDuplicateReady
@@ -657,6 +727,13 @@ export class SelectTool extends BaseTool {
             const w = this._toWorld(event.x, event.y);
             this._dragCtrl.update({ ...event, x: w.x, y: w.y });
         }
+        // Сообщаем о процессе перетаскивания (с текущей позицией объекта)
+        if (this.isDragging && this.dragTarget) {
+            // Передаём текущий центр PIXI для точного расчёта dx/dy службами
+            const pix = this.getPixiObject(this.dragTarget);
+            const center = pix ? { x: pix.x, y: pix.y } : null;
+            this.emit(Events.Tool.DragUpdate, { object: this.dragTarget, pixiCenter: center });
+        }
         
         // Обновляем ручки во время перетаскивания
         if (this.resizeHandles && this.selection.has(this.dragTarget)) {
@@ -678,6 +755,8 @@ export class SelectTool extends BaseTool {
             this.groupCloneMap = null;
         } else if (this.dragTarget) {
             if (this._dragCtrl) this._dragCtrl.end();
+            // Сообщаем о завершении перетаскивания одиночного объекта
+            this.emit(Events.Tool.DragEnd, { object: this.dragTarget });
         }
         
         this.isDragging = false;
@@ -763,7 +842,8 @@ export class SelectTool extends BaseTool {
                 this.groupBoundsGraphics.position.set(gb.x, gb.y);
             }
             if (this.resizeHandles) {
-                this.resizeHandles.showHandles(this.groupBoundsGraphics, this.groupId);
+                // Отключаем старые PIXI-ручки
+                this.resizeHandles.hideHandles();
             }
             return;
         }
@@ -868,7 +948,7 @@ export class SelectTool extends BaseTool {
                 this.groupBoundsGraphics.pivot.set(0, 0);
                 this.groupBoundsGraphics.position.set(gb.x, gb.y);
             }
-            if (this.resizeHandles) this.resizeHandles.showHandles(this.groupBoundsGraphics, this.groupId);
+            if (this.resizeHandles) this.resizeHandles.hideHandles();
             return;
         }
         if (this._rotateCtrl) this._rotateCtrl.end();
@@ -1044,7 +1124,7 @@ export class SelectTool extends BaseTool {
         this.isDragging = false; // отключаем одиночный drag, если был
         this.ensureGroupBoundsGraphics(gb);
         if (this.groupBoundsGraphics && this.resizeHandles) {
-            this.resizeHandles.showHandles(this.groupBoundsGraphics, this.groupId);
+            this.resizeHandles.hideHandles();
         }
         if (this._groupDragCtrl) {
             const w = this._toWorld(event.x, event.y);
@@ -1562,22 +1642,27 @@ export class SelectTool extends BaseTool {
             left: '0px',
             top: '0px',
             border: 'none',
-            padding: '6px 8px', // Увеличиваем отступы для лучшего отображения
+            padding: '0',
             fontSize: `${fontSize}px`,
             fontFamily: 'Arial, sans-serif',
-            lineHeight: '1.2',
+            lineHeight: `${fontSize}px`,
             color: '#111', // Для записок делаем текст черным для лучшей видимости
             background: 'white',
             outline: 'none',
             resize: 'none',
             minWidth: '240px', // Для заметок уменьшаем минимальную ширину
-            minHeight: '28px', // Для заметок уменьшаем минимальную высоту
+            minHeight: `${fontSize}px`,
             width: '280px', // Для заметок уменьшаем начальную ширину
-            height: '36px', // Для заметок уменьшаем начальную высоту
-            boxSizing: 'border-box',
+            height: `${fontSize}px`,
+            boxSizing: 'content-box',
+            overflow: 'hidden',
             // Повыше чёткость текста в CSS
             WebkitFontSmoothing: 'antialiased',
             MozOsxFontSmoothing: 'grayscale',
+            // Улучшенное перенесение слов, как в Miro
+            overflowWrap: 'anywhere',
+            wordBreak: 'break-word',
+            margin: '0',
         });
         
         wrapper.appendChild(textarea);
@@ -1727,8 +1812,22 @@ export class SelectTool extends BaseTool {
         const initialHpx = initialSize ? Math.max(1, (initialSize.height || 0) * s / viewRes) : null;
         
         // Определяем минимальные границы для всех типов объектов
-        let minWBound = initialWpx || 240;
-        let minHBound = 28;
+        let minWBound = initialWpx || 120; // базово близко к призраку
+        let minHBound = fontSize; // высота по шрифту, чтобы не было пустого пространства
+
+        // Если создаём новый текст — выставляем стартовый размер, как у призрака, но чуть шире
+        if (create && !isNote) {
+            const ghostWidth = 120;
+            const startWidth = Math.round(ghostWidth * 1.33); // чуть длиннее призрака (~160px)
+            const startHeight = fontSize; // высота равна высоте шрифта
+            textarea.style.width = `${startWidth}px`;
+            textarea.style.height = `${startHeight}px`;
+            wrapper.style.width = `${startWidth}px`;
+            wrapper.style.height = `${startHeight}px`;
+            // Зафиксируем минимальные границы, чтобы авторазмер не схлопывал пустое поле
+            minWBound = startWidth;
+            minHBound = startHeight;
+        }
         
         // Для записок размеры уже установлены выше, пропускаем эту логику
         if (!isNote) {
@@ -1742,24 +1841,38 @@ export class SelectTool extends BaseTool {
             }
         }
         // Автоподгон
+        const MAX_AUTO_WIDTH = 360; // Поведение как в Miro: авто-ширина до порога, далее перенос строк
         const autoSize = () => {
             if (isNote) {
                 // Для заметок используем фиксированные размеры, вычисленные выше
-                // Не вызываем autoSize, чтобы сохранить точное позиционирование
                 return;
             }
-            
-            // Для обычного текста восстанавливаем автоподгон
-            textarea.style.height = '1px';
-            textarea.style.width = '1px';
-            const w = Math.max(minWBound, textarea.scrollWidth + 8);
-            const h = Math.max(minHBound, textarea.scrollHeight + 4);
-            textarea.style.width = `${w}px`;
-            textarea.style.height = `${h}px`;
-            wrapper.style.width = `${w}px`;
-            wrapper.style.height = `${h}px`;
-            // Обновляем ручки только для обычного текста
-            // placeHandles();
+            // Сначала измеряем естественную ширину без ограничений
+            const prevWidth = textarea.style.width;
+            const prevHeight = textarea.style.height;
+            textarea.style.width = 'auto';
+            textarea.style.height = 'auto';
+
+            // Желаемая ширина: не уже минимальной и не шире максимальной авто-ширины
+            const naturalW = textarea.scrollWidth + 1;
+            const targetW = Math.min(MAX_AUTO_WIDTH, Math.max(minWBound, naturalW));
+            textarea.style.width = `${targetW}px`;
+            wrapper.style.width = `${targetW}px`;
+
+            // Высота по содержимому при установленной ширине
+            textarea.style.height = 'auto';
+            // Коррекция высоты: для одной строки принудительно равна line-height,
+            // для нескольких строк используем scrollHeight с небольшим вычетом браузерного запаса
+            const adjust = 2;
+            const computed = (typeof window !== 'undefined') ? window.getComputedStyle(textarea) : null;
+            const lineH = computed ? parseFloat(computed.lineHeight) : (fontSize || 18);
+            const rawH = textarea.scrollHeight;
+            const lines = lineH > 0 ? Math.max(1, Math.round(rawH / lineH)) : 1;
+            const targetH = lines <= 1
+                ? lineH
+                : Math.max(minHBound, Math.max(1, rawH - adjust));
+            textarea.style.height = `${targetH}px`;
+            wrapper.style.height = `${targetH}px`;
         };
         
         // Вызываем autoSize только для обычного текста
@@ -1828,6 +1941,7 @@ export class SelectTool extends BaseTool {
             // handles.forEach(h => h.addEventListener('mousedown', onHandleDown));
         }
         // Завершение
+        const isNewCreation = !!create;
         const finalize = (commit) => {
             console.log('🔧 SelectTool: finalize called with commit:', commit, 'objectId:', objectId, 'objectType:', this.textEditor.objectType);
             const value = textarea.value.trim();
@@ -1837,8 +1951,8 @@ export class SelectTool extends BaseTool {
             const currentObjectType = this.textEditor.objectType;
             console.log('🔧 SelectTool: finalize - saved objectType:', currentObjectType);
             
-            // Показываем статичный текст после завершения редактирования для всех типов объектов
-            if (objectId) {
+            // Показываем статичный текст только если не отменяем создание нового пустого
+            if (objectId && (commitValue || !isNewCreation)) {
                 // Проверяем, что HTML-элемент существует перед попыткой показать текст
                 if (typeof window !== 'undefined' && window.moodboardHtmlTextLayer) {
                     const el = window.moodboardHtmlTextLayer.idToEl.get(objectId);
@@ -1852,10 +1966,42 @@ export class SelectTool extends BaseTool {
                 }
             }
             
+            // Перед скрытием — если редактировался существующий текст, обновим его размер под текущий редактор
+            if (objectId && (currentObjectType === 'text' || currentObjectType === 'simple-text')) {
+                try {
+                    const worldLayerRef = this.textEditor.world || (this.app?.stage);
+                    const s = worldLayerRef?.scale?.x || 1;
+                    const viewResLocal = (this.app?.renderer?.resolution) || (view.width && view.clientWidth ? (view.width / view.clientWidth) : 1);
+                    const wPx = Math.max(1, wrapper.offsetWidth);
+                    const hPx = Math.max(1, wrapper.offsetHeight);
+                    const newW = Math.max(1, Math.round(wPx * viewResLocal / s));
+                    const newH = Math.max(1, Math.round(hPx * viewResLocal / s));
+                    // Получим старые размеры для команды
+                    const sizeReq = { objectId, size: null };
+                    this.eventBus.emit(Events.Tool.GetObjectSize, sizeReq);
+                    const oldSize = sizeReq.size || { width: newW, height: newH };
+                    // Позиция в state хранится как левый-верх
+                    const posReq = { objectId, position: null };
+                    this.eventBus.emit(Events.Tool.GetObjectPosition, posReq);
+                    const oldPos = posReq.position || { x: position.x, y: position.y };
+                    const newSize = { width: newW, height: newH };
+                    // Во время ResizeUpdate ядро обновит и PIXI, и state
+                    this.eventBus.emit(Events.Tool.ResizeUpdate, { object: objectId, size: newSize, position: oldPos });
+                    // Зафиксируем изменение одной командой
+                    this.eventBus.emit(Events.Tool.ResizeEnd, { object: objectId, oldSize: oldSize, newSize: newSize, oldPosition: oldPos, newPosition: oldPos });
+                } catch (err) {
+                    console.warn('⚠️ Не удалось применить размеры после редактирования текста:', err);
+                }
+            }
+
             wrapper.remove();
             this.textEditor = { active: false, objectId: null, textarea: null, wrapper: null, world: null, position: null, properties: null, objectType: 'text' };
             this.eventBus.emit(Events.UI.TextEditEnd, { objectId: objectId || null });
             if (!commitValue) {
+                // Если это было создание нового текста и оно отменено — удаляем пустой объект
+                if (isNewCreation && objectId) {
+                    this.eventBus.emit(Events.Tool.ObjectsDelete, { objects: [objectId] });
+                }
                 console.log('🔧 SelectTool: finalize - no commit, returning');
                 return;
             }
@@ -1863,11 +2009,18 @@ export class SelectTool extends BaseTool {
                 console.log('🔧 SelectTool: finalize - creating new object');
                 // Создаем объект с правильным типом
                 const objectType = currentObjectType || 'text';
+                // Конвертируем размеры редактора (px) в мировые единицы
+                const worldLayerRef = this.textEditor.world || (this.app?.stage);
+                const s = worldLayerRef?.scale?.x || 1;
+                const wPx = Math.max(1, wrapper.offsetWidth);
+                const hPx = Math.max(1, wrapper.offsetHeight);
+                const wWorld = Math.max(1, Math.round(wPx * viewRes / s));
+                const hWorld = Math.max(1, Math.round(hPx * viewRes / s));
                 this.eventBus.emit(Events.UI.ToolbarAction, {
                     type: objectType,
                     id: objectType,
                     position: { x: position.x, y: position.y },
-                    properties: { content: value, fontSize }
+                    properties: { content: value, fontSize, width: wWorld, height: hWorld }
                 });
             } else {
                 // Обновление существующего: используем команду обновления содержимого
@@ -1905,12 +2058,10 @@ export class SelectTool extends BaseTool {
             }
         };
         textarea.addEventListener('blur', (e) => {
-            // Не закрываем новый пустой текст по потере фокуса — чтобы поле не исчезало сразу
-            const isNew = objectId == null;
             const value = (textarea.value || '').trim();
-            if (isNew && value.length === 0) {
-                // Вернём фокус обратно, чтобы пользователь мог ввести текст
-                setTimeout(() => textarea.focus(), 0);
+            if (isNewCreation && value.length === 0) {
+                // Клик вне поля при пустом значении — отменяем и удаляем созданный объект
+                finalize(false);
                 return;
             }
             finalize(true);
@@ -2267,4 +2418,24 @@ export class SelectTool extends BaseTool {
         super.destroy();
     }
 
+    onDuplicateReady(newObjectId) {
+        this.clonePending = false;
+        
+        // Переключаем выделение на новый объект
+        this.clearSelection();
+        this.addToSelection(newObjectId);
+
+        // Завершаем drag исходного объекта и переключаем контроллер на новый объект
+        if (this._dragCtrl) this._dragCtrl.end();
+        this.dragTarget = newObjectId;
+        this.isDragging = true;
+        // Стартуем drag нового объекта под текущим курсором (в мировых координатах)
+        const w = this._toWorld(this.currentX, this.currentY);
+        if (this._dragCtrl) this._dragCtrl.start(newObjectId, { x: w.x, y: w.y });
+        // Мгновенно обновляем позицию под курсор
+        this.updateDrag({ x: this.currentX, y: this.currentY });
+        // Обновляем ручки
+        this.updateResizeHandles();
+    }
+
 }

package/src/tools/object-tools/selection/BoxSelectController.js

@@ -55,6 +55,9 @@ export class BoxSelectController {
             this.emit('get:all:objects', request);
             const matched = [];
             for (const item of request.objects) {
+                const meta = item.pixi && item.pixi._mb;
+                // Исключаем фреймы из выделения рамкой — их можно выбрать только кликом по захватной рамке
+                if (meta && meta.type === 'frame') continue;
                 if (this.rectIntersectsRect(box, item.bounds)) matched.push(item.id);
             }
             let newSelection;
@@ -84,6 +87,8 @@ export class BoxSelectController {
             this.emit('get:all:objects', request);
             const matched = [];
             for (const item of request.objects) {
+                const meta = item.pixi && item.pixi._mb;
+                if (meta && meta.type === 'frame') continue;
                 if (this.rectIntersectsRect(box, item.bounds)) matched.push(item.id);
             }
             if (matched.length > 0) {

package/src/ui/FilePropertiesPanel.js

@@ -28,9 +28,13 @@ export class FilePropertiesPanel {
             if (this.currentId && objectId === this.currentId) this.hide();
         });
 
-        // Обновляем позицию при любых изменениях
+        // Обновляем позицию / скрываем во время перетаскивания
+        this.eventBus.on(Events.Tool.DragStart, () => this.hide());
         this.eventBus.on(Events.Tool.DragUpdate, () => this.reposition());
+        this.eventBus.on(Events.Tool.DragEnd, () => this.updateFromSelection());
         this.eventBus.on(Events.Tool.GroupDragUpdate, () => this.reposition());
+        this.eventBus.on(Events.Tool.GroupDragStart, () => this.hide());
+        this.eventBus.on(Events.Tool.GroupDragEnd, () => this.updateFromSelection());
         this.eventBus.on(Events.Tool.ResizeUpdate, () => this.reposition());
         this.eventBus.on(Events.Tool.RotateUpdate, () => this.reposition());
 
@@ -256,7 +260,10 @@ export class FilePropertiesPanel {
             
             // Показываем/скрываем кнопку скачивания в зависимости от наличия fileId
             if (this.downloadButton) {
-                this.downloadButton.style.display = hasFileId ? 'flex' : 'none';
+                // Всегда показываем кнопку, даже без fileId
+                this.downloadButton.style.display = 'flex';
+                this.downloadButton.disabled = !hasFileId;
+                this.downloadButton.title = hasFileId ? 'Скачать файл' : 'Файл недоступен для скачивания';
             }
         }
     }