791 lines
26 KiB
JavaScript
791 lines
26 KiB
JavaScript
import tinycolor from 'tinycolor2'
|
||
import { getSchemeColorFromTheme } from './schemeColor'
|
||
import {
|
||
applyShade,
|
||
applyTint,
|
||
applyLumOff,
|
||
applyLumMod,
|
||
applyHueMod,
|
||
applySatMod,
|
||
hslToRgb,
|
||
getColorName2Hex,
|
||
} from './color'
|
||
|
||
import {
|
||
base64ArrayBuffer,
|
||
getTextByPathList,
|
||
angleToDegrees,
|
||
escapeHtml,
|
||
getMimeType,
|
||
toHex,
|
||
} from './utils'
|
||
|
||
export function getFillType(node) {
|
||
let fillType = ''
|
||
if (node['a:noFill']) fillType = 'NO_FILL'
|
||
if (node['a:solidFill']) fillType = 'SOLID_FILL'
|
||
if (node['a:gradFill']) fillType = 'GRADIENT_FILL'
|
||
if (node['a:pattFill']) fillType = 'PATTERN_FILL'
|
||
if (node['a:blipFill']) fillType = 'PIC_FILL'
|
||
if (node['a:grpFill']) fillType = 'GROUP_FILL'
|
||
|
||
return fillType
|
||
}
|
||
|
||
export async function getPicFill(type, node, warpObj) {
|
||
if (!node) return ''
|
||
|
||
let img
|
||
const rId = getTextByPathList(node, ['a:blip', 'attrs', 'r:embed'])
|
||
let imgPath
|
||
if (type === 'slideBg' || type === 'slide') {
|
||
imgPath = getTextByPathList(warpObj, ['slideResObj', rId, 'target'])
|
||
}
|
||
else if (type === 'slideLayoutBg') {
|
||
imgPath = getTextByPathList(warpObj, ['layoutResObj', rId, 'target'])
|
||
}
|
||
else if (type === 'slideMasterBg') {
|
||
imgPath = getTextByPathList(warpObj, ['masterResObj', rId, 'target'])
|
||
}
|
||
else if (type === 'themeBg') {
|
||
imgPath = getTextByPathList(warpObj, ['themeResObj', rId, 'target'])
|
||
}
|
||
else if (type === 'diagramBg') {
|
||
imgPath = getTextByPathList(warpObj, ['diagramResObj', rId, 'target'])
|
||
}
|
||
if (!imgPath) return imgPath
|
||
|
||
img = getTextByPathList(warpObj, ['loaded-images', imgPath])
|
||
if (!img) {
|
||
imgPath = escapeHtml(imgPath)
|
||
|
||
const imgExt = imgPath.split('.').pop()
|
||
if (imgExt === 'xml') return ''
|
||
|
||
const imgArrayBuffer = await warpObj['zip'].file(imgPath).async('arraybuffer')
|
||
const imgMimeType = getMimeType(imgExt)
|
||
if (warpObj.mediaMode === 'blob' && typeof URL !== 'undefined' && typeof Blob !== 'undefined' && URL.createObjectURL) {
|
||
img = URL.createObjectURL(new Blob([imgArrayBuffer], { type: imgMimeType }))
|
||
} else {
|
||
img = `data:${imgMimeType};base64,${base64ArrayBuffer(imgArrayBuffer)}`
|
||
}
|
||
|
||
const loadedImages = warpObj['loaded-images'] || {}
|
||
loadedImages[imgPath] = img
|
||
warpObj['loaded-images'] = loadedImages
|
||
}
|
||
return img
|
||
}
|
||
|
||
export function getPicFillOpacity(node) {
|
||
const aBlipNode = node['a:blip']
|
||
|
||
const aphaModFixNode = getTextByPathList(aBlipNode, ['a:alphaModFix', 'attrs'])
|
||
let opacity = 1
|
||
if (aphaModFixNode && aphaModFixNode['amt'] && aphaModFixNode['amt'] !== '') {
|
||
opacity = parseInt(aphaModFixNode['amt']) / 100000
|
||
}
|
||
|
||
return opacity
|
||
}
|
||
|
||
export function getPicFilters(node) {
|
||
if (!node) return null
|
||
|
||
const aBlipNode = node['a:blip']
|
||
if (!aBlipNode) return null
|
||
|
||
const filters = {}
|
||
|
||
// 从a:extLst中获取滤镜效果（Microsoft Office 2010+扩展）
|
||
const extLstNode = aBlipNode['a:extLst']
|
||
if (extLstNode && extLstNode['a:ext']) {
|
||
const extNodes = Array.isArray(extLstNode['a:ext']) ? extLstNode['a:ext'] : [extLstNode['a:ext']]
|
||
|
||
for (const extNode of extNodes) {
|
||
if (!extNode['a14:imgProps'] || !extNode['a14:imgProps']['a14:imgLayer']) continue
|
||
|
||
const imgLayerNode = extNode['a14:imgProps']['a14:imgLayer']
|
||
const imgEffects = imgLayerNode['a14:imgEffect']
|
||
|
||
if (!imgEffects) continue
|
||
|
||
const effectArray = Array.isArray(imgEffects) ? imgEffects : [imgEffects]
|
||
|
||
for (const effect of effectArray) {
|
||
// 饱和度
|
||
if (effect['a14:saturation']) {
|
||
const satAttr = getTextByPathList(effect, ['a14:saturation', 'attrs', 'sat'])
|
||
if (satAttr) {
|
||
filters.saturation = parseInt(satAttr) / 100000
|
||
}
|
||
}
|
||
|
||
// 亮度、对比度
|
||
if (effect['a14:brightnessContrast']) {
|
||
const brightAttr = getTextByPathList(effect, ['a14:brightnessContrast', 'attrs', 'bright'])
|
||
const contrastAttr = getTextByPathList(effect, ['a14:brightnessContrast', 'attrs', 'contrast'])
|
||
|
||
if (brightAttr) {
|
||
filters.brightness = parseInt(brightAttr) / 100000
|
||
}
|
||
if (contrastAttr) {
|
||
filters.contrast = parseInt(contrastAttr) / 100000
|
||
}
|
||
}
|
||
|
||
// 锐化/柔化
|
||
if (effect['a14:sharpenSoften']) {
|
||
const amountAttr = getTextByPathList(effect, ['a14:sharpenSoften', 'attrs', 'amount'])
|
||
if (amountAttr) {
|
||
const amount = parseInt(amountAttr) / 100000
|
||
if (amount > 0) {
|
||
filters.sharpen = amount
|
||
}
|
||
else {
|
||
filters.soften = Math.abs(amount)
|
||
}
|
||
}
|
||
}
|
||
|
||
// 色温
|
||
if (effect['a14:colorTemperature']) {
|
||
const tempAttr = getTextByPathList(effect, ['a14:colorTemperature', 'attrs', 'colorTemp'])
|
||
if (tempAttr) {
|
||
filters.colorTemperature = parseInt(tempAttr)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return Object.keys(filters).length > 0 ? filters : null
|
||
}
|
||
|
||
export async function getBgPicFill(bgPr, sorce, warpObj) {
|
||
const picBase64 = await getPicFill(sorce, bgPr['a:blipFill'], warpObj)
|
||
const aBlipNode = bgPr['a:blipFill']['a:blip']
|
||
|
||
const aphaModFixNode = getTextByPathList(aBlipNode, ['a:alphaModFix', 'attrs'])
|
||
let opacity = 1
|
||
if (aphaModFixNode && aphaModFixNode['amt'] && aphaModFixNode['amt'] !== '') {
|
||
opacity = parseInt(aphaModFixNode['amt']) / 100000
|
||
}
|
||
|
||
return {
|
||
picBase64,
|
||
opacity,
|
||
}
|
||
}
|
||
|
||
export function getGradientFill(node, warpObj) {
|
||
const gsLst = node['a:gsLst']['a:gs']
|
||
const colors = []
|
||
for (let i = 0; i < gsLst.length; i++) {
|
||
const lo_color = getSolidFill(gsLst[i], undefined, undefined, warpObj)
|
||
const pos = getTextByPathList(gsLst[i], ['attrs', 'pos'])
|
||
|
||
colors[i] = {
|
||
pos: pos ? (pos / 1000 + '%') : '',
|
||
color: lo_color,
|
||
}
|
||
}
|
||
const lin = node['a:lin']
|
||
let rot = 0
|
||
let pathType = 'line'
|
||
if (lin) rot = angleToDegrees(lin['attrs']['ang'])
|
||
else {
|
||
const path = node['a:path']
|
||
if (path && path['attrs'] && path['attrs']['path']) pathType = path['attrs']['path']
|
||
}
|
||
return {
|
||
rot,
|
||
path: pathType,
|
||
colors: colors.sort((a, b) => parseInt(a.pos) - parseInt(b.pos)),
|
||
}
|
||
}
|
||
|
||
export function getPatternFill(node, warpObj) {
|
||
if (!node) return null
|
||
|
||
const pattFill = node['a:pattFill']
|
||
if (!pattFill) return null
|
||
|
||
const type = getTextByPathList(pattFill, ['attrs', 'prst'])
|
||
|
||
const fgColorNode = pattFill['a:fgClr']
|
||
const bgColorNode = pattFill['a:bgClr']
|
||
|
||
let foregroundColor = '#000000'
|
||
let backgroundColor = '#FFFFFF'
|
||
|
||
if (fgColorNode) {
|
||
foregroundColor = getSolidFill(fgColorNode, undefined, undefined, warpObj)
|
||
}
|
||
|
||
if (bgColorNode) {
|
||
backgroundColor = getSolidFill(bgColorNode, undefined, undefined, warpObj)
|
||
}
|
||
|
||
return {
|
||
type,
|
||
foregroundColor,
|
||
backgroundColor,
|
||
}
|
||
}
|
||
|
||
export function getBgGradientFill(bgPr, phClr, slideMasterContent, warpObj) {
|
||
if (bgPr) {
|
||
const grdFill = bgPr['a:gradFill']
|
||
const gsLst = grdFill['a:gsLst']['a:gs']
|
||
const colors = []
|
||
|
||
for (let i = 0; i < gsLst.length; i++) {
|
||
const lo_color = getSolidFill(gsLst[i], slideMasterContent['p:sldMaster']['p:clrMap']['attrs'], phClr, warpObj)
|
||
const pos = getTextByPathList(gsLst[i], ['attrs', 'pos'])
|
||
|
||
colors[i] = {
|
||
pos: pos ? (pos / 1000 + '%') : '',
|
||
color: lo_color,
|
||
}
|
||
}
|
||
const lin = grdFill['a:lin']
|
||
let rot = 0
|
||
let pathType = 'line'
|
||
if (lin) rot = angleToDegrees(lin['attrs']['ang']) + 0
|
||
else {
|
||
const path = grdFill['a:path']
|
||
if (path && path['attrs'] && path['attrs']['path']) pathType = path['attrs']['path']
|
||
}
|
||
return {
|
||
rot,
|
||
path: pathType,
|
||
colors: colors.sort((a, b) => parseInt(a.pos) - parseInt(b.pos)),
|
||
}
|
||
}
|
||
else if (phClr) {
|
||
return phClr.indexOf('#') === -1 ? `#${phClr}` : phClr
|
||
}
|
||
return null
|
||
}
|
||
|
||
export async function getSlideBackgroundFill(warpObj) {
|
||
const slideContent = warpObj['slideContent']
|
||
const slideLayoutContent = warpObj['slideLayoutContent']
|
||
const slideMasterContent = warpObj['slideMasterContent']
|
||
|
||
let bgPr = getTextByPathList(slideContent, ['p:sld', 'p:cSld', 'p:bg', 'p:bgPr'])
|
||
let bgRef = getTextByPathList(slideContent, ['p:sld', 'p:cSld', 'p:bg', 'p:bgRef'])
|
||
|
||
let background = '#fff'
|
||
let backgroundType = 'color'
|
||
|
||
if (bgPr) {
|
||
const bgFillTyp = getFillType(bgPr)
|
||
|
||
if (bgFillTyp === 'SOLID_FILL') {
|
||
const sldFill = bgPr['a:solidFill']
|
||
let clrMapOvr
|
||
const sldClrMapOvr = getTextByPathList(slideContent, ['p:sld', 'p:clrMapOvr', 'a:overrideClrMapping', 'attrs'])
|
||
if (sldClrMapOvr) clrMapOvr = sldClrMapOvr
|
||
else {
|
||
const sldClrMapOvr = getTextByPathList(slideLayoutContent, ['p:sldLayout', 'p:clrMapOvr', 'a:overrideClrMapping', 'attrs'])
|
||
if (sldClrMapOvr) clrMapOvr = sldClrMapOvr
|
||
else clrMapOvr = getTextByPathList(slideMasterContent, ['p:sldMaster', 'p:clrMap', 'attrs'])
|
||
}
|
||
const sldBgClr = getSolidFill(sldFill, clrMapOvr, undefined, warpObj)
|
||
background = sldBgClr
|
||
}
|
||
else if (bgFillTyp === 'GRADIENT_FILL') {
|
||
const gradientFill = getBgGradientFill(bgPr, undefined, slideMasterContent, warpObj)
|
||
if (typeof gradientFill === 'string') {
|
||
background = gradientFill
|
||
}
|
||
else if (gradientFill) {
|
||
background = gradientFill
|
||
backgroundType = 'gradient'
|
||
}
|
||
}
|
||
else if (bgFillTyp === 'PIC_FILL') {
|
||
background = await getBgPicFill(bgPr, 'slideBg', warpObj)
|
||
backgroundType = 'image'
|
||
}
|
||
else if (bgFillTyp === 'PATTERN_FILL') {
|
||
const patternFill = getPatternFill(bgPr, warpObj)
|
||
if (patternFill) {
|
||
background = patternFill
|
||
backgroundType = 'pattern'
|
||
}
|
||
}
|
||
}
|
||
else if (bgRef) {
|
||
let clrMapOvr
|
||
const sldClrMapOvr = getTextByPathList(slideContent, ['p:sld', 'p:clrMapOvr', 'a:overrideClrMapping', 'attrs'])
|
||
if (sldClrMapOvr) clrMapOvr = sldClrMapOvr
|
||
else {
|
||
const sldClrMapOvr = getTextByPathList(slideLayoutContent, ['p:sldLayout', 'p:clrMapOvr', 'a:overrideClrMapping', 'attrs'])
|
||
if (sldClrMapOvr) clrMapOvr = sldClrMapOvr
|
||
else clrMapOvr = getTextByPathList(slideMasterContent, ['p:sldMaster', 'p:clrMap', 'attrs'])
|
||
}
|
||
const phClr = getSolidFill(bgRef, clrMapOvr, undefined, warpObj)
|
||
const idx = Number(bgRef['attrs']['idx'])
|
||
|
||
if (idx > 1000) {
|
||
const trueIdx = idx - 1000
|
||
const bgFillLst = warpObj['themeContent']['a:theme']['a:themeElements']['a:fmtScheme']['a:bgFillStyleLst']
|
||
const sortblAry = []
|
||
Object.keys(bgFillLst).forEach(key => {
|
||
const bgFillLstTyp = bgFillLst[key]
|
||
if (key !== 'attrs') {
|
||
if (bgFillLstTyp.constructor === Array) {
|
||
for (let i = 0; i < bgFillLstTyp.length; i++) {
|
||
const obj = {}
|
||
obj[key] = bgFillLstTyp[i]
|
||
if (bgFillLstTyp[i]['attrs']) {
|
||
obj['idex'] = bgFillLstTyp[i]['attrs']['order']
|
||
obj['attrs'] = {
|
||
'order': bgFillLstTyp[i]['attrs']['order']
|
||
}
|
||
}
|
||
sortblAry.push(obj)
|
||
}
|
||
}
|
||
else {
|
||
const obj = {}
|
||
obj[key] = bgFillLstTyp
|
||
if (bgFillLstTyp['attrs']) {
|
||
obj['idex'] = bgFillLstTyp['attrs']['order']
|
||
obj['attrs'] = {
|
||
'order': bgFillLstTyp['attrs']['order']
|
||
}
|
||
}
|
||
sortblAry.push(obj)
|
||
}
|
||
}
|
||
})
|
||
const sortByOrder = sortblAry.slice(0)
|
||
sortByOrder.sort((a, b) => a.idex - b.idex)
|
||
const bgFillLstIdx = sortByOrder[trueIdx - 1]
|
||
const bgFillTyp = getFillType(bgFillLstIdx)
|
||
if (bgFillTyp === 'SOLID_FILL') {
|
||
const sldFill = bgFillLstIdx['a:solidFill']
|
||
const sldBgClr = getSolidFill(sldFill, clrMapOvr, undefined, warpObj)
|
||
background = sldBgClr
|
||
}
|
||
else if (bgFillTyp === 'GRADIENT_FILL') {
|
||
const gradientFill = getBgGradientFill(bgFillLstIdx, phClr, slideMasterContent, warpObj)
|
||
if (typeof gradientFill === 'string') {
|
||
background = gradientFill
|
||
}
|
||
else if (gradientFill) {
|
||
background = gradientFill
|
||
backgroundType = 'gradient'
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
bgPr = getTextByPathList(slideLayoutContent, ['p:sldLayout', 'p:cSld', 'p:bg', 'p:bgPr'])
|
||
bgRef = getTextByPathList(slideLayoutContent, ['p:sldLayout', 'p:cSld', 'p:bg', 'p:bgRef'])
|
||
|
||
let clrMapOvr
|
||
const sldClrMapOvr = getTextByPathList(slideLayoutContent, ['p:sldLayout', 'p:clrMapOvr', 'a:overrideClrMapping', 'attrs'])
|
||
if (sldClrMapOvr) clrMapOvr = sldClrMapOvr
|
||
else clrMapOvr = getTextByPathList(slideMasterContent, ['p:sldMaster', 'p:clrMap', 'attrs'])
|
||
|
||
if (bgPr) {
|
||
const bgFillTyp = getFillType(bgPr)
|
||
if (bgFillTyp === 'SOLID_FILL') {
|
||
const sldFill = bgPr['a:solidFill']
|
||
const sldBgClr = getSolidFill(sldFill, clrMapOvr, undefined, warpObj)
|
||
background = sldBgClr
|
||
}
|
||
else if (bgFillTyp === 'GRADIENT_FILL') {
|
||
const gradientFill = getBgGradientFill(bgPr, undefined, slideMasterContent, warpObj)
|
||
if (typeof gradientFill === 'string') {
|
||
background = gradientFill
|
||
}
|
||
else if (gradientFill) {
|
||
background = gradientFill
|
||
backgroundType = 'gradient'
|
||
}
|
||
}
|
||
else if (bgFillTyp === 'PIC_FILL') {
|
||
background = await getBgPicFill(bgPr, 'slideLayoutBg', warpObj)
|
||
backgroundType = 'image'
|
||
}
|
||
else if (bgFillTyp === 'PATTERN_FILL') {
|
||
const patternFill = getPatternFill(bgPr, warpObj)
|
||
if (patternFill) {
|
||
background = patternFill
|
||
backgroundType = 'pattern'
|
||
}
|
||
}
|
||
}
|
||
else if (bgRef) {
|
||
const phClr = getSolidFill(bgRef, clrMapOvr, undefined, warpObj)
|
||
const idx = Number(bgRef['attrs']['idx'])
|
||
|
||
if (idx > 1000) {
|
||
const trueIdx = idx - 1000
|
||
const bgFillLst = warpObj['themeContent']['a:theme']['a:themeElements']['a:fmtScheme']['a:bgFillStyleLst']
|
||
const sortblAry = []
|
||
Object.keys(bgFillLst).forEach(key => {
|
||
const bgFillLstTyp = bgFillLst[key]
|
||
if (key !== 'attrs') {
|
||
if (bgFillLstTyp.constructor === Array) {
|
||
for (let i = 0; i < bgFillLstTyp.length; i++) {
|
||
const obj = {}
|
||
obj[key] = bgFillLstTyp[i]
|
||
if (bgFillLstTyp[i]['attrs']) {
|
||
obj['idex'] = bgFillLstTyp[i]['attrs']['order']
|
||
obj['attrs'] = {
|
||
'order': bgFillLstTyp[i]['attrs']['order']
|
||
}
|
||
}
|
||
sortblAry.push(obj)
|
||
}
|
||
}
|
||
else {
|
||
const obj = {}
|
||
obj[key] = bgFillLstTyp
|
||
if (bgFillLstTyp['attrs']) {
|
||
obj['idex'] = bgFillLstTyp['attrs']['order']
|
||
obj['attrs'] = {
|
||
'order': bgFillLstTyp['attrs']['order']
|
||
}
|
||
}
|
||
sortblAry.push(obj)
|
||
}
|
||
}
|
||
})
|
||
const sortByOrder = sortblAry.slice(0)
|
||
sortByOrder.sort((a, b) => a.idex - b.idex)
|
||
const bgFillLstIdx = sortByOrder[trueIdx - 1]
|
||
const bgFillTyp = getFillType(bgFillLstIdx)
|
||
if (bgFillTyp === 'SOLID_FILL') {
|
||
const sldFill = bgFillLstIdx['a:solidFill']
|
||
const sldBgClr = getSolidFill(sldFill, clrMapOvr, undefined, warpObj)
|
||
background = sldBgClr
|
||
}
|
||
else if (bgFillTyp === 'GRADIENT_FILL') {
|
||
const gradientFill = getBgGradientFill(bgFillLstIdx, phClr, slideMasterContent, warpObj)
|
||
if (typeof gradientFill === 'string') {
|
||
background = gradientFill
|
||
}
|
||
else if (gradientFill) {
|
||
background = gradientFill
|
||
backgroundType = 'gradient'
|
||
}
|
||
}
|
||
else if (bgFillTyp === 'PIC_FILL') {
|
||
background = await getBgPicFill(bgFillLstIdx, 'themeBg', warpObj)
|
||
backgroundType = 'image'
|
||
}
|
||
else if (bgFillTyp === 'PATTERN_FILL') {
|
||
const patternFill = getPatternFill(bgFillLstIdx, warpObj)
|
||
if (patternFill) {
|
||
background = patternFill
|
||
backgroundType = 'pattern'
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
bgPr = getTextByPathList(slideMasterContent, ['p:sldMaster', 'p:cSld', 'p:bg', 'p:bgPr'])
|
||
bgRef = getTextByPathList(slideMasterContent, ['p:sldMaster', 'p:cSld', 'p:bg', 'p:bgRef'])
|
||
|
||
const clrMap = getTextByPathList(slideMasterContent, ['p:sldMaster', 'p:clrMap', 'attrs'])
|
||
if (bgPr) {
|
||
const bgFillTyp = getFillType(bgPr)
|
||
if (bgFillTyp === 'SOLID_FILL') {
|
||
const sldFill = bgPr['a:solidFill']
|
||
const sldBgClr = getSolidFill(sldFill, clrMap, undefined, warpObj)
|
||
background = sldBgClr
|
||
}
|
||
else if (bgFillTyp === 'GRADIENT_FILL') {
|
||
const gradientFill = getBgGradientFill(bgPr, undefined, slideMasterContent, warpObj)
|
||
if (typeof gradientFill === 'string') {
|
||
background = gradientFill
|
||
}
|
||
else if (gradientFill) {
|
||
background = gradientFill
|
||
backgroundType = 'gradient'
|
||
}
|
||
}
|
||
else if (bgFillTyp === 'PIC_FILL') {
|
||
background = await getBgPicFill(bgPr, 'slideMasterBg', warpObj)
|
||
backgroundType = 'image'
|
||
}
|
||
else if (bgFillTyp === 'PATTERN_FILL') {
|
||
const patternFill = getPatternFill(bgPr, warpObj)
|
||
if (patternFill) {
|
||
background = patternFill
|
||
backgroundType = 'pattern'
|
||
}
|
||
}
|
||
}
|
||
else if (bgRef) {
|
||
const phClr = getSolidFill(bgRef, clrMap, undefined, warpObj)
|
||
const idx = Number(bgRef['attrs']['idx'])
|
||
|
||
if (idx > 1000) {
|
||
const trueIdx = idx - 1000
|
||
const bgFillLst = warpObj['themeContent']['a:theme']['a:themeElements']['a:fmtScheme']['a:bgFillStyleLst']
|
||
const sortblAry = []
|
||
Object.keys(bgFillLst).forEach(key => {
|
||
const bgFillLstTyp = bgFillLst[key]
|
||
if (key !== 'attrs') {
|
||
if (bgFillLstTyp.constructor === Array) {
|
||
for (let i = 0; i < bgFillLstTyp.length; i++) {
|
||
const obj = {}
|
||
obj[key] = bgFillLstTyp[i]
|
||
if (bgFillLstTyp[i]['attrs']) {
|
||
obj['idex'] = bgFillLstTyp[i]['attrs']['order']
|
||
obj['attrs'] = {
|
||
'order': bgFillLstTyp[i]['attrs']['order']
|
||
}
|
||
}
|
||
sortblAry.push(obj)
|
||
}
|
||
}
|
||
else {
|
||
const obj = {}
|
||
obj[key] = bgFillLstTyp
|
||
if (bgFillLstTyp['attrs']) {
|
||
obj['idex'] = bgFillLstTyp['attrs']['order']
|
||
obj['attrs'] = {
|
||
'order': bgFillLstTyp['attrs']['order']
|
||
}
|
||
}
|
||
sortblAry.push(obj)
|
||
}
|
||
}
|
||
})
|
||
const sortByOrder = sortblAry.slice(0)
|
||
sortByOrder.sort((a, b) => a.idex - b.idex)
|
||
const bgFillLstIdx = sortByOrder[trueIdx - 1]
|
||
const bgFillTyp = getFillType(bgFillLstIdx)
|
||
if (bgFillTyp === 'SOLID_FILL') {
|
||
const sldFill = bgFillLstIdx['a:solidFill']
|
||
const sldBgClr = getSolidFill(sldFill, clrMapOvr, undefined, warpObj)
|
||
background = sldBgClr
|
||
}
|
||
else if (bgFillTyp === 'GRADIENT_FILL') {
|
||
const gradientFill = getBgGradientFill(bgFillLstIdx, phClr, slideMasterContent, warpObj)
|
||
if (typeof gradientFill === 'string') {
|
||
background = gradientFill
|
||
}
|
||
else if (gradientFill) {
|
||
background = gradientFill
|
||
backgroundType = 'gradient'
|
||
}
|
||
}
|
||
else if (bgFillTyp === 'PIC_FILL') {
|
||
background = await getBgPicFill(bgFillLstIdx, 'themeBg', warpObj)
|
||
backgroundType = 'image'
|
||
}
|
||
else if (bgFillTyp === 'PATTERN_FILL') {
|
||
const patternFill = getPatternFill(bgFillLstIdx, warpObj)
|
||
if (patternFill) {
|
||
background = patternFill
|
||
backgroundType = 'pattern'
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return {
|
||
type: backgroundType,
|
||
value: background,
|
||
}
|
||
}
|
||
|
||
export async function getShapeFill(node, warpObj, source, groupHierarchy = []) {
|
||
const fillType = getFillType(getTextByPathList(node, ['p:spPr']))
|
||
let type = 'color'
|
||
let fillValue = ''
|
||
if (fillType === 'NO_FILL') {
|
||
return null
|
||
}
|
||
else if (fillType === 'SOLID_FILL') {
|
||
const shpFill = node['p:spPr']['a:solidFill']
|
||
fillValue = getSolidFill(shpFill, undefined, undefined, warpObj)
|
||
type = 'color'
|
||
}
|
||
else if (fillType === 'GRADIENT_FILL') {
|
||
const shpFill = node['p:spPr']['a:gradFill']
|
||
fillValue = getGradientFill(shpFill, warpObj)
|
||
type = 'gradient'
|
||
}
|
||
else if (fillType === 'PIC_FILL') {
|
||
const shpFill = node['p:spPr']['a:blipFill']
|
||
const picBase64 = await getPicFill(source, shpFill, warpObj)
|
||
const opacity = getPicFillOpacity(shpFill)
|
||
fillValue = {
|
||
picBase64,
|
||
opacity,
|
||
}
|
||
type = 'image'
|
||
}
|
||
else if (fillType === 'PATTERN_FILL') {
|
||
const shpFill = node['p:spPr']['a:pattFill']
|
||
fillValue = getPatternFill({ 'a:pattFill': shpFill }, warpObj)
|
||
type = 'pattern'
|
||
}
|
||
else if (fillType === 'GROUP_FILL') {
|
||
return findFillInGroupHierarchy(groupHierarchy, warpObj, source)
|
||
}
|
||
if (!fillValue) {
|
||
const clrName = getTextByPathList(node, ['p:style', 'a:fillRef'])
|
||
fillValue = getSolidFill(clrName, undefined, undefined, warpObj)
|
||
type = 'color'
|
||
}
|
||
if (!fillValue) {
|
||
return null
|
||
}
|
||
|
||
return {
|
||
type,
|
||
value: fillValue,
|
||
}
|
||
}
|
||
|
||
async function findFillInGroupHierarchy(groupHierarchy, warpObj, source) {
|
||
for (const groupNode of groupHierarchy) {
|
||
if (!groupNode || !groupNode['p:grpSpPr']) continue
|
||
|
||
const grpSpPr = groupNode['p:grpSpPr']
|
||
const fillType = getFillType(grpSpPr)
|
||
|
||
if (fillType === 'SOLID_FILL') {
|
||
const shpFill = grpSpPr['a:solidFill']
|
||
const fillValue = getSolidFill(shpFill, undefined, undefined, warpObj)
|
||
if (fillValue) {
|
||
return {
|
||
type: 'color',
|
||
value: fillValue,
|
||
}
|
||
}
|
||
}
|
||
else if (fillType === 'GRADIENT_FILL') {
|
||
const shpFill = grpSpPr['a:gradFill']
|
||
const fillValue = getGradientFill(shpFill, warpObj)
|
||
if (fillValue) {
|
||
return {
|
||
type: 'gradient',
|
||
value: fillValue,
|
||
}
|
||
}
|
||
}
|
||
else if (fillType === 'PIC_FILL') {
|
||
const shpFill = grpSpPr['a:blipFill']
|
||
const picBase64 = await getPicFill(source, shpFill, warpObj)
|
||
const opacity = getPicFillOpacity(shpFill)
|
||
if (picBase64) {
|
||
return {
|
||
type: 'image',
|
||
value: {
|
||
picBase64,
|
||
opacity,
|
||
},
|
||
}
|
||
}
|
||
}
|
||
else if (fillType === 'PATTERN_FILL') {
|
||
const shpFill = grpSpPr['a:pattFill']
|
||
const fillValue = getPatternFill({ 'a:pattFill': shpFill }, warpObj)
|
||
if (fillValue) {
|
||
return {
|
||
type: 'pattern',
|
||
value: fillValue,
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return null
|
||
}
|
||
|
||
export function getSolidFill(solidFill, clrMap, phClr, warpObj) {
|
||
if (!solidFill) return ''
|
||
|
||
let color = ''
|
||
let clrNode
|
||
|
||
if (solidFill['a:srgbClr']) {
|
||
clrNode = solidFill['a:srgbClr']
|
||
color = getTextByPathList(clrNode, ['attrs', 'val'])
|
||
}
|
||
else if (solidFill['a:schemeClr']) {
|
||
clrNode = solidFill['a:schemeClr']
|
||
const schemeClr = 'a:' + getTextByPathList(clrNode, ['attrs', 'val'])
|
||
color = getSchemeColorFromTheme(schemeClr, warpObj, clrMap, phClr) || ''
|
||
}
|
||
else if (solidFill['a:scrgbClr']) {
|
||
clrNode = solidFill['a:scrgbClr']
|
||
const defBultColorVals = clrNode['attrs']
|
||
const red = (defBultColorVals['r'].indexOf('%') !== -1) ? defBultColorVals['r'].split('%').shift() : defBultColorVals['r']
|
||
const green = (defBultColorVals['g'].indexOf('%') !== -1) ? defBultColorVals['g'].split('%').shift() : defBultColorVals['g']
|
||
const blue = (defBultColorVals['b'].indexOf('%') !== -1) ? defBultColorVals['b'].split('%').shift() : defBultColorVals['b']
|
||
color = toHex(255 * (Number(red) / 100)) + toHex(255 * (Number(green) / 100)) + toHex(255 * (Number(blue) / 100))
|
||
}
|
||
else if (solidFill['a:prstClr']) {
|
||
clrNode = solidFill['a:prstClr']
|
||
const prstClr = getTextByPathList(clrNode, ['attrs', 'val'])
|
||
color = getColorName2Hex(prstClr)
|
||
}
|
||
else if (solidFill['a:hslClr']) {
|
||
clrNode = solidFill['a:hslClr']
|
||
const defBultColorVals = clrNode['attrs']
|
||
const hue = Number(defBultColorVals['hue']) / 100000
|
||
const sat = Number((defBultColorVals['sat'].indexOf('%') !== -1) ? defBultColorVals['sat'].split('%').shift() : defBultColorVals['sat']) / 100
|
||
const lum = Number((defBultColorVals['lum'].indexOf('%') !== -1) ? defBultColorVals['lum'].split('%').shift() : defBultColorVals['lum']) / 100
|
||
const hsl2rgb = hslToRgb(hue, sat, lum)
|
||
color = toHex(hsl2rgb.r) + toHex(hsl2rgb.g) + toHex(hsl2rgb.b)
|
||
}
|
||
else if (solidFill['a:sysClr']) {
|
||
clrNode = solidFill['a:sysClr']
|
||
const sysClr = getTextByPathList(clrNode, ['attrs', 'lastClr'])
|
||
if (sysClr) color = sysClr
|
||
}
|
||
|
||
let isAlpha = false
|
||
const alpha = parseInt(getTextByPathList(clrNode, ['a:alpha', 'attrs', 'val'])) / 100000
|
||
if (!isNaN(alpha)) {
|
||
const al_color = tinycolor(color)
|
||
al_color.setAlpha(alpha)
|
||
color = al_color.toHex8()
|
||
isAlpha = true
|
||
}
|
||
|
||
const hueMod = parseInt(getTextByPathList(clrNode, ['a:hueMod', 'attrs', 'val'])) / 100000
|
||
if (!isNaN(hueMod)) {
|
||
color = applyHueMod(color, hueMod, isAlpha)
|
||
}
|
||
const lumMod = parseInt(getTextByPathList(clrNode, ['a:lumMod', 'attrs', 'val'])) / 100000
|
||
if (!isNaN(lumMod)) {
|
||
color = applyLumMod(color, lumMod, isAlpha)
|
||
}
|
||
const lumOff = parseInt(getTextByPathList(clrNode, ['a:lumOff', 'attrs', 'val'])) / 100000
|
||
if (!isNaN(lumOff)) {
|
||
color = applyLumOff(color, lumOff, isAlpha)
|
||
}
|
||
const satMod = parseInt(getTextByPathList(clrNode, ['a:satMod', 'attrs', 'val'])) / 100000
|
||
if (!isNaN(satMod)) {
|
||
color = applySatMod(color, satMod, isAlpha)
|
||
}
|
||
const shade = parseInt(getTextByPathList(clrNode, ['a:shade', 'attrs', 'val'])) / 100000
|
||
if (!isNaN(shade)) {
|
||
color = applyShade(color, shade, isAlpha)
|
||
}
|
||
const tint = parseInt(getTextByPathList(clrNode, ['a:tint', 'attrs', 'val'])) / 100000
|
||
if (!isNaN(tint)) {
|
||
color = applyTint(color, tint, isAlpha)
|
||
}
|
||
|
||
if (color && color.indexOf('#') === -1) color = '#' + color
|
||
|
||
return color
|
||
} |