कैसे एक अच्छे युवा आदमी की कहानी तीन सिर वाले सांप से लड़ती है, या एडोब इनडिजाइन डॉक्यूमेंट्स में एसवीजी ग्राफिक्स कैसे एम्बेड करें - भाग एक

सभी हैब्रज़िटेल को बधाई!
पहले थोड़ा विषयांतर। यह पोस्ट मेरे द्वारा नहीं लिखी गई थी, लेकिन फिर भी अप्रतिष्ठित अपडेट द्वारा: viklequick पहले से ही पहले से ही जिद्दी है , और, मेरी राय में, सभी परिणामों के साथ आपका ध्यान आकर्षित करता है। इसलिए ...

आवाज़ का उतार-चढ़ाव

ठंड के मौसम में एक बार, लेखक ईपीएस प्रारूप में वेक्टर चित्रों के साथ लड़ने के लिए अच्छे साथी से थक गए। और उन्होंने एसवीजी के रूप में एडोब इनडिजाइन दस्तावेजों में प्रगति और ग्राफ और चार्ट को एम्बेड करने का निर्णय लिया। और फिर उसके लिए एक बड़ी निराशा होती है, क्योंकि Adobe Systems अपने Adobe Flash को पसंद करता है, और Adobe InDesign SVG समर्थन अनुपस्थित है। हालांकि, अच्छे साथी ने इनडिजाइन के लिए प्लग-इन बनाने में उल्लेखनीय अनुभव जमा किया है, और उन्होंने अपने शक्तिशाली वीर का उपयोग करने और तीन-सिर वाले हाइड्रा को लेने का फैसला किया। योद्धा ने कहा - योद्धा ने किया, अर्थात् - उसने लिया।
इस संघर्ष के विवरण के बारे में और हम अपनी कहानी का नेतृत्व करेंगे।

कहानी

चरण एक, या ट्राइसेप्स हाइड्रा के एनाटॉमी का अध्ययन करें

आरंभ करने के लिए, आपको संक्षेप में उल्लेख करना होगा कि InDesign चित्रों के साथ कैसे काम करता है।
InDesign के दृष्टिकोण से, चित्र एक विशेष प्रकार का PageItem है जो स्वयं आकर्षित और प्रिंट कर सकता है। और इस पेज को पेज पर डाला जा सकता है, या तो एक फ्रेम में या टेबल सेल में इनलाइन के रूप में, और यह सब संभाला जाना चाहिए। और फिर भी, तीन प्रकार के प्रतिपादन हैं - तेज (एक पार आयत खींची गई है), इष्टतम (रेखापुंज छद्म छवि), और पूर्ण (धीमा)। इस सब का समर्थन करना भी आवश्यक है।
इस प्रकार, हमारे पास आयात प्लग-इन, पृष्ठ आइटम, और कई सहायक कक्षाएं हैं, जो इस प्रकार हैं:

  वर्ग
 {
   kSVGItem,
   kDisplayListPageItemBoss,
   {
     IID_ISHAPE, kSVGShapeImpl,
     IID_IINKRESOURCES, kAllProcessInkResourcesImpl,
     IID_IFLATTENERUSAGE, kSVGItemFlattenerUsageImpl,
     IID_IVISITORHELPER, kEPSItemVisitorHelperImpl,
     IID_ISCRIPT, kSVGItemScriptImpl,
   }
 }

और इतना:

Class
{
kSVGPlaceProviderBoss,
kInvalidClass,
{
IID_IK2SERVICEPROVIDER, kImportServiceImpl,
IID_IIMPORTPROVIDER, kSVGPlaceProviderImpl,
IID_IIMPORTPREVIEW, kSVGImportPreviewImpl,
}
},


और, ज़ाहिर है, स्टार्टअप / शटडाउन के लिए एक मानक हेडर भी है, जो लाने के लिए समझ में नहीं आता है।
आइए देखें कि यह क्या है और क्यों है।
• IID_ISHAPE वास्तविक पृष्ठ आइटम का कार्यान्वयन है जो प्रतिपादन प्रदान करता है।
• IID_IINKRESOURCES - हम बाहरी फ़ाइलों (इंक) से लिंक की प्रक्रिया करते हैं।
• IID_IFLATTENERUSAGE - हम पीडीएफ में अल्फा चैनल रेखांकन की प्रक्रिया करते हैं। दरअसल, यह एक ऐसी रेखा है जिसमें स्पष्ट रूप से एक चपटे को शामिल करने की आवश्यकता होती है, और अधिक कुछ नहीं।
• IID_IVISITORHELPER - इसे EPS से उधार लेकर मानक रखें।
• IID_ISCRIPT - हम स्क्रिप्टिंग के माध्यम से अपने तत्व के लिए समर्थन प्रदान करते हैं। यह भी एक बहुत ही सरल हिस्सा है, बस वस्तु के प्रकार को सही ढंग से निर्दिष्ट करता है।
• IID_IK2SERVICEPROVIDER और IID_IIMPORTPROVIDER - प्लेस कमांड के लिए समर्थन जोड़ें।
• IID_IIMPORTPREVIEW - और फ़ाइल चयन संवाद (विंडोज विशिष्ट) में एक पूर्वावलोकन प्रदान करें।
सबसे दिलचस्प वास्तव में IID_ISHAPE है, यह हमारे प्लगइन का दिल है। उसे सीधे IGraphicsPort का उपयोग करके खुद को खींचने की क्षमता की आवश्यकता होती है, साथ ही साथ एक रास्टर प्रॉक्सी छवि प्राप्त करना। आगे देखते हुए, मैं ध्यान देना चाहता हूं - पर्याप्त आश्चर्य थे।

दो कदम, या एक वीर तलवार चुनें

एक्सप्रेस googling, साथ ही OpenClipArt से नमूना छवियों को देखने से मुझे अपाचे बाटिक में रहने के बारे में सोचा। मुझे तुरंत कहना होगा कि मुझे बाटिक को ठीक करने के लिए कुछ प्रयास करने थे, लेकिन अंत में वे बेहूदा निकले। यह मूल रूप से "सामग्री द्वारा एसवीजी के संस्करण का अनुमान लगाने के लिए" उबला हुआ था। हालांकि, कार्य "IGraphicsPort के साथ एक तस्वीर कैसे खींचना है" कार्य बैटिक में दिखाई दिया, और हम इसे सबसे कठिन के रूप में ध्यान केंद्रित करेंगे। और हम बोरिंग सी ++ सामान से मजेदार जावा रचनात्मक और इसके विपरीत में स्थानांतरित करेंगे।
हालांकि, शर्मनाक minstrels हमें बताएंगे - यह आप, नायक, गलत कहानी में भटक गया है, और आप पांच मीटर कांटेदार तार के साथ समाप्त हो जाएंगे, जैसा कि हमेशा सांप के साथ एक हाथी को पार करते समय होता है। अनुभव, कठिन गलतियों का बेटा, हमें सिखाता है - इस मामले में, कुछ अधिक उपयोगी प्राप्त होता है।

चरण तीन, या आरंभ करना
जैसा कि ऊपर उल्लेख किया गया है, आपको जावा को डिजाइन धाराओं के साथ काम करने की आवश्यकता है। वास्तव में, कार्य स्पष्ट है और जेएनआई के माध्यम से हल किया गया है:

/**
* Class for reading from InDesign IPMStream
*/
public class PMInputStream extends InputStream
{
/**
* Creates PMInputStream object and attaches it to IPMStream* already
* opened by InDesign.
* @param iPMStreamPtr IPMStream* to attach to
* @throws IOException The stream has no ability to read.
*/
public PMInputStream(long iPMStreamPtr) throws IOException {
this.ownedStreamPtr = iPMStreamPtr;
this.retain();
}

@Override
public int read() throws IOException {
return readByte();
}

@Override
public int read(byte b[], int off, int len) throws IOException {
if (len == 0) return 0;
return readBytes(b, off, len);
}

@Override
public long skip(long n) throws IOException {
return performSeek(n, SeekFromCurrent);
}

public long seek(long numberOfBytes, int fromHere) throws IOException {
return performSeek(numberOfBytes, fromHere);
}

@Override
public int available() {
return availableBytes();
}

// native functions below
...


कार्यान्वयन मूल कार्यों के माध्यम से बनाया गया है, हम उन्हें सूचीबद्ध करते हैं। वे स्वयं स्पष्ट हैं और विशेष टिप्पणियों की आवश्यकता नहीं है। केवल एक दिलचस्प बिंदु है, यहाँ यह है:

/**
* 'Cause IPMStream is a COM-like object we gotta call AddRef() for it
* if we wanna save pointer in our class.
*/
private native void retain();
/**
* Once we called AddRef() we shouldn't forget calling corresponding
* Release(). Let's do it!
*/
private native void release();


और सूची ही:

protected native int readByte();
protected native int readBytes(byte b[], int off, int len);
protected native long performSeek(long numberOfBytes, int fromHere);
protected native int availableBytes();

protected native String getFileName();
protected native long getLastModifiedTime();


पिछले दो कार्यों को जावा में सीधे कैश तत्वों में जोड़ा गया था, ताकि प्रत्येक रेंडरिंग के लिए डोम मॉडल का पुनर्निर्माण न हो। आपको केवल डेटा परिवर्तनों को ट्रैक करने की आवश्यकता है और बदलते समय उन्हें जल्दी से फिर से पढ़ना होगा।
और अंतिम स्पर्श देशी तरीकों का वास्तविक कार्यान्वयन है।

class IPMStream; class PMInputStream
{
private:
IPMStream* fStream;

public:
PMInputStream(IPMStream* stream);
~PMInputStream() { close(); }

void close();

int read() {
unsigned char result;
return read(&result, 1) == 1? result: -1;
}

int read(unsigned char* buffer, int len){ return fStream->XferByte(buffer, len); }
XInt64 seek(XInt64 numberOfBytes, SeekFrom fromHere) {
return fStream->Seek((int32)numberOfBytes, fromHere);
}

public:
enum SeekFrom { SeekFromStart = kSeekFromStart,
SeekFromCurrent = kSeekFromCurrent,
SeekFromEnd = kSeekFromEnd
};
};


हम पहले ही एसवीजी तक पहुंच चुके हैं, लेकिन अब काम एक तस्वीर को प्राप्त करना और खींचना है। दरअसल, बफर्डमैज में एक वेक्टर इमेज तैयार होने के बाद, हम अपनी प्रॉक्सी इमेज प्राप्त करते हैं। बैटिक के एक मानक उदाहरण से हमें स्पष्ट रूप से पता चलता है कि इसे कैसे प्राप्त किया गया था, इसलिए, अंतरिक्ष को बचाने के लिए, मैं खुद को इस फुटक्लॉथ को यहां नहीं लाने देता हूं। बफ़रेडइमेज से RGB में बाइट्स की एक सरणी प्राप्त करने के लिए PixelGrabber का उपयोग करना भी स्पष्ट है। हम AGMImageRecord के परिणामी सरणी को उसी तरह से पास करते हैं जैसे कि लेख के दूसरे भाग में चर्चा की गई है।
यह दिलचस्प है कि BufferedImage के बजाय IGraphicsPort पर रेंडर करना बिल्कुल एक पंक्ति से भिन्न होता है, मानक ऑफ़स्क्रीन ग्राफिक्स 2D के बजाय हमें अपने कार्यान्वयन को स्थानापन्न करने की आवश्यकता है। यही हम करेंगे।

चौथा चरण, या संक्षेप में एक विद्युत प्रवाह को तलवार से जोड़ते हैं ताकि चिंगारी उड़ जाए
ग्राफिक्स 2 डी के सक्षम उत्तराधिकार के लिए कोड की मात्रा बड़ी, उबाऊ, लेकिन स्पष्ट है, और इसे आसानी से एक ही अपाचे बाटिक से देखा जा सकता है। इसलिए, हम सबसे दिलचस्प हिस्सों पर ध्यान केंद्रित करेंगे, लेकिन यहां Paint getPaint(){ return paint; } का एक पूरा गुच्छा है और एक ला Paint getPaint(){ return paint; } Paint getPaint(){ return paint; } ओट।
मैं केवल इस बात पर ध्यान देता हूं कि सामान्य तौर पर, आप सुरक्षित रूप से इस तरह के प्लग डाल सकते हैं:

public void setXORMode(Color c1){ throw new RuntimeException("setXORMode: N/A"); }

और ऐसे:

public void fillRect(int x, int y, int w, int h) { fill(new Rectangle(x, y, w, h)); }

इस तरह के सरलीकरण और डुप्लिकेट के उन्मूलन के परिणामस्वरूप, हमें निम्नलिखित वास्तविक कार्य मिलते हैं:

public void draw(Shape s);
public void fill(Shape s);
public boolean drawImage(Image img, int x, int y, int width, int height, Color bgcolor, ImageObserver observer);

public void drawString(String str, float x, float y);
public void drawString(AttributedCharacterIterator iterator, float x, float y);


आप StrokeTextPainter का उपयोग करके आगे जा सकते हैं, और यह सेट तीन कार्यों तक कम हो जाएगा, जो अच्छा है।
अब दूसरे पक्ष से संपर्क करते हैं और देखते हैं कि हमें IGraphicsPort से क्या चाहिए:

private native void newpath();
private native void moveto(float x, float y);
private native void lineto(float x, float y);
private native void curveto(float x1, float y1, float x2, float y2, float x3, float y3);
private native void curvetov(float x2, float y2, float x3, float y3);
private native void closepath();

private native void gsave();
private native void grestore();

private native void setlinewidth(float width);
private native void setdash(int len, float[] dashArray, float offset);
private native void setopacity(float opacity, boolean bIsAlphaShape); // from 0 to 1.0
private native void setrgbcolor(float r, float g, float b);

private native void fill();
private native void eofill();
private native void stroke();

private native void image(int[] buffer, int x, int y, int width, int height, double[] transformMatrix);

private native void clip();
private native void eoclip();


एक अनुभवी नज़र के साथ, आप ग्रेडर जैसे रेंडरिंग टूल्स की स्पष्ट अनुपस्थिति को नोटिस कर सकते हैं। काश, Adobe द्वारा एपीआई के इस हिस्से के लिए प्रलेखन इतना दुर्लभ है कि मैं अभी भी उपलब्ध कार्यों का उपयोग नहीं कर सका, मुझे शर्मसार होना पड़ा, जैसा कि नीचे चर्चा की जाएगी।
जाहिर है, हमें थोड़ी जरूरत है। हालाँकि, एक नया कार्य सामने आता है: हमें किसी तरह इस पूरी चीज़ को मिलाने की जरूरत है। आइए सरल से शुरू करें - ज्यामितीय आकृतियों के साथ।
यहां सबसे कठिन हिस्सा जावा से आकृति को मूल कार्यों के एक सेट पर तैनात करना है। ऐसा करने के लिए, हम मानक PathIterator का उपयोग करेंगे, और उसी समय परिवर्तनों के बारे में मत भूलना, क्योंकि बाटिक AffineTransform का उपयोग बहुत सक्रिय रूप से करता है:

private void applyPath(PathIterator pi, int kind) {
float[] coord = new float[6];
int retSeg;

newpath();
while(!pi.isDone()) {
retSeg = pi.currentSegment(coord);
switch (retSeg) {
case SEG_LINETO:
lineto(coord[0], coord[1]);
break;
case SEG_CUBICTO:
curveto(coord[0], coord[1], coord[2], coord[3], coord[4], coord[5]);
break;
case SEG_MOVETO:
moveto(coord[0], coord[1]);
break;
case SEG_QUADTO:
curvetov(coord[0], coord[1], coord[2], coord[3]);
break;
case SEG_CLOSE:
closepath();
break;
}
pi.next();
}

if(kind == PATH_FILL) {
if(pi.getWindingRule() == PathIterator.WIND_EVEN_ODD) eofill();
else fill();
}
else if(kind == PATH_STROKE) stroke();
else if(kind == PATH_CLIP) {
if(pi.getWindingRule() == PathIterator.WIND_EVEN_ODD) eoclip();
else clip();
}
}


अब हम आसानी से आदिम आकर्षित कर सकते हैं:



public void draw(Shape s) {
PathIterator pi = s.getPathIterator(getTransform());
applyClip(getClip());
applyStroke(s);
applyStyles();
applyPath(pi, PATH_STROKE);
restoreClip();
}


अब तक, हम सभी प्रकार के आवेदन पर ध्यान केंद्रित नहीं करेंगे *, उनकी चर्चा आगे की गई है। सख्ती से बोलना, भरना () ग्रेडिएंट्स के साथ कुछ कठिनाइयों को छोड़कर, बिल्कुल वैसा ही दिखता है। जैसा कि आप अनुमान लगा सकते हैं, applyClip () भी इसी तरह लागू किया गया है:

private void applyClip(Shape xclip) {
gsave();
if(xclip != null) {
PathIterator pi = xclip.getPathIterator(getTransform());
applyPath(pi, PATH_CLIP);
}
}


असली कोड थोड़ा अधिक जटिल है, आपको इग्राफिक्सपॉर्ट में फ्लैटनर कार्यान्वयन की सुविधाओं को ध्यान में रखना होगा, और आवश्यक के रूप में गोल को मोड़ना होगा ताकि पथ वामावर्त के चारों ओर चला जाए। और, जैसा कि पहले उल्लेख किया गया है, बाटिक जानता है कि पाठ को ग्लिफ़ के सेट में कैसे वेक्टर किया जाए, इसलिए आप फोंट के साथ काम करने के बारे में चिंता नहीं कर सकते। तो हमारा पाठ अनिवार्य रूप से ज्यामितीय आकृतियों का एक सेट बन जाता है।

जारी रखने के लिए ...