I'll paste in the entire .cpp file content. Basically, it's an extension of the sample SnippetRunner.cpp:
//========================================================================================
//
// $File: //ai_stream/rel_21_0/devtech/sdk/public/samplecode/SnippetRunner/Source/SnippetRunnerPlugin.cpp $
//
// $Revision: #1 $
//
// Copyright 1987 Adobe Systems Incorporated. All rights reserved.
//
// NOTICE: Adobe permits you to use, modify, and distribute this file in accordance
// with the terms of the Adobe license agreement accompanying it. If you have received
// this file from a source other than Adobe, then your use, modification, or
// distribution of it requires the prior written permission of Adobe.
//
//========================================================================================
#include "IllustratorSDK.h"
#include "AICSXS.h"
#include "SDKDef.h"
#include "SDKAboutPluginsHelper.h"
#include "SnippetRunnerID.h"
#include "SnippetRunnerPlugin.h"
#include "SnippetRunnerSuites.h"
#include "SnippetRunnerPanelController.h"
#include "SnippetRunnerLog.h"
#include "SnippetRunnerParameter.h"
#include "SnippetRunnerPreferences.h"
#include "SDKErrors.h"
#include "SnippetRunnerUnitTestManager.h"
// Framework includes:
#include "SnpRunnable.h"
#include "SnpSelectionHelper.h"
#include "SnpArtSetHelper.h"
#include "SnpArtHelper.h"
#include "tinyxml2.h"
#include "PdmReaderWriter.h"
using namespace ATE;
using namespace PdmMetaDataTools;
extern ImportSuite gPostStartupSuites[];
SnippetRunnerPlugin* gPlugin = NULL;
/*
*/
Plugin* AllocatePlugin(SPPluginRef pluginRef)
{
return new SnippetRunnerPlugin(pluginRef);
}
/*
*/
void FixupReload(Plugin* plugin)
{
SnippetRunnerPlugin::FixupVTable((SnippetRunnerPlugin*)plugin);
}
/*
*/
ASErr SnippetRunnerPlugin::SetGlobal(Plugin *plugin)
{
gPlugin = (SnippetRunnerPlugin *)plugin;
return kNoErr;
}
/*
*/
SnippetRunnerPlugin::SnippetRunnerPlugin(SPPluginRef pluginRef) :
Plugin(pluginRef),
fSnippetRunnerPanelController(NULL),
fCSXSPlugPlugSetupCompleteNotifier(NULL)
{
strncpy(fPluginName, kSnippetRunnerPluginName, kMaxStringLength);
fAboutPluginMenu = NULL;
fShowHidePanelMenu = NULL;
}
/*
*/
SnippetRunnerPlugin::~SnippetRunnerPlugin()
{
}
/*
*/
ASErr SnippetRunnerPlugin::Message(char *caller, char *selector, void *message)
{
ASErr result = kNoErr;
try {
result = Plugin::Message(caller, selector, message);
}
catch (ai::Error& ex) {
result = ex;
}
catch (...) {
result = kCantHappenErr;
}
if (result) {
if (result == kUnhandledMsgErr) {
// Defined by Plugin.hpp and used in Plugin::Message - ignore
result = kNoErr;
}
else {
// TODO should really call gPlugin->ReportError
aisdk::report_error(result);
}
}
return result;
}
/*
*/
ASErr SnippetRunnerPlugin::GoMenuItem(AIMenuMessage *message)
{
ASErr result = kNoErr;
try {
if (message->menuItem == this->fAboutPluginMenu)
{
SDKAboutPluginsHelper aboutPluginsHelper;
aboutPluginsHelper.PopAboutBox(message, "About SnippetRunner", kSDKDefAboutSDKCompanyPluginsAlertString);
}
else if (message->menuItem == this->fShowHidePanelMenu)
{
if (this->fSnippetRunnerPanelController)
{
AIBoolean visible = false;
fSnippetRunnerPanelController->IsPrimaryStageVisible(visible);
if (visible)
{
fSnippetRunnerPanelController->UnloadExtension();
}
else
{
fSnippetRunnerPanelController->LoadExtension();
}
}
}
}
catch (ai::Error& ex) {
result = ex;
}
return result;
}
/*
*/
ASErr SnippetRunnerPlugin::UpdateMenuItem(AIMenuMessage *message)
{
// Update the Show/Hide panel menu.
AIBoolean visible = false;
if (fSnippetRunnerPanelController != NULL)
fSnippetRunnerPanelController->IsPrimaryStageVisible(visible);
// sAIMenu->CheckItem(fShowHidePanelMenu, visible);
return kNoErr;
}
/*
*/
ASErr SnippetRunnerPlugin::StartupPlugin(SPInterfaceMessage *message)
{
ASErr error = kNoErr;
try {
error = Plugin::StartupPlugin(message);
aisdk::check_ai_error(error);
error = this->AddNotifiers(message);
aisdk::check_ai_error(error);
// error = this->AddMenus(message);
// aisdk::check_ai_error(error);
}
catch (ai::Error& ex) {
error = ex;
}
return error;
}
/*
*/
ASErr SnippetRunnerPlugin::ShutdownPlugin(SPInterfaceMessage *message)
{
ASErr error = kNoErr;
if (fSnippetRunnerPanelController)
{
fSnippetRunnerPanelController->RemoveEventListeners();
delete fSnippetRunnerPanelController;
fSnippetRunnerPanelController = NULL;
Plugin::LockPlugin(false);
}
this->ReleasePostStartupSuites();
error = Plugin::ShutdownPlugin(message);
return error;
}
ASErr SnippetRunnerPlugin::PostStartupPlugin()
{
ASErr error = kNoErr;
try {
// Acquire suites we could not get on plug-in startup.
error = this->AcquirePostStartupSuites();
if (error) {
error = kNoErr;
// Ignore - this should not be a fatal error.
// We want the SnippetRunner panel to open and
// we want snippets to be checking that the
// suite pointers they depend on are not NULL
// before using them.
}
// Read preferences.
SnippetRunnerPreferences::Instance();
// Create flash panel
if (fSnippetRunnerPanelController == NULL)
{
fSnippetRunnerPanelController = new SnippetRunnerPanelController();
error = Plugin::LockPlugin(true);
if (error) { return error; }
}
}
catch (ai::Error ex) {
error = ex;
}
return error;
}
/*
*/
ASErr SnippetRunnerPlugin::AddNotifiers(SPInterfaceMessage *message)
{
ASErr error = kNoErr;
try {
error = sAINotifier->AddNotifier(message->d.self, "SnippetRunner " kAIApplicationShutdownNotifier, kAIApplicationShutdownNotifier, &fAppShutdownNotifier);
aisdk::check_ai_error(error);
error = sAINotifier->AddNotifier(message->d.self, "SnippetRunner " kAIArtSelectionChangedNotifier, kAIArtSelectionChangedNotifier, &fArtSelectionChangedNotifier);
aisdk::check_ai_error(error);
error = sAINotifier->AddNotifier(message->d.self, "SnippetRunner " kAICSXSPlugPlugSetupCompleteNotifier, kAICSXSPlugPlugSetupCompleteNotifier, &fCSXSPlugPlugSetupCompleteNotifier);
aisdk::check_ai_error(error);
error = sAINotifier->AddNotifier(message->d.self, "SnippetRunner",
kAIDocumentOpenedNotifier, NULL);
error = sAINotifier->AddNotifier(message->d.self, "SnippetRunner",
kAIDocumentSavedNotifier, NULL);
// error = sAINotifier->AddNotifier(message->d.self, "SnippetRunner", kAIDocumentNewNotifier, NULL);
}
catch (ai::Error& ex) {
error = ex;
}
return error;
}
/*
*/
ASErr SnippetRunnerPlugin::Notify(AINotifierMessage *message)
{
ASErr error = kNoErr;
if (message->notifier == fAppShutdownNotifier)
{
SnippetRunnerLog::DeleteInstance();
SnippetRunnerParameter::DeleteInstance();
SnippetRunnerPreferences::Instance()->DeleteInstance();
SnippetRunnerUnitTestManager::Instance()->DeleteInstance();
}
else if (message->notifier == fArtSelectionChangedNotifier)
{
fSnippetRunnerPanelController->HandleModelChanged();
}
else if (message->notifier == fCSXSPlugPlugSetupCompleteNotifier)
{
fSnippetRunnerPanelController->RegisterCSXSEventListeners();
}
if (!strcmp(message->type, kAIDocumentOpenedNotifier))
{
ai::FilePath filePath;
sAIDocument->GetDocumentFileSpecification(filePath);
/*
1. DEFINE ALL ROW AND COLUMN HEADER NAMES BASED UPON VARIABLE NAMES
headerInfoByVariables = {
'varname1': ['Brand', 'Signature:']
'varname2': ['Brand'], 'Approved:'],
}
2. WHEN ITERATING THROUGH THE XML
i. CREATE A NEW ARRAY BY FLIPPLING THE ABOVE ARRAY
variableNamesByHeaders = {
'Brand': {
'Signature': ["varname1", "varval1"],
'Approved': "varname2", "varval2"]
}
''
}
ii. Create row header strings
iii. Create col header strings
*/
// //sAIUser->MessageAlert(ai::UnicodeString("File opened"));
// std::map<string, map<string, AIArtHandle>> textFrames = {};
map < string, map<string, PDMVariable>> variablesByHeaders = {};
map <string, PDMVariable> variablesByNewInfo = {};
tinyxml2::XMLDocument* doc;
// std::map<string, tinyxml2::XMLElement*> xmlTextVariables;
AIReal defaultDateHOffset = -30.0;
AIReal defaultCheckboxHOffset = -5.0;
AIReal defaultCheckboxVOffset = -5.0;
map<string, TitleBlockHeaderInfo> headerInfoByVariables = {
{ "xmp:MarketingAppReq",{ "Product \rMarketing ", "Approval\rNeeded", true, defaultCheckboxHOffset, defaultCheckboxVOffset } },
{ "xmp:MarketingApproval",{ "Product \rMarketing ", "Approved By:", false, 0.0, 0.0 } },
{ "xmp:MarketingAppDate",{ "Product \rMarketing ", "Date:", false, defaultDateHOffset, 0 } },
{ "xmp:MktgBrandAppReq",{ "Brand \rMarketing ", "Approval\rNeeded", true, defaultCheckboxHOffset, defaultCheckboxVOffset } },
{ "xmp:MktgBrandApproval",{ "Brand \rMarketing ", "Approved By:", false, 0.0, 0.0 } },
{ "xmp:MktgBrandAppDate",{ "Brand \rMarketing ", "Date:", false, defaultDateHOffset, 0 } },
{ "xmp:MarketingDirAppReq",{ "Marketing\rDirector ", "Approval\rNeeded", true, defaultCheckboxHOffset, defaultCheckboxVOffset } },
{ "xmp:MarketingDirApproval",{ "Marketing\rDirector ", "Approved By:", false, 0.0, 0.0 } },
{ "xmp:MarketingDirAppDate",{ "Marketing\rDirector ", "Date:", false, defaultDateHOffset, 0 } },
{ "xmp:EngineeringAppReq",{ "Engineering", "Approval\rNeeded", true, defaultCheckboxHOffset, defaultCheckboxVOffset + 5 } },
{ "xmp:EngineeringApproval",{ "Engineering", "Approved By:", false, 0.0, 0.0 } },
{ "xmp:EngAppDate",{ "Engineering", "Date:", false, defaultDateHOffset, 0 } },
{ "xmp:OperationsDirAppReq",{ "Operations\rDirector", "Approval\rNeeded", true, defaultCheckboxHOffset, defaultCheckboxVOffset } },
{ "xmp:OperationsDirApproval",{ "Operations\rDirector", "Approved By:", false, 0.0, 0.0 } },
{ "xmp:OperationsDirAppDate",{ "Operations\rDirector", "Date:", false, defaultDateHOffset, 0 } },
{ "xmp:QAAppReq",{ "Product\rIntegrity", "Approval\rNeeded", true, defaultCheckboxHOffset, defaultCheckboxVOffset } },
{ "xmp:QAApproval",{ "Product\rIntegrity", "Approved By:", false, 0.0, 0.0 } },
{ "xmp:QAAppDate",{ "Product\rIntegrity", "Date:", false, defaultDateHOffset, 0 } },
{ "xmp:QADirAppReq",{ "Quality\rManger", "Approval\rNeeded", true, defaultCheckboxHOffset, defaultCheckboxVOffset } },
{ "xmp:QADirApproval",{ "Quality\rManger", "Approved By:", false, 0.0, 0.0 } },
{ "xmp:QADirAppDate",{ "Quality\rManger", "Date:", false, defaultDateHOffset, 0 } },
{ "xmp:LegalAppReq",{ "Legal", "Approval\rNeeded", true, defaultCheckboxHOffset, defaultCheckboxVOffset + 5 } },
{ "xmp:LegalApproval",{ "Legal", "Approved By:", false, 0.0, 0.0 } },
{ "xmp:LegalAppDate",{ "Legal", "Date:", false, defaultDateHOffset, 0 } },
{ "xmp:MexicoAppReq",{ "KCM", "Approval\rNeeded", true, defaultCheckboxHOffset, defaultCheckboxVOffset + 5 } },
{ "xmp:MexicoApproval",{ "KCM", "Approved By:", false, 0.0, 0.0 } },
{ "xmp:MexicoAppDate",{ "KCM", "Date:", false, defaultDateHOffset, 0 } },
{ "xmp:ToolingApproved",{ "FINAL ROUTING", "Approval\rNeeded", true, defaultCheckboxHOffset, defaultCheckboxVOffset + 8 } },
};
map<string, string> newInfoByVariables = {
{ "xmp:fileNameOnSystem", "File Name:" },
{ "xmp:DrawnDate", "Date Created:" },
{ "xmp:DrawnBy", "Author:" },
{ "xmp:SpecNo", "Spec #" },
{ "xmp:LegacySpecNo", "Legacy Spec #" },
{ "xmp:Revision", "Revision:" },
{ "dc:description[1]", "Description:" },
{ "xmp:ECnumber", "EC #:" },
{ "xmp:Project", "Project #:" },
{ "xmp:ProjectDescription", "Project Description:" },
{ "xmp:ArtworkType", "Artwork Type:" },
{ "xmp:Dieline", "Die/Drawing:" },
{ "xmp:Material", "Substrate:" },
{ "xmp:TemplateNo", "Template:" },
{ "xmp:TemplateRev", "Template Rev:" },
{ "xmp:PrintProcess", "Print Process:" },
{ "xmp:Note", "Note: " },
{ "xmp:ColorStations", "Color Stations: " },
{ "xmp:Size", "Size:" },
{ "xmp:ApplicationVersion", "Application Version:" }
};
std::map<string, boolean> textToRemove = {
{ "Illustrator Spec Box 20171005 - Copy", true },
{ "Illustrator/CC", true },
};
std::map <string, AIReal> hColHeaders = {};
std::map <string, AIReal> vRowHeaders = {};
std::map <string, AIRealPoint> newInfoCoordinates = {};
/*
NOTE: Separate variables are used below because of the following reason:
fullPathUnicode.as_Platform().c_str() will not really give you a
compile error but will say within the debugger watch window:
"Nested function evaluation not supported."
This was the main cause of the crash bug - xml being assigned the value of
a 'Nested Function Evaluation'
*/
ai::UnicodeString fullPathUnicode = filePath.GetFullPath(true);
string strFullpath = fullPathUnicode.as_Platform();
const char* fullFilePath = strFullpath.c_str();
// //sAIUser->MessageAlert(ai::UnicodeString("A document was just opened!"));
ASErr result = kNoErr;
try
{
// Fill these up with the required values above.
/*
static const char* xml =
"<root>"
"<debug>Filepath passed = C:\dev\desktopDev\lampros\evenfloPdm\aiConnectorDllTest\aiConnectorDllTest\bin\Debug\./example.ai
No smart handler available. trying packet scanning.

CreatorTool = Adobe Illustrator CC 2017 (Windows)
terminated successfully after reading values
</debug>"
"<message></message>"
"<pdm_variable_list>"
"<pdm_variable>"
"<variable_name>xmp:MarketingAppReq</variable_name>"
"<variable_value>03/21/2017</variable_value>"
"</pdm_variable>"
"<pdm_variable>"
"<variable_name>xmp:MarketingApproval</variable_name>"
"<variable_value>03/21/2017</variable_value>"
"</pdm_variable>"
"</pdm_variable_list>"
"</root>";
*/
// Determine whether or not to clear the text fields
string loggedInUser = "some_user";
string userThatCheckedOut = "some_user";
bool fileIsCheckedOut = false;
bool fileOpenedOnce = false;
string strXml = MetaDataReaderWriter::preCheckIn(fullFilePath);
const char* xml = strXml.c_str();
/***********************************************************
////////////////// BEGIN EXTRACTING VARIABLE CONTENT FROM THE XML CONTENT//////////////
***********************************************************/
//sAIUser->MessageAlert(ai::UnicodeString("Step 1 -PARSING XML: First, We'll display all variable names and their values found in the XML."));
doc = new tinyxml2::XMLDocument();
doc->Parse(xml);
// doc->LoadFile("return_std__string_checkin_result.xml"); // xml.css");
// tinyxml2::XMLElement* pdm_variable_list = doc->NextSiblingElement()->NextSiblingElement()->NextSiblingElement();
tinyxml2::XMLElement* root = doc->FirstChildElement("root");
tinyxml2::XMLElement* pdm_variable_list = root->FirstChildElement("pdm_variable_list");
for (tinyxml2::XMLElement* pdm_variable = pdm_variable_list->FirstChildElement("pdm_variable"); pdm_variable != NULL; pdm_variable = pdm_variable->NextSiblingElement())
{
tinyxml2::XMLElement* variable_name = pdm_variable->FirstChildElement("variable_name");
tinyxml2::XMLElement* variable_value = pdm_variable->FirstChildElement("variable_value");
tinyxml2::XMLNode* textNodeVarName = variable_name->FirstChild();
string var_name = "";
if (textNodeVarName)
{
tinyxml2::XMLText* xmlTextVarName = textNodeVarName->ToText();
var_name = xmlTextVarName->Value();
tinyxml2::XMLNode* textNodeVarValue = variable_value->FirstChild();
string var_value = "";
if (textNodeVarValue)
{
tinyxml2::XMLText* xmlTextVarValue = textNodeVarValue->ToText();
var_value = xmlTextVarValue->Value();
}
if (headerInfoByVariables.find(var_name) != headerInfoByVariables.end())
{
string rowHeader = headerInfoByVariables[var_name].row;
string columnHeader = headerInfoByVariables[var_name].column;
variablesByHeaders[rowHeader][columnHeader] = { var_name, var_value };
vRowHeaders[rowHeader] = 0.0;
hColHeaders[columnHeader] = 0.0;
// xmlTextVariables[var_name] = variable_value;
string alertMsg = "'" + var_name + "' - '" + var_value + "'";
//sAIUser->MessageAlert(ai::UnicodeString(alertMsg.c_str()));
}
if (newInfoByVariables.find(var_name) != newInfoByVariables.end())
{
string tmpHeader = newInfoByVariables[var_name];
variablesByNewInfo[tmpHeader] = { var_name, var_value };
// xmlTextVariables[var_name] = variable_value;
newInfoCoordinates[tmpHeader] = { 0.0, 0.0 };
string alertMsg = "'" + var_name + "' - '" + var_value + "'";
//sAIUser->MessageAlert(ai::UnicodeString(alertMsg.c_str()));
}
/*if (var_name == "dc:format")
{
string tmpDcFormat = var_value;
bool isDCFormat = var_value == "1";
}
*/
if (var_name == "xmp:loggedInUser")
{
loggedInUser = var_value;
}
else if (var_name == "xmp:userThatCheckedOut")
{
userThatCheckedOut = var_value;
}
else if (var_name == "xmp:fileIsCheckedOut")
{
fileIsCheckedOut = var_value == "1";
}
if (var_name == "xmp:fileOpenedOnce" && var_value == "1")
{
fileOpenedOnce = true;
}
}
}
bool bClearTextFields = !loggedInUser.compare(userThatCheckedOut) && fileIsCheckedOut;
////////////////// END EXTRACTING VARIABLE CONTENT FROM THE XML CONTENT//////////////
ATE::ICharFeatures features;
FontRef fontRef;
AIFontKey fontKey;
features.SetFontSize(10);
AIRealMatrix headerMatrix;
AIArtHandle artGroup = NULL;
result = sAIArt->GetFirstArtOfLayer(NULL, &artGroup);
SDK_ASSERT(sAITextFrame);
SnippetRunnerLog* log = SnippetRunnerLog::Instance();
AIArtSpec specs[1] = { { kTextFrameArt,0,0 } };
SnpArtSetHelper textFrameArtSet(specs, 1);
if (textFrameArtSet.GetCount() > 0)
{
//sAIUser->MessageAlert(ai::UnicodeString("Step 2 - PARSING AI FILE: Next, we'll search for text tokens corresponding to variable names and display their captions and coordinates."));
/***********************************************************
////////////////// BEGIN ITERATING THE ENTIRE TEXT OF THE .AI FILE//////////////
// 1. GETTING COORDINATES FOR HEADER ROWS AND COLUMNS
// 2. GETTING COORDINATES FOR ALL OTHER REQUIRED FIELDS
***********************************************************/
for (size_t i = 0; i < textFrameArtSet.GetCount(); i++)
{
AIArtHandle textFrameArt = textFrameArtSet;
TextFrameRef textFrameRef = NULL;
result = sAITextFrame->GetATETextFrame(textFrameArt, &textFrameRef);
aisdk::check_ai_error(result);
ITextFrame textFrame(textFrameRef);
SnippetRunnerLog::Indent indent;
ITextRange textRange = textFrame.GetTextRange();
ai::AutoBuffer<ASUnicode> contents(textRange.GetSize());
textRange.GetContents(contents, textRange.GetSize());
ASInt32 strLength = textRange.GetSize();
if (strLength > 0)
{
std::vector<char> vc(strLength);
ASInt32 conLength = textRange.GetContents(&vc[0], strLength);
if (conLength == strLength)
{
std::string contents;
contents.assign(vc.begin(), vc.begin() + strLength);
int tmp = 0;
bool bColumnIndexPresent = hColHeaders.find(contents) != hColHeaders.end();
bool bRowIndexPresent = vRowHeaders.find(contents) != vRowHeaders.end();
if (bRowIndexPresent || bColumnIndexPresent)
{
AIArtHandle frameArt = NULL;
error = sAITextFrame->GetAITextFrame(textFrameRef, &frameArt);
AIRealPoint anchor;
result = sAITextFrame->GetPointTextAnchor(textFrameArt, &anchor);
aisdk::check_ai_error(result);
if (bColumnIndexPresent)
{
hColHeaders[contents] = anchor.h;
headerMatrix = textFrame.GetMatrix();
string alertMsg = "'" + contents + " - x-coord: " + std::to_string(anchor.h);
//sAIUser->MessageAlert(ai::UnicodeString(alertMsg.c_str()));
}
if (bRowIndexPresent)
{
vRowHeaders[contents] = anchor.v;
string alertMsg = "'" + contents + "' - y-coord: " + std::to_string(anchor.v);
//sAIUser->MessageAlert(ai::UnicodeString(alertMsg.c_str()));
}
}
bool bNewInfoIndexPresent = variablesByNewInfo.find(contents) != variablesByNewInfo.end();
if (bNewInfoIndexPresent)
{
AIArtHandle frameArt = NULL;
error = sAITextFrame->GetAITextFrame(textFrameRef, &frameArt);
AIRealPoint anchor;
result = sAITextFrame->GetPointTextAnchor(textFrameArt, &anchor);
aisdk::check_ai_error(result);
int len = contents.length();
float widthFactor = 4.7;
anchor.h += len * widthFactor;
newInfoCoordinates[contents] = anchor;
string alertMsg = "'" + contents + "' - x: " + std::to_string(anchor.h) + ", y: " + std::to_string(anchor.v);
//sAIUser->MessageAlert(ai::UnicodeString(alertMsg.c_str()));
}
// First, we get the features for the text range
ATE::ICharFeatures tmpFeatures = textRange.GetUniqueLocalCharFeatures();
// And then we somehow compare those with the features that are set later
bool bBuff;
AIReal tmpFontSize = tmpFeatures.GetFontSize(&bBuff);
AIReal fontSize = features.GetFontSize(&bBuff);
if (bClearTextFields)
{
if (tmpFontSize == fontSize)
{
// Remove the text if the font size matches the configured one!
textRange.Remove();
}
}
// Removing any unneeded text
bool bTextToRemove = false; // textToRemove.find(contents) != textToRemove.end();
if (bTextToRemove)
{
textRange.Remove();
}
}
}
}
////////////////// END ITERATING THE ENTIRE TEXT OF THE .AI FILE//////////////
/**********************************************************************
///////////// BEGIN CREATING TEXT FIELDS FOR TABLE ///////////////////////
************************************************************************/
ATE::ICharFeatures features;
FontRef fontRef;
AIFontKey fontKey;
features.SetFontSize(10);
map<string, AIReal>::iterator row;
//sAIUser->MessageAlert(ai::UnicodeString("Step 3 - SHOWING DATA: Finally, we'll show values at the coordinates fetched for each of the variable names."));
for (row = vRowHeaders.begin(); row != vRowHeaders.end(); row++)
{
std::string rowIndex = row->first;
AIReal rowTop = row->second; // rowRectTop.top;
map<string, AIReal>::iterator col;
map<string, AIArtHandle> innerTextRange;
for (col = hColHeaders.begin(); col != hColHeaders.end(); col++)
{
std::string colIndex = col->first;
AIReal colLeft = col->second;
if (variablesByHeaders[rowIndex].find(colIndex) != variablesByHeaders[rowIndex].end())
{
string text = variablesByHeaders[rowIndex][colIndex].value;
string varName = variablesByHeaders[rowIndex][colIndex].name;
AIReal hOffset = headerInfoByVariables[varName].hOffset;
AIReal vOffset = headerInfoByVariables[varName].vOffset;
AIArtHandle newFrame;
SnpArtHelper artHelper;
// Get the group art that contains all the art in the current layer.
AIArtHandle artGroup = NULL;
result = sAIArt->GetFirstArtOfLayer(NULL, &artGroup);
aisdk::check_ai_error(result);
//
// Add the new point text item to the layer.
AITextOrientation orient = kHorizontalTextOrientation;
AIRealPoint newAnchor = {};
newAnchor.h = colLeft + hOffset;
newAnchor.v = rowTop + vOffset;
AIArtHandle textFrame = NULL;
result = sAITextFrame->NewPointText(kPlaceAboveAll, artGroup, orient, newAnchor, &textFrame);
aisdk::check_ai_error(result);
// Set the contents of the text range.
TextRangeRef range = NULL;
result = sAITextFrame->GetATETextRange(textFrame, &range);
aisdk::check_ai_error(result);
ITextRange crange(range);
if (headerInfoByVariables[varName].bCheckbox)
{
text = text == "1" ? "X" : "";
}
crange.SetLocalCharFeatures(features);
crange.InsertAfter(ai::UnicodeString(text).as_ASUnicode().c_str());
innerTextRange[colIndex] = textFrame;
string alertMsg = "'" + varName + "' - '" + text + "' - Coords: (" + std::to_string(newAnchor.h) + "," + std::to_string(newAnchor.v) + ")";
//sAIUser->MessageAlert(ai::UnicodeString(alertMsg));
}
}
// textFrames[rowIndex] = innerTextRange;
}
/**********************************************************************
///////////// END CREATING TEXT FIELDS FOR TABLE ///////////////////////
************************************************************************/
/***********************************************************************
///////////////////// BEGIN CREATING NEW FIELDS
***********************************************************************/
map<string, AIRealPoint>::iterator itNew;
for (itNew = newInfoCoordinates.begin(); itNew != newInfoCoordinates.end(); itNew++)
{
std::string newInfoHeader = itNew->first;
AIRealPoint newAnchor = itNew->second;
AIArtHandle newFrame;
SnpArtHelper artHelper;
// Get the group art that contains all the art in the current layer.
AIArtHandle artGroup = NULL;
result = sAIArt->GetFirstArtOfLayer(NULL, &artGroup);
aisdk::check_ai_error(result);
// Add the new point text item to the layer.
AITextOrientation orient = kHorizontalTextOrientation;
AIArtHandle textFrame = NULL;
result = sAITextFrame->NewPointText(kPlaceAboveAll, artGroup, orient, newAnchor, &textFrame);
aisdk::check_ai_error(result);
// Set the contents of the text range.
TextRangeRef range = NULL;
result = sAITextFrame->GetATETextRange(textFrame, &range);
aisdk::check_ai_error(result);
ITextRange crange(range);
string text = "";
string varName = "";
if (variablesByNewInfo.find(newInfoHeader) != variablesByNewInfo.end())
{
text = variablesByNewInfo[newInfoHeader].value;
varName = variablesByNewInfo[newInfoHeader].name;
crange.SetLocalCharFeatures(features);
crange.InsertAfter(ai::UnicodeString(text).as_ASUnicode().c_str());
string alertMsg = "'" + varName + "' - '" + text + "' - Coords: (" + std::to_string(newAnchor.h) + "," + std::to_string(newAnchor.v) + ")";
//sAIUser->MessageAlert(ai::UnicodeString(alertMsg));
}
}
/***********************************************************************
///////////////////// END CREATING NEW FIELDS
***********************************************************************/
AIDocumentHandle documentHandle;
sAIDocument->GetDocument(&documentHandle);
// TODOs: Ask client if the file is to be autosaved.
boolean bAutoSaveFile = true;
if (bAutoSaveFile)
{
// Save the .AI file once showing
// WARNING:
// This function seems to be the reason the text doesn't show up!
// Let's see if there's an alternative
// sAIUser->AppIdle();
// sAIDocument->SyncDocument();
// sAIDocumentList->Save(documentHandle);
}
// fileOpenedOnce = true;
if (!fileOpenedOnce)
{
// sAIDocument->SetDocumentModified(true);
AIBoolean foundAnyLegacy;
sAIDocumentList->Save(documentHandle);
sAILegacyTextConversion->ConvertAllToNative(&foundAnyLegacy);
// sAIAppContext->SyncAndDraw();
// sAIDocumentList->Close(documentHandle);
// sAIDocumentList->CloseAll();
// ToDo:
// Write 1 to the xmp:fileOpenedOnce variable
// in order to avoid inifinite close/open chain!
std::string xmlVariableStringExample = "<pdm_variable_list> <pdm_variable> <variable_name>xmp:fileOpenedOnce</variable_name> <variable_value>1</variable_value> </pdm_variable> </pdm_variable_list>";
std::string resultStatus = MetaDataReaderWriter::sync(fullFilePath, xmlVariableStringExample.c_str());
//sAIDocumentList->OpenNthRecentDocument(0);
}
}
else
{
log->Write("Create some text art.");
aisdk::check_ai_error(kBadParameterErr);
}
}
catch (ai::Error& ex)
{
result = ex;
}
catch (ATE::Exception& ex)
{
result = ex.error;
}
return result;
}
else if (!strcmp(message->type, kAIDocumentSavedNotifier))
{
// sAIDocument->ResumeTextReflow();
// sAIDocument->RedrawDocument();
}
// else if (!strcmp(message->type, kAIDocumentSavedNotifier))
// {
/*
// To Curtis Mimes: Here's where the Save event is triggered.
ASErr result = kNoErr;
const char* fullFilePath = filePath.GetFullPath().as_Platform().c_str();
tinyxml2::XMLPrinter streamer;
doc->Print(&streamer);
// //sAIUser->MessageAlert(ai::UnicodeString(streamer.CStr()));
map<string, map<string, AIArtHandle>>::iterator outerTextRangeIterator;
for (outerTextRangeIterator = textFrames.begin(); outerTextRangeIterator != textFrames.end(); outerTextRangeIterator++)
{
std::string rowIndex = outerTextRangeIterator->first;
map<string, AIArtHandle> outerTextRange = outerTextRangeIterator->second; // rowRectTop.top;
map<string, AIArtHandle>::iterator innerTextRangeIterator;
for (innerTextRangeIterator = outerTextRange.begin(); innerTextRangeIterator != outerTextRange.end(); innerTextRangeIterator++)
{
std::string colIndex = innerTextRangeIterator->first;
AIArtHandle textFrame = innerTextRangeIterator->second;
TextRangeRef range = NULL;
result = sAITextFrame->GetATETextRange(textFrame, &range);
aisdk::check_ai_error(result);
ITextRange textRange(range);
ai::AutoBuffer<ASUnicode> contents(textRange.GetSize());
textRange.GetContents(contents, textRange.GetSize());
// //sAIUser->MessageAlert(ai::UnicodeString(contents));
ASInt32 strLength = textRange.GetSize();
if (strLength > 0)
{
std::vector<char> vc(strLength);
ASInt32 conLength = textRange.GetContents(&vc[0], strLength);
if (conLength == strLength)
{
std::string contents;
contents.assign(vc.begin(), vc.begin() + strLength);
// To Curtis Mimes: And Here's where the modified text field content gets displayed (the contents variable).
string prevVarValue = variablesByHeaders[rowIndex][colIndex].value;
if (contents != prevVarValue)
{
string variableName = variablesByHeaders[rowIndex][colIndex].name;
// //sAIUser->MessageAlert(ai::UnicodeString(contents));
xmlTextVariables[variableName]->SetText(contents.c_str());
}
}
}
}
}
tinyxml2::XMLPrinter streamer2;
doc->Print(&streamer2);
//sAIUser->MessageAlert(ai::UnicodeString(streamer2.CStr()));
// MetaDataReaderWriter::sync(fullFilePath, streamer2.CStr());
*/
// }
// else if (!strcmp(message->type, kAIDocumentNewNotifier))
// {
// int documentNew = 1;
// }
return error;
}
/*
*/
ASErr SnippetRunnerPlugin::AddMenus(SPInterfaceMessage *message)
{
ASErr error = kNoErr;
// Add About Plugins menu item for this plug-in.
SDKAboutPluginsHelper aboutPluginsHelper;
error = aboutPluginsHelper.AddAboutPluginsMenuItem(message,
kSDKDefAboutSDKCompanyPluginsGroupName,
ai::UnicodeString(kSDKDefAboutSDKCompanyPluginsGroupNameString),
kSnippetRunnerPluginName "...",
&fAboutPluginMenu);
aisdk::check_ai_error(error);
// Add an SDK menu group to the Windows menu.
const char* kSDKWindowsMenuGroup = "SDKWindowGroup";
bool exists = false;
error = this->MenuGroupExists(kSDKWindowsMenuGroup, exists);
aisdk::check_ai_error(error);
if (!exists) {
AIPlatformAddMenuItemDataUS menuItemData;
menuItemData.groupName = kOtherPalettesMenuGroup;
menuItemData.itemText = ai::UnicodeString("SDK");
AIMenuItemHandle menuItemHandle = nil;
// error = sAIMenu->AddMenuItem(message->d.self, NULL, &menuItemData, kMenuItemNoOptions, &menuItemHandle);
// aisdk::check_ai_error(error);
AIMenuGroup menuGroup = nil;
// error = sAIMenu->AddMenuGroupAsSubMenu(kSDKWindowsMenuGroup, kMenuGroupSortedAlphabeticallyOption, menuItemHandle, &menuGroup);
// aisdk::check_ai_error(error);
}
// Add menu item for this plug-in under the company's about plug-ins menu group.
AIPlatformAddMenuItemDataUS showHidePanelMenuData;
showHidePanelMenuData.groupName = kSDKWindowsMenuGroup;
showHidePanelMenuData.itemText = ai::UnicodeString(kSnippetRunnerPluginName);
AIMenuItemHandle showHidePanelMenuItemHandle = nil;
// error = sAIMenu->AddMenuItem(message->d.self, NULL, &showHidePanelMenuData, kMenuItemWantsUpdateOption, &showHidePanelMenuItemHandle);
// aisdk::check_ai_error(error);
fShowHidePanelMenu = showHidePanelMenuItemHandle;
return error;
}
/*
*/
AIErr SnippetRunnerPlugin::MenuGroupExists(const char* targetGroupName, bool& groupAlreadyMade)
{
AIErr error = kNoErr;
groupAlreadyMade = false;
ai::int32 count = 0;
AIMenuGroup dummyGroup = nil;
error = sAIMenu->CountMenuGroups(&count);
if (error) return error;
for (ai::int32 i = 0; i < count; i++)
{
error = sAIMenu->GetNthMenuGroup(i, &dummyGroup);
aisdk::check_ai_error(error);
const char* name;
error = sAIMenu->GetMenuGroupName(dummyGroup, &name);
aisdk::check_ai_error(error);
if (std::strcmp(name, targetGroupName) == 0)
{
groupAlreadyMade = true;
break;
}
}
return error;
}
/*
*/
ASErr SnippetRunnerPlugin::AcquirePostStartupSuites()
{
ASErr error = kNoErr;
for (int i = 0; gPostStartupSuites.name != nil; ++i) {
if (gPostStartupSuites.suite != nil) {
ASErr tmperr = sSPBasic->AcquireSuite(gPostStartupSuites.name,
gPostStartupSuites.version,
(const void **)gPostStartupSuites.suite);
SDK_ASSERT_MSG_NOTHROW(!tmperr,
aisdk::format_args("AcquireSuite failed for suite=%s version=%d",
gPostStartupSuites.name,
gPostStartupSuites.version));
if (tmperr && !error) {
// A suite could not be acquired - note first error encountered for later return to caller then carry on.
error = tmperr;
}
}
}
return error;
}
/*
*/
ASErr SnippetRunnerPlugin::ReleasePostStartupSuites()
{
ASErr error = kNoErr;
for (int i = 0; gPostStartupSuites.name != nil; ++i) {
if (gPostStartupSuites.suite != nil) {
void **s = (void **)gPostStartupSuites.suite;
if (*s != nil) {
ASErr tmperr = sSPBasic->ReleaseSuite(gPostStartupSuites.name, gPostStartupSuites.version);
*s = nil;
SDK_ASSERT_MSG_NOTHROW(!tmperr,
aisdk::format_args("ReleaseSuite failed for suite=%s version=%d",
gPostStartupSuites.name,
gPostStartupSuites.version));
if (tmperr && !error) {
// A suite could not be released - note first error encountered for later return to caller then carry on.
error = tmperr;
}
}
}
}
return error;
}
/*
*/
ASErr SnippetRunnerPlugin::GoTimer(AITimerMessage* message)
{
// This plug-in only has one timer - used for running unit tests.
SnippetRunnerUnitTestManager::Instance()->GoTimer(message);
return kNoErr;
}
/*
*/
void SnippetRunnerPlugin::NotifyLogChanged()
{
if (fSnippetRunnerPanelController)
{
fSnippetRunnerPanelController->HandleLogChanged();
}
}
/*
*/
void SnippetRunnerPlugin::NotifyEndUnitTest()
{
if (fSnippetRunnerPanelController)
{
fSnippetRunnerPanelController->HandleModelChanged();
}
}
// End SnippetRunnerPlugin.cpp
1 Correct answer
12
Replies
AdChoices