11
11
* Obeo - initial API and implementation
12
12
*******************************************************************************/
13
13
14
- import { DataExtension , useData } from '@eclipse-sirius/sirius-components-core' ;
15
14
import DragIndicatorIcon from '@mui/icons-material/DragIndicator' ;
16
15
import Box from '@mui/material/Box' ;
17
16
import Divider from '@mui/material/Divider' ;
18
17
import Paper from '@mui/material/Paper' ;
19
- import { Edge , Node , useReactFlow , useStoreApi , useViewport , XYPosition } from '@xyflow/react' ;
18
+ import { Edge , Node , useStoreApi , useViewport , XYPosition } from '@xyflow/react' ;
20
19
import React , { useEffect , useState } from 'react' ;
21
20
import Draggable , { DraggableData } from 'react-draggable' ;
22
21
import { makeStyles } from 'tss-react/mui' ;
23
22
import { EdgeData , NodeData } from '../DiagramRenderer.types' ;
24
23
import {
25
- DiagramPaletteToolContributionComponentProps ,
26
- DiagramPaletteToolContributionProps ,
27
- } from './DiagramPaletteToolContribution.types' ;
28
- import {
24
+ GQLPalette ,
29
25
GQLPaletteDivider ,
30
26
GQLPaletteEntry ,
31
27
GQLSingleClickOnDiagramElementTool ,
32
28
GQLToolSection ,
33
29
PaletteProps ,
34
30
PaletteStyleProps ,
35
31
} from './Palette.types' ;
36
- import { PaletteQuickAccessToolBar } from './tool-list /PaletteQuickAccessToolBar' ;
32
+ import { PaletteQuickAccessToolBar } from './quick-access-tool /PaletteQuickAccessToolBar' ;
37
33
import { PaletteToolList } from './tool-list/PaletteToolList' ;
38
- import { diagramPaletteToolExtensionPoint } from './tool/DiagramPaletteToolExtensionPoints' ;
39
34
import { usePalette } from './usePalette' ;
40
35
41
36
const usePaletteStyle = makeStyles < PaletteStyleProps > ( ) ( ( theme , props ) => ( {
@@ -78,18 +73,40 @@ const computeDraggableBounds = (bounds?: DOMRect): XYPosition => {
78
73
const paletteWidth = 200 ;
79
74
const paletteHeight = 275 ;
80
75
76
+ const getPaletteToolCount = ( palette : GQLPalette ) : number => {
77
+ return (
78
+ palette . paletteEntries . filter ( isSingleClickOnDiagramElementTool ) . length +
79
+ palette . quickAccessTools . filter ( isSingleClickOnDiagramElementTool ) . length +
80
+ palette . paletteEntries
81
+ . filter ( isToolSection )
82
+ . filter ( ( toolSection ) => toolSection . tools . filter ( isSingleClickOnDiagramElementTool ) . length > 0 ) . length
83
+ ) ;
84
+ } ;
85
+
86
+ const computePaletteLocation = (
87
+ paletteX : number ,
88
+ paletteY : number ,
89
+ viewportWidth : number ,
90
+ viewportHeight : number
91
+ ) : XYPosition => {
92
+ return {
93
+ x : paletteX + paletteWidth < viewportWidth ? paletteX : viewportWidth - paletteWidth ,
94
+ y : paletteY + paletteHeight < viewportHeight ? paletteY : viewportHeight - paletteHeight ,
95
+ } ;
96
+ } ;
97
+
81
98
export const Palette = ( {
82
99
x : paletteX ,
83
100
y : paletteY ,
84
101
diagramElementId,
85
102
targetObjectId,
86
103
onDirectEditClick,
87
- hideableDiagramElement,
88
104
} : PaletteProps ) => {
89
- const { getNodes, getEdges } = useReactFlow < Node < NodeData > , Edge < EdgeData > > ( ) ;
90
- const { domNode } = useStoreApi ( ) . getState ( ) ;
105
+ const { domNode, nodeLookup, edgeLookup } = useStoreApi < Node < NodeData > , Edge < EdgeData > > ( ) . getState ( ) ;
91
106
const { x : viewportWidth , y : viewportHeight } = computeDraggableBounds ( domNode ?. getBoundingClientRect ( ) ) ;
92
107
108
+ const diagramElement = nodeLookup . get ( diagramElementId ) || edgeLookup . get ( diagramElementId ) ;
109
+
93
110
const [ controlledPosition , setControlledPosition ] = useState < XYPosition > ( { x : 0 , y : 0 } ) ;
94
111
let x : number = 0 ;
95
112
let y : number = 0 ;
@@ -99,35 +116,16 @@ export const Palette = ({
99
116
y = ( paletteY - viewportY ) / viewportZoom ;
100
117
}
101
118
const { handleToolClick, palette } = usePalette ( { x, y, diagramElementId, onDirectEditClick, targetObjectId } ) ;
119
+
102
120
useEffect ( ( ) => {
103
121
const paletteLocation : XYPosition = computePaletteLocation ( paletteX , paletteY , viewportWidth , viewportHeight ) ;
104
122
setControlledPosition ( paletteLocation ) ;
105
123
} , [ paletteX , paletteY , viewportWidth , viewportHeight ] ) ;
106
124
107
- const paletteToolData : DataExtension < DiagramPaletteToolContributionProps [ ] > = useData (
108
- diagramPaletteToolExtensionPoint
109
- ) ;
110
-
111
- const diagramElement : Node < NodeData > | Edge < EdgeData > | undefined =
112
- getEdges ( ) . find ( ( edge ) => edge . id === diagramElementId ) ?? getNodes ( ) . find ( ( node ) => node . id === diagramElementId ) ;
113
-
114
- const paletteToolComponents : React . ComponentType < DiagramPaletteToolContributionComponentProps > [ ] = diagramElement
115
- ? paletteToolData . data . filter ( ( data ) => data . canHandle ( diagramElement ) ) . map ( ( data ) => data . component )
116
- : [ ] ;
117
-
118
- const toolCount =
119
- ( palette
120
- ? palette . paletteEntries . filter ( isSingleClickOnDiagramElementTool ) . length +
121
- palette . quickAccessTools . filter ( isSingleClickOnDiagramElementTool ) . length +
122
- palette . paletteEntries
123
- . filter ( isToolSection )
124
- . filter ( ( toolSection ) => toolSection . tools . filter ( isSingleClickOnDiagramElementTool ) . length > 0 ) . length
125
- : 0 ) +
126
- ( hideableDiagramElement ? ( diagramElement ? 3 : 1 ) : 0 ) +
127
- paletteToolComponents . length ;
128
125
const { classes } = usePaletteStyle ( { paletteWidth : `${ paletteWidth } px` , paletteHeight : `${ paletteHeight } px` } ) ;
129
126
130
- const shouldRender = palette && ( diagramElement || ( ! diagramElement && toolCount > 0 ) ) ;
127
+ const shouldRender = palette && ( getPaletteToolCount ( palette ) > 0 || ! ! diagramElement ) ;
128
+
131
129
if ( ! shouldRender ) {
132
130
return null ;
133
131
}
@@ -163,26 +161,12 @@ export const Palette = ({
163
161
< PaletteQuickAccessToolBar
164
162
diagramElementId = { diagramElementId }
165
163
onToolClick = { handleToolClick }
166
- diagramElement = { diagramElement ?? null }
167
164
quickAccessTools = { palette . quickAccessTools }
168
- paletteToolComponents = { paletteToolComponents }
169
165
x = { x }
170
166
y = { y }
171
- hideableDiagramElement = { hideableDiagramElement }
172
167
/>
173
168
< PaletteToolList palette = { palette } onToolClick = { handleToolClick } />
174
169
</ Paper >
175
170
</ Draggable >
176
171
) ;
177
172
} ;
178
- const computePaletteLocation = (
179
- paletteX : number ,
180
- paletteY : number ,
181
- viewportWidth : number ,
182
- viewportHeight : number
183
- ) : XYPosition => {
184
- return {
185
- x : paletteX + paletteWidth < viewportWidth ? paletteX : viewportWidth - paletteWidth ,
186
- y : paletteY + paletteHeight < viewportHeight ? paletteY : viewportHeight - paletteHeight ,
187
- } ;
188
- } ;
0 commit comments