From bbe32b5528e79ced692fadb4a0f4fd524a769fb8 Mon Sep 17 00:00:00 2001
From: Maxime Nicolas <71704827+Maxime-UwU@users.noreply.github.com>
Date: Thu, 8 Jun 2023 09:09:30 +0200
Subject: [PATCH 1/5] pdf working but need to modify sizes
---
.../agility/UI/DefaultSelectionBox.vue | 42 ++++++++++++++++-
.../agility/UI/MiroSelectionBox.vue | 46 ++++++++++++++++++-
.../blueprint/pruneTheProjectTree.ts | 2 +-
.../pixi-tools-v2/class/framedContainer.ts | 1 +
.../pixi-tools-v2/class/genericContainer.ts | 1 +
.../lib/pixi-tools-v2/class/lineContainer.ts | 1 +
front-end/src/store/modules/project.store.ts | 2 +-
7 files changed, 91 insertions(+), 4 deletions(-)
diff --git a/front-end/src/components/agility/UI/DefaultSelectionBox.vue b/front-end/src/components/agility/UI/DefaultSelectionBox.vue
index 0b6260006..d29c59c15 100644
--- a/front-end/src/components/agility/UI/DefaultSelectionBox.vue
+++ b/front-end/src/components/agility/UI/DefaultSelectionBox.vue
@@ -34,7 +34,7 @@
{{ element.order }}
-
+
@@ -51,6 +51,7 @@
text-style="text-black dark:text-white font-bold text-sm"
background="bg-light-secondary hover:bg-light-tertiary dark:bg-dark-tertiary"
class="w-32 min-w-[8rem]"
+ @click="exportToPdf()"
/>
@@ -71,6 +72,7 @@ import SvgSideBar from '@/components/common/svg/SideBar.vue';
import SvgShrink from '@/components/common/svg/Shrink.vue';
import { useProjectStore } from '@/store/modules/project.store';
import DefaultButton from '@/components/common/buttons/Default.vue';
+import pdfMake from 'pdfmake/build/pdfmake';
const projectStore = useProjectStore();
@@ -147,4 +149,42 @@ const decreaseZoom = () => {
projectStore.decreaseZoom();
}
+const exportToPdf = () => {
+ if (childImages.value.length === 0) return;
+
+ const styles = {
+ first: {
+ marginBottom: 25
+ },
+ second: {
+ marginLeft: 160,
+ marginBottom: 25
+ },
+ };
+
+ const data = {
+ content: [],
+ styles: styles
+ };
+
+ for (let n = 0; n < childImages.value.length; n++) {
+ if (childImages.value[n].dimension.width > 520) {
+ data.content.push({
+ style: 'first',
+ image: childImages.value[n].base64,
+ width: 520,
+ height: 300,
+ });
+ } else {
+ data.content.push({
+ style: 'second',
+ image: childImages.value[n].base64,
+ width: childImages.value[n].dimension.width,
+ height: childImages.value[n].dimension.height,
+ });
+ }
+ }
+
+ const pdfGenerator = pdfMake.createPdf(data).open();
+};
\ No newline at end of file
diff --git a/front-end/src/components/agility/UI/MiroSelectionBox.vue b/front-end/src/components/agility/UI/MiroSelectionBox.vue
index 94ff4bd44..dc2830ea5 100644
--- a/front-end/src/components/agility/UI/MiroSelectionBox.vue
+++ b/front-end/src/components/agility/UI/MiroSelectionBox.vue
@@ -118,7 +118,7 @@
{{ element.order }}
-
+
@@ -135,6 +135,7 @@
text-style="text-black dark:text-white font-bold text-sm"
background="bg-light-secondary hover:bg-light-tertiary dark:bg-dark-tertiary"
class="w-32 min-w-[8rem]"
+ @click="exportToPdf()"
/>
@@ -187,6 +188,7 @@ import SvgTriangle from '@/components/common/svg/Triangle.vue';
import SvgSideBar from '@/components/common/svg/SideBar.vue';
import SvgShrink from '@/components/common/svg/Shrink.vue';
import { useAgilityStore } from '@/store/modules/agility.store';
+import pdfMake from 'pdfmake/build/pdfmake';
const projectStore = useProjectStore();
const agilityStore = useAgilityStore();
@@ -272,6 +274,48 @@ const decreaseZoom = () => {
projectStore.decreaseZoom();
}
+const exportToPdf = () => {
+ if(childImages.value.length === 0) return;
+ const data = {
+ // defaultStyle: {margin: [0, 0]},
+ content:[]
+ };
+ // const data = { content: [] };
+ for(let n = 0; n < childImages.value.length; n++) {
+ if(childImages.value[n].dimension.width > 816){
+ data.content.push({
+ image: childImages.value[n].base64,
+ width: 520,
+ height: 300,
+ })
+ } else {
+ data.content.push({
+ image: childImages.value[n].base64,
+ width: childImages.value[n].dimension.width,
+ height: childImages.value[n].dimension.height,
+ })
+
+ }
+ }
+
+ const pdfGenerator = pdfMake.createPdf(data) //.open()
+ pdfGenerator.open()
+
+ // pdfGenerator.getBuffer((buffer: any) => {
+
+ // });
+}
+
+const savePdf = (buffer: any, fileName: string) => {
+ const blob = new Blob([buffer], { type: "application/pdf" });
+ const url = URL.createObjectURL(blob);
+ const link = document.createElement("a");
+ link.href = url;
+ link.download = fileName;
+ link.click();
+ URL.revokeObjectURL(url);
+}
+
const setDefaultMode = () => {
projectStore.default = true;
projectStore.deferredGeometry = null;
diff --git a/front-end/src/lib/pixi-tools-v2/blueprint/pruneTheProjectTree.ts b/front-end/src/lib/pixi-tools-v2/blueprint/pruneTheProjectTree.ts
index e7a6b7e2a..38c046ab5 100644
--- a/front-end/src/lib/pixi-tools-v2/blueprint/pruneTheProjectTree.ts
+++ b/front-end/src/lib/pixi-tools-v2/blueprint/pruneTheProjectTree.ts
@@ -32,7 +32,7 @@ export const pruneTheProjectTree = (
properties: {
cursor: 'pointer',
eventMode: PixiEventMode.STATIC,
- color: 0xff00ff,
+ color: 0xffffff,
alpha: 0,
borderWidth: 0,
borderColor: 0x000000,
diff --git a/front-end/src/lib/pixi-tools-v2/class/framedContainer.ts b/front-end/src/lib/pixi-tools-v2/class/framedContainer.ts
index f2b46ed4e..4ab88dd25 100644
--- a/front-end/src/lib/pixi-tools-v2/class/framedContainer.ts
+++ b/front-end/src/lib/pixi-tools-v2/class/framedContainer.ts
@@ -246,6 +246,7 @@ export class FramedContainer extends PluginContainer {
for (const element of this.mainContainer.children) {
if (element instanceof Rectangle) {
const clonedChild = element.clone();
+ clonedChild.alpha = element.alpha;
clonedChild.position.copyFrom(element.position);
cloned.addChild(clonedChild);
} else if (element instanceof GenericContainer) {
diff --git a/front-end/src/lib/pixi-tools-v2/class/genericContainer.ts b/front-end/src/lib/pixi-tools-v2/class/genericContainer.ts
index bcd49ad7d..afc20d98e 100644
--- a/front-end/src/lib/pixi-tools-v2/class/genericContainer.ts
+++ b/front-end/src/lib/pixi-tools-v2/class/genericContainer.ts
@@ -122,6 +122,7 @@ export class GenericContainer extends PluginContainer {
for (const element of this.children) {
const clonedChild = element.clone();
+ clonedChild.alpha = element.alpha;
clonedChild.position.copyFrom(element.position);
cloned.addChild(clonedChild);
}
diff --git a/front-end/src/lib/pixi-tools-v2/class/lineContainer.ts b/front-end/src/lib/pixi-tools-v2/class/lineContainer.ts
index 459ad540b..89bbc48a0 100644
--- a/front-end/src/lib/pixi-tools-v2/class/lineContainer.ts
+++ b/front-end/src/lib/pixi-tools-v2/class/lineContainer.ts
@@ -144,6 +144,7 @@ export class LineContainer extends PluginContainer {
for (const element of this.children) {
const clonedChild = element.clone();
+ clonedChild.alpha = element.alpha;
clonedChild.position.copyFrom(element.position);
cloned.addChild(clonedChild);
}
diff --git a/front-end/src/store/modules/project.store.ts b/front-end/src/store/modules/project.store.ts
index a2c74e16f..df9660352 100644
--- a/front-end/src/store/modules/project.store.ts
+++ b/front-end/src/store/modules/project.store.ts
@@ -54,7 +54,7 @@ export const useProjectStore = defineStore('project', {
const { x, y } = cloneContainer.getBounds();
cloneContainer.position.set(-x, -y);
- const renderer = new Renderer({ resolution: devicePixelRatio + 1, width: height, height: width, backgroundAlpha: 0 });
+ const renderer = new Renderer({ resolution: devicePixelRatio + 1, width, height, backgroundAlpha: 0 });
renderer.render(cloneContainer);
const canvas = renderer.view;
From 50e88c4001ebe689f7740efefb97af42e7ca6d04 Mon Sep 17 00:00:00 2001
From: Maxime Nicolas <71704827+Maxime-UwU@users.noreply.github.com>
Date: Thu, 8 Jun 2023 17:32:05 +0200
Subject: [PATCH 2/5] fix positions inside the pdf
---
.../agility/UI/DefaultSelectionBox.vue | 33 ++++++++++++-------
.../pixi-tools-v2/blueprint/elevatorPitch.ts | 1 +
.../lib/pixi-tools-v2/blueprint/empathyMap.ts | 1 +
.../pixi-tools-v2/blueprint/impactMapping.ts | 1 +
.../lib/pixi-tools-v2/blueprint/personas.ts | 1 +
.../blueprint/pruneTheProjectTree.ts | 1 +
.../pixi-tools-v2/class/framedContainer.ts | 3 ++
.../src/lib/pixi-tools-v2/class/normalyzer.ts | 1 +
.../lib/pixi-tools-v2/types/pixi-serialize.ts | 1 +
.../src/store/interfaces/project.interface.ts | 2 +-
front-end/src/store/modules/project.store.ts | 3 +-
11 files changed, 35 insertions(+), 13 deletions(-)
diff --git a/front-end/src/components/agility/UI/DefaultSelectionBox.vue b/front-end/src/components/agility/UI/DefaultSelectionBox.vue
index d29c59c15..12b69c765 100644
--- a/front-end/src/components/agility/UI/DefaultSelectionBox.vue
+++ b/front-end/src/components/agility/UI/DefaultSelectionBox.vue
@@ -72,7 +72,12 @@ import SvgSideBar from '@/components/common/svg/SideBar.vue';
import SvgShrink from '@/components/common/svg/Shrink.vue';
import { useProjectStore } from '@/store/modules/project.store';
import DefaultButton from '@/components/common/buttons/Default.vue';
-import pdfMake from 'pdfmake/build/pdfmake';
+import { elements } from 'chart.js';
+import { ClientRequest } from 'http';
+import { createPdf } from 'pdfmake/build/pdfmake';
+import * as _ from 'pdfmake/build/vfs_fonts.js';
+
+const fonts = globalThis.pdfMake.vfs ?? _.pdfMake.vfs;
const projectStore = useProjectStore();
@@ -153,12 +158,9 @@ const exportToPdf = () => {
if (childImages.value.length === 0) return;
const styles = {
- first: {
- marginBottom: 25
- },
- second: {
- marginLeft: 160,
- marginBottom: 25
+ image: {
+ alignment: 'center',
+ marginBottom: 25,
},
};
@@ -168,16 +170,23 @@ const exportToPdf = () => {
};
for (let n = 0; n < childImages.value.length; n++) {
- if (childImages.value[n].dimension.width > 520) {
+ if (childImages.value[n].isBlueprint == true) {
data.content.push({
- style: 'first',
+ style: 'image',
image: childImages.value[n].base64,
width: 520,
height: 300,
});
+ } else if (childImages.value[n].dimension.width > 520) {
+ data.content.push({
+ style: 'image',
+ image: childImages.value[n].base64,
+ width: 520,
+ height: childImages.value[n].dimension.height,
+ });
} else {
data.content.push({
- style: 'second',
+ style: 'image',
image: childImages.value[n].base64,
width: childImages.value[n].dimension.width,
height: childImages.value[n].dimension.height,
@@ -185,6 +194,8 @@ const exportToPdf = () => {
}
}
- const pdfGenerator = pdfMake.createPdf(data).open();
+ // @ts-ignore
+ const pdfGenerator = createPdf(data, null, null, fonts).open();
};
+
\ No newline at end of file
diff --git a/front-end/src/lib/pixi-tools-v2/blueprint/elevatorPitch.ts b/front-end/src/lib/pixi-tools-v2/blueprint/elevatorPitch.ts
index a957c2b11..8ddbcb8da 100644
--- a/front-end/src/lib/pixi-tools-v2/blueprint/elevatorPitch.ts
+++ b/front-end/src/lib/pixi-tools-v2/blueprint/elevatorPitch.ts
@@ -43,6 +43,7 @@ export const elavatorPitch = (
isAttachedToFrame: false,
frameNumber: frameNumber,
disabled: false,
+ isBlueprint: true,
},
childs: [],
};
diff --git a/front-end/src/lib/pixi-tools-v2/blueprint/empathyMap.ts b/front-end/src/lib/pixi-tools-v2/blueprint/empathyMap.ts
index ffea9fbcb..b4a635716 100644
--- a/front-end/src/lib/pixi-tools-v2/blueprint/empathyMap.ts
+++ b/front-end/src/lib/pixi-tools-v2/blueprint/empathyMap.ts
@@ -54,6 +54,7 @@ export const empathyMap = (
isAttachedToFrame: false,
frameNumber: frameNumber,
disabled: false,
+ isBlueprint: true,
},
childs: [
{
diff --git a/front-end/src/lib/pixi-tools-v2/blueprint/impactMapping.ts b/front-end/src/lib/pixi-tools-v2/blueprint/impactMapping.ts
index 5b9dc859a..b4bdba623 100644
--- a/front-end/src/lib/pixi-tools-v2/blueprint/impactMapping.ts
+++ b/front-end/src/lib/pixi-tools-v2/blueprint/impactMapping.ts
@@ -56,6 +56,7 @@ export const impactMapping = (
isAttachedToFrame: false,
frameNumber: frameNumber,
disabled: false,
+ isBlueprint: true,
},
childs: [
{
diff --git a/front-end/src/lib/pixi-tools-v2/blueprint/personas.ts b/front-end/src/lib/pixi-tools-v2/blueprint/personas.ts
index 351aeb07a..af5994fe4 100644
--- a/front-end/src/lib/pixi-tools-v2/blueprint/personas.ts
+++ b/front-end/src/lib/pixi-tools-v2/blueprint/personas.ts
@@ -56,6 +56,7 @@ export const personas = (
isAttachedToFrame: false,
frameNumber: frameNumber,
disabled: false,
+ isBlueprint: true,
},
childs: [
{
diff --git a/front-end/src/lib/pixi-tools-v2/blueprint/pruneTheProjectTree.ts b/front-end/src/lib/pixi-tools-v2/blueprint/pruneTheProjectTree.ts
index 38c046ab5..2561562c7 100644
--- a/front-end/src/lib/pixi-tools-v2/blueprint/pruneTheProjectTree.ts
+++ b/front-end/src/lib/pixi-tools-v2/blueprint/pruneTheProjectTree.ts
@@ -51,6 +51,7 @@ export const pruneTheProjectTree = (
isAttachedToFrame: false,
frameNumber: frameNumber,
disabled: false,
+ isBlueprint: true,
},
childs: [
/*******************************
diff --git a/front-end/src/lib/pixi-tools-v2/class/framedContainer.ts b/front-end/src/lib/pixi-tools-v2/class/framedContainer.ts
index 4ab88dd25..85c8d2ee3 100644
--- a/front-end/src/lib/pixi-tools-v2/class/framedContainer.ts
+++ b/front-end/src/lib/pixi-tools-v2/class/framedContainer.ts
@@ -45,6 +45,7 @@ export class FramedContainer extends PluginContainer {
public tabNumberContext: number;
public isAttachedToFrame: boolean;
public frameNumber: number;
+ public isBlueprint: boolean;
static registerContainer(
viewport: ViewportUI,
@@ -75,6 +76,7 @@ export class FramedContainer extends PluginContainer {
this.tabNumberContext = properties.tabNumberContext;
this.isAttachedToFrame = properties.isAttachedToFrame;
this.frameNumber = properties.frameNumber;
+ this.isBlueprint = properties.isBlueprint;
this.absMinX = anchors.absMinX;
this.absMinY = anchors.absMinY;
this.absMaxX = anchors.absMaxX;
@@ -292,6 +294,7 @@ export class FramedContainer extends PluginContainer {
isAttachedToFrame: this.isAttachedToFrame,
frameNumber: this.frameNumber,
disabled: this.disabled,
+ isBlueprint: this.isBlueprint,
},
childs: genericContainerSerialized,
};
diff --git a/front-end/src/lib/pixi-tools-v2/class/normalyzer.ts b/front-end/src/lib/pixi-tools-v2/class/normalyzer.ts
index 3b3f474e2..8d3cb882b 100644
--- a/front-end/src/lib/pixi-tools-v2/class/normalyzer.ts
+++ b/front-end/src/lib/pixi-tools-v2/class/normalyzer.ts
@@ -107,6 +107,7 @@ export class Normalizer {
isAttachedToFrame: false,
tabNumberContext: tabContext ?? -1,
disabled: false,
+ isBlueprint: false,
};
}
diff --git a/front-end/src/lib/pixi-tools-v2/types/pixi-serialize.ts b/front-end/src/lib/pixi-tools-v2/types/pixi-serialize.ts
index 34e53fe93..7e7dfb4cc 100644
--- a/front-end/src/lib/pixi-tools-v2/types/pixi-serialize.ts
+++ b/front-end/src/lib/pixi-tools-v2/types/pixi-serialize.ts
@@ -87,6 +87,7 @@ export interface SerializedContainerProperties
tabNumberContext: number;
frameNumber?: number;
disabled: boolean;
+ isBlueprint?: boolean;
}
export interface SerializedGraphicProperties extends SerializedProperties, ElementColorimetry {
diff --git a/front-end/src/store/interfaces/project.interface.ts b/front-end/src/store/interfaces/project.interface.ts
index 0db987947..c09daa08b 100644
--- a/front-end/src/store/interfaces/project.interface.ts
+++ b/front-end/src/store/interfaces/project.interface.ts
@@ -49,8 +49,8 @@ export interface ViewportDefaultPosition {
export interface FramedPDF {
id: string,
order: number,
- random?: number,
base64: string,
+ isBlueprint: boolean,
dimension: {
width: number,
height: number,
diff --git a/front-end/src/store/modules/project.store.ts b/front-end/src/store/modules/project.store.ts
index df9660352..8db495097 100644
--- a/front-end/src/store/modules/project.store.ts
+++ b/front-end/src/store/modules/project.store.ts
@@ -49,7 +49,7 @@ export const useProjectStore = defineStore('project', {
const reactiveImages: Array = [];
for(let n = 0; n < len; n++) {
const container = frames[n];
- const { width, height } = container;
+ const { width, height, isBlueprint } = container;
const cloneContainer = container.cloneToContainer();
const { x, y } = cloneContainer.getBounds();
cloneContainer.position.set(-x, -y);
@@ -63,6 +63,7 @@ export const useProjectStore = defineStore('project', {
reactiveImages.push({
id: container.uuid,
order: n + 1,
+ isBlueprint,
base64: imageData,
dimension: {
width: Math.floor(width),
From 8cf7b835af236ab5ced769a4e385969d4bde6d4e Mon Sep 17 00:00:00 2001
From: Maxime Nicolas <71704827+Maxime-UwU@users.noreply.github.com>
Date: Fri, 9 Jun 2023 10:23:34 +0200
Subject: [PATCH 3/5] add text on top of blueprints in the pdf
---
.../agility/UI/DefaultSelectionBox.vue | 36 +++++++++++++++++--
.../pixi-tools-v2/blueprint/elevatorPitch.ts | 3 +-
.../lib/pixi-tools-v2/blueprint/empathyMap.ts | 3 +-
.../pixi-tools-v2/blueprint/impactMapping.ts | 3 +-
.../lib/pixi-tools-v2/blueprint/personas.ts | 3 +-
.../blueprint/pruneTheProjectTree.ts | 3 +-
.../pixi-tools-v2/class/framedContainer.ts | 3 ++
.../src/lib/pixi-tools-v2/class/normalyzer.ts | 1 +
.../src/lib/pixi-tools-v2/types/pixi-enums.ts | 18 ++++++++++
.../lib/pixi-tools-v2/types/pixi-serialize.ts | 1 +
.../src/store/interfaces/project.interface.ts | 1 +
front-end/src/store/modules/project.store.ts | 3 +-
12 files changed, 69 insertions(+), 9 deletions(-)
diff --git a/front-end/src/components/agility/UI/DefaultSelectionBox.vue b/front-end/src/components/agility/UI/DefaultSelectionBox.vue
index 12b69c765..fb68cf203 100644
--- a/front-end/src/components/agility/UI/DefaultSelectionBox.vue
+++ b/front-end/src/components/agility/UI/DefaultSelectionBox.vue
@@ -76,6 +76,7 @@ import { elements } from 'chart.js';
import { ClientRequest } from 'http';
import { createPdf } from 'pdfmake/build/pdfmake';
import * as _ from 'pdfmake/build/vfs_fonts.js';
+import { TypeBlueprintText } from '@/lib/pixi-tools-v2/types/pixi-enums';
const fonts = globalThis.pdfMake.vfs ?? _.pdfMake.vfs;
@@ -162,6 +163,9 @@ const exportToPdf = () => {
alignment: 'center',
marginBottom: 25,
},
+ text: {
+ alignment: 'center',
+ },
};
const data = {
@@ -171,8 +175,35 @@ const exportToPdf = () => {
for (let n = 0; n < childImages.value.length; n++) {
if (childImages.value[n].isBlueprint == true) {
- data.content.push({
- style: 'image',
+ if(childImages.value[n].typeBlueprint == 1){
+ data.content.push({
+ style: 'text',
+ text: TypeBlueprintText["1"]
+ })
+ }else if(childImages.value[n].typeBlueprint == 2){
+ data.content.push({
+ style: 'text',
+ text: TypeBlueprintText["2"]
+ })
+ }else if(childImages.value[n].typeBlueprint == 3){
+ data.content.push({
+ style: 'text',
+ text: TypeBlueprintText["3"]
+ })
+ }else if(childImages.value[n].typeBlueprint == 4){
+ data.content.push({
+ style: 'text',
+ text: TypeBlueprintText["4"]
+ })
+ }else if(childImages.value[n].typeBlueprint == 5){
+ data.content.push({
+ style: 'text',
+ text: TypeBlueprintText["5"]
+ })
+ }else {
+ }
+ data.content.push({
+ style: 'image',
image: childImages.value[n].base64,
width: 520,
height: 300,
@@ -197,5 +228,4 @@ const exportToPdf = () => {
// @ts-ignore
const pdfGenerator = createPdf(data, null, null, fonts).open();
};
-
\ No newline at end of file
diff --git a/front-end/src/lib/pixi-tools-v2/blueprint/elevatorPitch.ts b/front-end/src/lib/pixi-tools-v2/blueprint/elevatorPitch.ts
index 8ddbcb8da..128362da2 100644
--- a/front-end/src/lib/pixi-tools-v2/blueprint/elevatorPitch.ts
+++ b/front-end/src/lib/pixi-tools-v2/blueprint/elevatorPitch.ts
@@ -3,7 +3,7 @@ import { FramedContainer } from '../class/framedContainer';
import { lowestNumberFinder } from '../utils/numberFinder';
import { ViewportUI } from '../viewportUI';
import { SerializedContainer } from '../types/pixi-serialize';
-import { PixiEventMode } from '../types/pixi-enums';
+import { PixiEventMode, TypeBlueprint } from '../types/pixi-enums';
export const elavatorPitch = (
viewport: ViewportUI,
@@ -44,6 +44,7 @@ export const elavatorPitch = (
frameNumber: frameNumber,
disabled: false,
isBlueprint: true,
+ typeBlueprint: TypeBlueprint.ELEVATOR_PITCH,
},
childs: [],
};
diff --git a/front-end/src/lib/pixi-tools-v2/blueprint/empathyMap.ts b/front-end/src/lib/pixi-tools-v2/blueprint/empathyMap.ts
index b4a635716..4dc56ed9f 100644
--- a/front-end/src/lib/pixi-tools-v2/blueprint/empathyMap.ts
+++ b/front-end/src/lib/pixi-tools-v2/blueprint/empathyMap.ts
@@ -3,7 +3,7 @@ import { FramedContainer } from '../class/framedContainer';
import { lowestNumberFinder } from '../utils/numberFinder';
import { ViewportUI } from '../viewportUI';
import { SerializedContainer } from '../types/pixi-serialize';
-import { PixiEventMode } from '../types/pixi-enums';
+import { PixiEventMode, TypeBlueprint } from '../types/pixi-enums';
export const empathyMap = (
viewport: ViewportUI,
@@ -55,6 +55,7 @@ export const empathyMap = (
frameNumber: frameNumber,
disabled: false,
isBlueprint: true,
+ typeBlueprint: TypeBlueprint.EMPATHY_MAP,
},
childs: [
{
diff --git a/front-end/src/lib/pixi-tools-v2/blueprint/impactMapping.ts b/front-end/src/lib/pixi-tools-v2/blueprint/impactMapping.ts
index b4bdba623..6c0965f6b 100644
--- a/front-end/src/lib/pixi-tools-v2/blueprint/impactMapping.ts
+++ b/front-end/src/lib/pixi-tools-v2/blueprint/impactMapping.ts
@@ -3,7 +3,7 @@ import { FramedContainer } from '../class/framedContainer';
import { lowestNumberFinder } from '../utils/numberFinder';
import { ViewportUI } from '../viewportUI';
import { SerializedContainer } from '../types/pixi-serialize';
-import { PixiEventMode } from '../types/pixi-enums';
+import { PixiEventMode, TypeBlueprint } from '../types/pixi-enums';
export const impactMapping = (
viewport: ViewportUI,
@@ -57,6 +57,7 @@ export const impactMapping = (
frameNumber: frameNumber,
disabled: false,
isBlueprint: true,
+ typeBlueprint: TypeBlueprint.IMPACT_MAPPING,
},
childs: [
{
diff --git a/front-end/src/lib/pixi-tools-v2/blueprint/personas.ts b/front-end/src/lib/pixi-tools-v2/blueprint/personas.ts
index af5994fe4..8a25ddf7e 100644
--- a/front-end/src/lib/pixi-tools-v2/blueprint/personas.ts
+++ b/front-end/src/lib/pixi-tools-v2/blueprint/personas.ts
@@ -3,7 +3,7 @@ import { FramedContainer } from '../class/framedContainer';
import { lowestNumberFinder } from '../utils/numberFinder';
import { ViewportUI } from '../viewportUI';
import { SerializedContainer } from '../types/pixi-serialize';
-import { PixiEventMode } from '../types/pixi-enums';
+import { PixiEventMode, TypeBlueprint } from '../types/pixi-enums';
export const personas = (
viewport: ViewportUI,
@@ -57,6 +57,7 @@ export const personas = (
frameNumber: frameNumber,
disabled: false,
isBlueprint: true,
+ typeBlueprint: TypeBlueprint.PERSONA,
},
childs: [
{
diff --git a/front-end/src/lib/pixi-tools-v2/blueprint/pruneTheProjectTree.ts b/front-end/src/lib/pixi-tools-v2/blueprint/pruneTheProjectTree.ts
index 2561562c7..662e29064 100644
--- a/front-end/src/lib/pixi-tools-v2/blueprint/pruneTheProjectTree.ts
+++ b/front-end/src/lib/pixi-tools-v2/blueprint/pruneTheProjectTree.ts
@@ -3,7 +3,7 @@ import { FramedContainer } from '../class/framedContainer';
import { lowestNumberFinder } from '../utils/numberFinder';
import { ViewportUI } from '../viewportUI';
import { SerializedContainer } from '../types/pixi-serialize';
-import { PixiEventMode } from '../types/pixi-enums';
+import { PixiEventMode, TypeBlueprint } from '../types/pixi-enums';
export const pruneTheProjectTree = (
viewport: ViewportUI,
@@ -52,6 +52,7 @@ export const pruneTheProjectTree = (
frameNumber: frameNumber,
disabled: false,
isBlueprint: true,
+ typeBlueprint: TypeBlueprint.PRUNE_THE_PROJECT_TREE,
},
childs: [
/*******************************
diff --git a/front-end/src/lib/pixi-tools-v2/class/framedContainer.ts b/front-end/src/lib/pixi-tools-v2/class/framedContainer.ts
index 85c8d2ee3..ee9c85e34 100644
--- a/front-end/src/lib/pixi-tools-v2/class/framedContainer.ts
+++ b/front-end/src/lib/pixi-tools-v2/class/framedContainer.ts
@@ -46,6 +46,7 @@ export class FramedContainer extends PluginContainer {
public isAttachedToFrame: boolean;
public frameNumber: number;
public isBlueprint: boolean;
+ public typeBlueprint: number;
static registerContainer(
viewport: ViewportUI,
@@ -77,6 +78,7 @@ export class FramedContainer extends PluginContainer {
this.isAttachedToFrame = properties.isAttachedToFrame;
this.frameNumber = properties.frameNumber;
this.isBlueprint = properties.isBlueprint;
+ this.typeBlueprint = properties.typeBlueprint ?? 0;
this.absMinX = anchors.absMinX;
this.absMinY = anchors.absMinY;
this.absMaxX = anchors.absMaxX;
@@ -295,6 +297,7 @@ export class FramedContainer extends PluginContainer {
frameNumber: this.frameNumber,
disabled: this.disabled,
isBlueprint: this.isBlueprint,
+ typeBlueprint: this.typeBlueprint,
},
childs: genericContainerSerialized,
};
diff --git a/front-end/src/lib/pixi-tools-v2/class/normalyzer.ts b/front-end/src/lib/pixi-tools-v2/class/normalyzer.ts
index 8d3cb882b..b439868ab 100644
--- a/front-end/src/lib/pixi-tools-v2/class/normalyzer.ts
+++ b/front-end/src/lib/pixi-tools-v2/class/normalyzer.ts
@@ -108,6 +108,7 @@ export class Normalizer {
tabNumberContext: tabContext ?? -1,
disabled: false,
isBlueprint: false,
+ typeBlueprint: 0,
};
}
diff --git a/front-end/src/lib/pixi-tools-v2/types/pixi-enums.ts b/front-end/src/lib/pixi-tools-v2/types/pixi-enums.ts
index 1a0cc9b58..29983c4e1 100644
--- a/front-end/src/lib/pixi-tools-v2/types/pixi-enums.ts
+++ b/front-end/src/lib/pixi-tools-v2/types/pixi-enums.ts
@@ -85,3 +85,21 @@ export enum PixiEventMode {
STATIC = 'static',
DYNAMIC = 'dynamic',
}
+
+export enum TypeBlueprint {
+ EMPATHY_MAP = 1,
+ PERSONA = 2,
+ IMPACT_MAPPING = 3,
+ PRUNE_THE_PROJECT_TREE = 4,
+ ELEVATOR_PITCH = 5,
+}
+
+export const TypeBlueprintText = {
+ "0": "Null",
+ "1": "Empathy Map",
+ "2": "Persona",
+ "3": "Impact mapping",
+ "4": "Prune the project tree",
+ "5": "Elevator pitch",
+} as const;
+
diff --git a/front-end/src/lib/pixi-tools-v2/types/pixi-serialize.ts b/front-end/src/lib/pixi-tools-v2/types/pixi-serialize.ts
index 7e7dfb4cc..99a376819 100644
--- a/front-end/src/lib/pixi-tools-v2/types/pixi-serialize.ts
+++ b/front-end/src/lib/pixi-tools-v2/types/pixi-serialize.ts
@@ -88,6 +88,7 @@ export interface SerializedContainerProperties
frameNumber?: number;
disabled: boolean;
isBlueprint?: boolean;
+ typeBlueprint?: number;
}
export interface SerializedGraphicProperties extends SerializedProperties, ElementColorimetry {
diff --git a/front-end/src/store/interfaces/project.interface.ts b/front-end/src/store/interfaces/project.interface.ts
index c09daa08b..c97300740 100644
--- a/front-end/src/store/interfaces/project.interface.ts
+++ b/front-end/src/store/interfaces/project.interface.ts
@@ -51,6 +51,7 @@ export interface FramedPDF {
order: number,
base64: string,
isBlueprint: boolean,
+ typeBlueprint: number,
dimension: {
width: number,
height: number,
diff --git a/front-end/src/store/modules/project.store.ts b/front-end/src/store/modules/project.store.ts
index 8db495097..018f2ff81 100644
--- a/front-end/src/store/modules/project.store.ts
+++ b/front-end/src/store/modules/project.store.ts
@@ -49,7 +49,7 @@ export const useProjectStore = defineStore('project', {
const reactiveImages: Array = [];
for(let n = 0; n < len; n++) {
const container = frames[n];
- const { width, height, isBlueprint } = container;
+ const { width, height, isBlueprint, typeBlueprint } = container;
const cloneContainer = container.cloneToContainer();
const { x, y } = cloneContainer.getBounds();
cloneContainer.position.set(-x, -y);
@@ -64,6 +64,7 @@ export const useProjectStore = defineStore('project', {
id: container.uuid,
order: n + 1,
isBlueprint,
+ typeBlueprint,
base64: imageData,
dimension: {
width: Math.floor(width),
From 2c8b9bf9ad2f6a74ea561fe5231bd81542360bcc Mon Sep 17 00:00:00 2001
From: Maxime Nicolas <71704827+Maxime-UwU@users.noreply.github.com>
Date: Fri, 9 Jun 2023 13:44:08 +0200
Subject: [PATCH 4/5] move the pdf creation to generatePdf in utils folder and
import it in MiroSelectionBox
---
.../agility/UI/DefaultSelectionBox.vue | 81 +------------------
.../agility/UI/MiroSelectionBox.vue | 51 ++----------
.../lib/pixi-tools-v2/utils/generatePdf.ts | 79 ++++++++++++++++++
3 files changed, 90 insertions(+), 121 deletions(-)
create mode 100644 front-end/src/lib/pixi-tools-v2/utils/generatePdf.ts
diff --git a/front-end/src/components/agility/UI/DefaultSelectionBox.vue b/front-end/src/components/agility/UI/DefaultSelectionBox.vue
index fb68cf203..3dbf8c924 100644
--- a/front-end/src/components/agility/UI/DefaultSelectionBox.vue
+++ b/front-end/src/components/agility/UI/DefaultSelectionBox.vue
@@ -51,7 +51,7 @@
text-style="text-black dark:text-white font-bold text-sm"
background="bg-light-secondary hover:bg-light-tertiary dark:bg-dark-tertiary"
class="w-32 min-w-[8rem]"
- @click="exportToPdf()"
+ @click="generatePdf()"
/>
@@ -61,7 +61,6 @@
\ No newline at end of file
diff --git a/front-end/src/components/agility/UI/MiroSelectionBox.vue b/front-end/src/components/agility/UI/MiroSelectionBox.vue
index dc2830ea5..88b237b51 100644
--- a/front-end/src/components/agility/UI/MiroSelectionBox.vue
+++ b/front-end/src/components/agility/UI/MiroSelectionBox.vue
@@ -112,7 +112,6 @@
:style="drawerOpen ? 'width: 550px;' : 'width: 0;' "
>
@@ -188,7 +187,9 @@ import SvgTriangle from '@/components/common/svg/Triangle.vue';
import SvgSideBar from '@/components/common/svg/SideBar.vue';
import SvgShrink from '@/components/common/svg/Shrink.vue';
import { useAgilityStore } from '@/store/modules/agility.store';
-import pdfMake from 'pdfmake/build/pdfmake';
+import * as _ from 'pdfmake/build/vfs_fonts.js';
+import { exportToPdf} from '@/lib/pixi-tools-v2/utils/generatePdf';
+
const projectStore = useProjectStore();
const agilityStore = useAgilityStore();
@@ -274,47 +275,9 @@ const decreaseZoom = () => {
projectStore.decreaseZoom();
}
-const exportToPdf = () => {
- if(childImages.value.length === 0) return;
- const data = {
- // defaultStyle: {margin: [0, 0]},
- content:[]
- };
- // const data = { content: [] };
- for(let n = 0; n < childImages.value.length; n++) {
- if(childImages.value[n].dimension.width > 816){
- data.content.push({
- image: childImages.value[n].base64,
- width: 520,
- height: 300,
- })
- } else {
- data.content.push({
- image: childImages.value[n].base64,
- width: childImages.value[n].dimension.width,
- height: childImages.value[n].dimension.height,
- })
-
- }
- }
-
- const pdfGenerator = pdfMake.createPdf(data) //.open()
- pdfGenerator.open()
-
- // pdfGenerator.getBuffer((buffer: any) => {
-
- // });
-}
-
-const savePdf = (buffer: any, fileName: string) => {
- const blob = new Blob([buffer], { type: "application/pdf" });
- const url = URL.createObjectURL(blob);
- const link = document.createElement("a");
- link.href = url;
- link.download = fileName;
- link.click();
- URL.revokeObjectURL(url);
-}
+const generatePdf = () => {
+ exportToPdf(childImages.value);
+ };
const setDefaultMode = () => {
projectStore.default = true;
diff --git a/front-end/src/lib/pixi-tools-v2/utils/generatePdf.ts b/front-end/src/lib/pixi-tools-v2/utils/generatePdf.ts
new file mode 100644
index 000000000..290dc860c
--- /dev/null
+++ b/front-end/src/lib/pixi-tools-v2/utils/generatePdf.ts
@@ -0,0 +1,79 @@
+import { createPdf } from 'pdfmake/build/pdfmake';
+import * as _ from 'pdfmake/build/vfs_fonts.js';
+import { TypeBlueprintText } from '@/lib/pixi-tools-v2/types/pixi-enums';
+
+const _fonts = globalThis.pdfMake.vfs ?? _.pdfMake.vfs;
+
+export function exportToPdf(childImages) {
+ if (childImages.length === 0) return;
+
+ const styles = {
+ image: {
+ alignment: 'center',
+ marginBottom: 25,
+ },
+ text: {
+ alignment: 'center',
+ },
+ };
+
+ const data = {
+ content: [],
+ styles: styles
+ };
+
+ for (let n = 0; n < childImages.length; n++) {
+ if (childImages[n].isBlueprint == true) {
+ if (childImages[n].typeBlueprint == 1) {
+ data.content.push({
+ style: 'text',
+ text: TypeBlueprintText["1"]
+ })
+ } else if (childImages[n].typeBlueprint == 2) {
+ data.content.push({
+ style: 'text',
+ text: TypeBlueprintText["2"]
+ })
+ } else if (childImages[n].typeBlueprint == 3) {
+ data.content.push({
+ style: 'text',
+ text: TypeBlueprintText["3"]
+ })
+ } else if (childImages[n].typeBlueprint == 4) {
+ data.content.push({
+ style: 'text',
+ text: TypeBlueprintText["4"]
+ })
+ } else if (childImages[n].typeBlueprint == 5) {
+ data.content.push({
+ style: 'text',
+ text: TypeBlueprintText["5"]
+ })
+ } else {
+ }
+ data.content.push({
+ style: 'image',
+ image: childImages[n].base64,
+ width: 520,
+ height: 300,
+ });
+ } else if (childImages[n].dimension.width > 520) {
+ data.content.push({
+ style: 'image',
+ image: childImages[n].base64,
+ width: 520,
+ height: childImages[n].dimension.height,
+ });
+ } else {
+ data.content.push({
+ style: 'image',
+ image: childImages[n].base64,
+ width: childImages[n].dimension.width,
+ height: childImages[n].dimension.height,
+ });
+ }
+ }
+
+ // @ts-ignore
+ const pdfGenerator = createPdf(data, null, null, _fonts).open();
+}
From c95a12a69e3764744db233bc00874a83662ce2f1 Mon Sep 17 00:00:00 2001
From: Maxime Nicolas <71704827+Maxime-UwU@users.noreply.github.com>
Date: Fri, 16 Jun 2023 11:25:21 +0200
Subject: [PATCH 5/5] add logo to pdf
---
.../utils/base64codingFactoryLogo.ts | 2 +
.../utils/base64codingToolsLogo.ts | 2 +
.../lib/pixi-tools-v2/utils/generatePdf.ts | 38 ++++++++++++++++---
3 files changed, 36 insertions(+), 6 deletions(-)
create mode 100644 front-end/src/lib/pixi-tools-v2/utils/base64codingFactoryLogo.ts
create mode 100644 front-end/src/lib/pixi-tools-v2/utils/base64codingToolsLogo.ts
diff --git a/front-end/src/lib/pixi-tools-v2/utils/base64codingFactoryLogo.ts b/front-end/src/lib/pixi-tools-v2/utils/base64codingFactoryLogo.ts
new file mode 100644
index 000000000..6c5720912
--- /dev/null
+++ b/front-end/src/lib/pixi-tools-v2/utils/base64codingFactoryLogo.ts
@@ -0,0 +1,2 @@
+
+export const codingFactoryBase64 = 'data:image/png;base64,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'
\ No newline at end of file
diff --git a/front-end/src/lib/pixi-tools-v2/utils/base64codingToolsLogo.ts b/front-end/src/lib/pixi-tools-v2/utils/base64codingToolsLogo.ts
new file mode 100644
index 000000000..99119ebff
--- /dev/null
+++ b/front-end/src/lib/pixi-tools-v2/utils/base64codingToolsLogo.ts
@@ -0,0 +1,2 @@
+
+ export const codingToolsBase64 = 'data:image/png;base64,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'
\ No newline at end of file
diff --git a/front-end/src/lib/pixi-tools-v2/utils/generatePdf.ts b/front-end/src/lib/pixi-tools-v2/utils/generatePdf.ts
index 290dc860c..ec581a6fa 100644
--- a/front-end/src/lib/pixi-tools-v2/utils/generatePdf.ts
+++ b/front-end/src/lib/pixi-tools-v2/utils/generatePdf.ts
@@ -1,6 +1,8 @@
import { createPdf } from 'pdfmake/build/pdfmake';
import * as _ from 'pdfmake/build/vfs_fonts.js';
import { TypeBlueprintText } from '@/lib/pixi-tools-v2/types/pixi-enums';
+import { codingToolsBase64 } from './base64codingToolsLogo';
+import { codingFactoryBase64 } from './base64codingFactoryLogo';
const _fonts = globalThis.pdfMake.vfs ?? _.pdfMake.vfs;
@@ -15,39 +17,62 @@ export function exportToPdf(childImages) {
text: {
alignment: 'center',
},
+ logoLeft: {
+ marginBottom: 50,
+ },
+ logoRight: {
+ marginBottom: 50,
+ marginLeft: 100,
+ },
};
const data = {
content: [],
styles: styles
};
-
+ data.content.push({
+ columns: [
+ {
+ style: 'logoLeft',
+ image: codingToolsBase64,
+ width: 65,
+ height: 50,
+ },{
+ style: 'logo',
+ image: codingFactoryBase64,
+ width: 100,
+ height: 50,
+ }
+ ],
+ columnGap: 350,
+ })
for (let n = 0; n < childImages.length; n++) {
if (childImages[n].isBlueprint == true) {
if (childImages[n].typeBlueprint == 1) {
data.content.push({
style: 'text',
- text: TypeBlueprintText["1"]
+ text: TypeBlueprintText["1"],
+ width: 200,
})
} else if (childImages[n].typeBlueprint == 2) {
data.content.push({
style: 'text',
- text: TypeBlueprintText["2"]
+ text: TypeBlueprintText["2"],
})
} else if (childImages[n].typeBlueprint == 3) {
data.content.push({
style: 'text',
- text: TypeBlueprintText["3"]
+ text: TypeBlueprintText["3"],
})
} else if (childImages[n].typeBlueprint == 4) {
data.content.push({
style: 'text',
- text: TypeBlueprintText["4"]
+ text: TypeBlueprintText["4"],
})
} else if (childImages[n].typeBlueprint == 5) {
data.content.push({
style: 'text',
- text: TypeBlueprintText["5"]
+ text: TypeBlueprintText["5"],
})
} else {
}
@@ -56,6 +81,7 @@ export function exportToPdf(childImages) {
image: childImages[n].base64,
width: 520,
height: 300,
+
});
} else if (childImages[n].dimension.width > 520) {
data.content.push({