MStatus pnTriangles::getFloat3(MObject attr, float value[3])
{
MStatus status;
// Get the attr to use
//
MPlug plug(thisMObject(), attr);
MObject object;
status = plug.getValue(object);
if (!status)
{
status.perror("pnTrianglesNode::bind plug.getValue.");
return status;
}
MFnNumericData data(object, &status);
if (!status)
{
status.perror("pnTrianglesNode::bind construct data.");
return status;
}
status = data.getData(value[0], value[1], value[2]);
if (!status)
{
status.perror("pnTrianglesNode::bind get values.");
return status;
}
return MS::kSuccess;
}
void KPlayerTrackActionList::update (const QMap<int, QString>& ids, int id)
{
unplug();
if ( ids.count() > 1 )
addActions (ids, id);
plug();
}
PluginT* installPlugin(List&&... constructorParameters)
{
std::unique_ptr <Plugin> plug (new PluginT {this, std::forward <List> (constructorParameters)...});
plugins.push_back(std::move(plug));
plugins.back()->install();
return static_cast <PluginT*> (plugins.back().get());
}
MStatus PRTAttrs::addColorParameter(MFnDependencyNode & node, MObject & attr, const MString & name, MString & value ) {
MStatus stat;
MFnNumericAttribute nAttr;
const wchar_t* s = value.asWChar();
attr = nAttr.createColor(longName(name), briefName(name), &stat );
MCHECK(stat);
double r = 0.0;
double g = 0.0;
double b = 0.0;
if (s[0] == '#' && wcslen(s) >= 7) {
r = (double)((prtu::fromHex(s[1]) << 4) + prtu::fromHex(s[2])) / 255.0;
g = (double)((prtu::fromHex(s[3]) << 4) + prtu::fromHex(s[4])) / 255.0;
b = (double)((prtu::fromHex(s[5]) << 4) + prtu::fromHex(s[6])) / 255.0;
nAttr.setDefault(r, g, b);
}
MCHECK(addParameter(node, attr, nAttr));
MFnNumericData fnData;
MObject rgb = fnData.create(MFnNumericData::k3Double, &stat);
MCHECK(stat);
fnData.setData(r, g, b);
MPlug plug(node.object(), attr);
MCHECK(plug.setValue(rgb));
return MS::kSuccess;
}
void maTranslator::getSetAttrCmds(const MObject& node, MStringArray& cmds)
{
//
// Get rid of any garbage already in the array.
//
cmds.clear();
//
// Run through the node's attributes.
//
MFnDependencyNode nodeFn(node);
unsigned int numAttrs = nodeFn.attributeCount();
unsigned int i;
for (i = 0; i < numAttrs; i++)
{
//
// Use the attribute ordering which Maya uses when doing I/O.
//
MObject attr = nodeFn.reorderedAttribute(i);
MFnAttribute attrFn(attr);
MStatus status;
attrFn.parent(&status);
bool isChild = (status != MS::kNotFound);
//
// We don't want attributes which are children of other attributes
// because they will be processed when we process the parent.
//
// And we only want storable attributes which accept inputs.
//
if (!isChild && attrFn.isStorable() && attrFn.isWritable())
{
//
// Get a plug for the attribute.
//
MPlug plug(node, attr);
//
// Get setAttr commands for this attribute, and any of its
// children, which have had their values changed by the scene.
//
MStringArray newCmds;
plug.getSetAttrCmds(newCmds, MPlug::kChanged, false);
unsigned int numCommands = newCmds.length();
unsigned int c;
for (c = 0; c < numCommands; c++)
{
if (newCmds[c] != "")
cmds.append(newCmds[c]);
}
}
}
}
bool curvedArrows::drawLast() const
{
MObject thisNode = thisMObject();
MPlug plug( thisNode, aEnableDrawLast );
bool value;
plug.getValue( value );
return value;
}
void Processor::plugNext(const Output* source) {
for (size_t i = 0; i < inputs_.size(); ++i) {
if (inputs_[i]->source == &Processor::null_source_) {
plug(source, i);
return;
}
}
}
bool curvedArrows::isTransparent( ) const
{
MObject thisNode = thisMObject();
MPlug plug( thisNode, aEnableTransparencySort );
bool value;
plug.getValue( value );
return value;
}
bool BasicLocator::isTransparent() const
{
MPlug plug(thisMObject(), aIsTransparent);
bool value;
plug.getValue(value);
return value;
}
bool HelixBase_NextBase(const MObject & base, const MObject & attribute, MDagPath & result, MStatus *retStatus) {
MStatus status;
MPlug plug(base, attribute);
MPlugArray plugArray;
if (plug.connectedTo(plugArray, true, true, &status)) {
unsigned int plugArray_length = plugArray.length();
for(unsigned int i = 0; i < plugArray_length; ++i) {
MObject target = plugArray[i].node(&status);
if (!status) {
status.perror("MPlugArray[i]::node");
if (retStatus)
*retStatus = status;
return false;
}
MFnDagNode dagNode(target);
if (dagNode.typeId(&status) == HelixBase::id) {
if (!(status = dagNode.getPath(result))) {
status.perror("MFnDagNode::getPath");
if (retStatus)
*retStatus = status;
return false;
}
return true;
}
if (!status) {
status.perror("MFnDagNode::typeId");
if (retStatus)
*retStatus = status;
return false;
}
}
}
if (!status) {
status.perror("MPlug::connectedTo");
if (retStatus)
*retStatus = status;
return false;
}
return false;
}
int main()
{
using blender_t = my_code::GenericAppliance<third_party::Blender>;
using toaster_t = my_code::GenericAppliance<third_party::Toaster>;
my_code::MultiPowerPoint plug (std::make_unique<blender_t>(), std::make_unique<toaster_t>());
plug.switchOn();
return 0;
}
MStatus PRTAttrs::addBoolParameter(MFnDependencyNode & node, MObject & attr, const MString & name, bool value) {
MStatus stat;
MFnNumericAttribute nAttr;
attr = nAttr.create(longName(name), briefName(name), MFnNumericData::kBoolean, value, &stat);
if ( stat != MS::kSuccess ) throw stat;
MCHECK(addParameter(node, attr, nAttr));
MPlug plug(node.object(), attr);
MCHECK(plug.setValue(value));
return MS::kSuccess;
}
void rigidBodyNode::draw( M3dView & view, const MDagPath &path,
M3dView::DisplayStyle style,
M3dView::DisplayStatus status )
{
// std::cout << "rigidBodyNode::draw" << std::endl;
MObject thisObject(thisMObject());
update();
view.beginGL();
glPushAttrib( GL_ALL_ATTRIB_BITS );
if(m_rigid_body) {
//remove the scale, since it's already included in the node transform
vec3f scale;
m_rigid_body->collision_shape()->get_scale(scale);
glPushMatrix();
glScalef(1/scale[0], 1/scale[1], 1/scale[2]);
if(style == M3dView::kFlatShaded || style == M3dView::kGouraudShaded) {
glEnable(GL_LIGHTING);
MPlug plug(thisObject, rigidBodyNode::ia_mass);
float mass;
plug.getValue(mass);
if (mass) {
float material[] = { 0.2f, 1.0f, 0.2f, 1.0f };
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, material);
} else {
float material[] = { 1.0f, 0.3f, 0.1f, 1.0f };
glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, material);
}
//glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, material);
m_rigid_body->collision_shape()->gl_draw(collision_shape_t::kDSSolid);
}
if( status == M3dView::kActive ||
status == M3dView::kLead ||
status == M3dView::kHilite ||
( style != M3dView::kGouraudShaded && style != M3dView::kFlatShaded ) ) {
glDisable(GL_LIGHTING);
m_rigid_body->collision_shape()->gl_draw(collision_shape_t::kDSWireframe);
}
glPopMatrix();
}
glPopAttrib();
view.endGL();
}
MStatus initializePlugin( MObject obj )
{
// Init Log
MString k3dLogDir(getenv("KALEIDO3D_DIR"));
k3d::Log::InitLogFile((k3dLogDir + "/Data/MayaToolkitLog.html").asChar());
MStatus status = MStatus::kFailure;
MFnPlugin plug(obj, MAYA_PLUGIN_COMPANY, MAYA_PLUGIN_VERSION, MAYA_PLUGIN_REQUIREDAPI);
gRenderer = new Mk3dRenderer();
if (gRenderer)
{
status = gRenderer->registerRenderer();
if (status != MStatus::kSuccess)
{
status.perror("Failed to register Kaleido3D renderer properly.");
}
}
/*
gRendererHUD = new Mk3dRendererHUD();
if (gRendererHUD)
{
status = gRendererHUD->registerRenderer();
if (status != MStatus::kSuccess)
{
status.perror("Failed to register Kaleido3D renderer properly.");
}
}
gRendererFullUI = new Mk3dRendererFullUI();
if (gRendererFullUI)
{
status = gRendererFullUI->registerRenderer();
if (status != MStatus::kSuccess)
{
status.perror("Failed to register Kaleido3D renderer properly.");
}
}
*/
status = plug.registerFileTranslator(
MAYA_TRANSLATOR,
"none",
DCTranslator::creator
);
if (status != MStatus::kSuccess)
{
status.perror("Failed to register Kaleido3D Translator properly.");
}
return status;
}
void Processor::plugNext(const Output* source) {
for (size_t i = 0; i < inputs_->size(); ++i) {
Input* input = inputs_->at(i);
if (input && input->source == &Processor::null_source_) {
plug(source, i);
return;
}
}
// If there are no empty inputs, create another.
Input* input = new Input();
owned_inputs_.push_back(input);
input->source = source;
registerInput(input);
}
MStatus PRTAttrs::addStrParameter(MFnDependencyNode & node, MObject & attr, const MString & name, MString & value ) {
MStatus stat;
MStatus stat2;
MFnStringData stringData;
MFnTypedAttribute sAttr;
attr = sAttr.create(longName(name), briefName(name), MFnData::kString, stringData.create(value, &stat2), &stat );
MCHECK(stat2);
MCHECK(stat);
MCHECK(addParameter(node, attr, sAttr));
MPlug plug(node.object(), attr);
MCHECK(plug.setValue(value));
return MS::kSuccess;
}
/** Decode a LinkFI field of encoded stat packet */
int32_t decode_LinkFI(char *buf, struct stat *statp, int stat_size)
{
char *p = buf;
int64_t val;
/*
* We store into the stat packet so make sure the caller's conception
* is the same as ours. They can be different if LARGEFILE is not
* the same when compiling this library and the calling program.
*/
ASSERT(stat_size == (int)sizeof(struct stat));
skip_nonspaces(&p); /* st_dev */
p++; /* skip space */
skip_nonspaces(&p); /* st_ino */
p++;
p += from_base64(&val, p);
plug(statp->st_mode, val); /* st_mode */
p++;
skip_nonspaces(&p); /* st_nlink */
p++;
skip_nonspaces(&p); /* st_uid */
p++;
skip_nonspaces(&p); /* st_gid */
p++;
skip_nonspaces(&p); /* st_rdev */
p++;
skip_nonspaces(&p); /* st_size */
p++;
skip_nonspaces(&p); /* st_blksize */
p++;
skip_nonspaces(&p); /* st_blocks */
p++;
skip_nonspaces(&p); /* st_atime */
p++;
skip_nonspaces(&p); /* st_mtime */
p++;
skip_nonspaces(&p); /* st_ctime */
/* Optional FileIndex of hard linked file data */
if (*p == ' ' || (*p != 0 && *(p+1) == ' ')) {
p++;
p += from_base64(&val, p);
return (int32_t)val;
}
return 0;
}
MStatus PRTAttrs::addEnumParameter(MFnDependencyNode & node, MObject & attr, const MString & name, short value, PRTEnum * e) {
MStatus stat;
attr = e->mAttr.create(longName(name), briefName(name), value, &stat);
MCHECK(stat);
MCHECK(e->fill());
MCHECK(addParameter(node, attr, e->mAttr));
MPlug plug(node.object(), attr);
MCHECK(plug.setValue(value));
return MS::kSuccess;
}
void KPlayerSimpleActionList::update (void)
{
#ifdef DEBUG_KPLAYER_ACTIONLIST
kdDebugTime() << "KPlayerSimpleActionList::update\n";
#endif
unplug();
QStringList::ConstIterator iterator (m_names.constBegin());
while ( iterator != m_names.constEnd() )
{
QAction* action = new KAction (this);
connect (action, SIGNAL (triggered()), SLOT (actionActivated()));
action -> setText (*iterator);
updateAction (action);
m_actions.append (action);
++ iterator;
}
plug();
}
MStatus uninitializePlugin( MObject obj )
{
MFnPlugin plug( obj );
MStatus status = MStatus::kSuccess;
// Deregister the renderer
if (gRenderer)
{
status = gRenderer->deregisterRenderer();
if (status != MStatus::kSuccess)
{
status.perror("Failed to deregister Kaleido3D renderer properly.");
}
}
gRenderer = 0;
/*
if (gRendererHUD)
{
status = gRendererHUD->deregisterRenderer();
if (status != MStatus::kSuccess)
{
status.perror("Failed to deregister Kaleido3D renderer properly.");
}
}
gRendererHUD = 0;
if (gRendererFullUI)
{
status = gRendererFullUI->deregisterRenderer();
if (status != MStatus::kSuccess)
{
status.perror("Failed to deregister Kaleido3D renderer properly.");
}
}
gRendererFullUI = 0;
*/
status = plug.deregisterFileTranslator(MAYA_TRANSLATOR);
if (status != MStatus::kSuccess)
{
status.perror("Failed to deregister Kaleido3D Translator properly.");
}
k3d::Log::CloseLog();
return status;
}
MBoundingBox swissArmyLocator::boundingBox() const
{
// Get the size
//
MObject thisNode = thisMObject();
MPlug plug(thisNode, aSize);
MDistance sizeVal;
plug.getValue(sizeVal);
double multiplier = sizeVal.asCentimeters();
MPoint corner1(-1.1, 0.0, -1.1);
MPoint corner2(1.1, 0.0, 1.1);
corner1 = corner1 * multiplier;
corner2 = corner2 * multiplier;
return MBoundingBox(corner1, corner2);
}
MBoundingBox footPrint::boundingBox() const
{
// Get the size
//
MObject thisNode = thisMObject();
MPlug plug( thisNode, size );
MDistance sizeVal;
plug.getValue( sizeVal );
double multiplier = sizeVal.asCentimeters();
MPoint corner1( -0.17, 0.0, -0.7 );
MPoint corner2( 0.17, 0.0, 0.3 );
corner1 = corner1 * multiplier;
corner2 = corner2 * multiplier;
return MBoundingBox( corner1, corner2 );
}
MStatus tm_polySplit::initModifierNode( MObject modifierNode )
{
// We need to tell the tm_polySplit node which UVs to operate on. By overriding
// the polyModifierCmd::initModifierNode() method, we can insert our own
// modifierNode initialization code.
//
MFnDependencyNode depNodeFn( modifierNode );
MObject attrObj;
attrObj = depNodeFn.attribute( "inputComponents" );
MPlug plug( modifierNode, attrObj );
plug.setValue( fComponentList );
#ifdef _DEBUG
cout << endl << "tm_polySplit::initModifierNode : splitAlgorithm=";
cout<<cmd_flag_sel<<" loopMode="<<cmd_flag_loop_mode<<" loop_angle="<<cmd_flag_loop_angle<<" loop_maxcount="<<cmd_flag_loop_maxcount<<endl;
#endif
if( cmd_flag_loop)
{
attrObj = depNodeFn.attribute( "splitAlgorithm");
plug.setAttribute( attrObj);
plug.setValue( 0);
attrObj = depNodeFn.attribute( "loopMode");
plug.setAttribute( attrObj);
plug.setValue( cmd_flag_loop_mode);
attrObj = depNodeFn.attribute( "loopAngle");
plug.setAttribute( attrObj);
plug.setValue( cmd_flag_loop_angle);
attrObj = depNodeFn.attribute( "loopMaxCount");
plug.setAttribute( attrObj);
plug.setValue( cmd_flag_loop_maxcount);
}
else
{
attrObj = depNodeFn.attribute( "splitAlgorithm");
plug.setAttribute( attrObj);
plug.setValue( 1);
}
return MStatus::kSuccess;
}
void make_move(t_list **a, t_list **b, t_list **in, enum e_instr instr)
{
plug(in, new_node(instr));
if (instr == PA)
push(a, pop(b));
if (instr == PB)
push(b, pop(a));
if (instr == SA || instr == SS)
swap(a);
if (instr == SB || instr == SS)
swap(b);
if (instr == RA || instr == RR)
rot_up(a);
if (instr == RB || instr == RR)
rot_up(b);
if (instr == RRA || instr == RRR)
rot_down(a);
if (instr == RRB || instr == RRR)
rot_down(b);
}
float FootPrintDrawOverride::getMultiplier(const MDagPath& objPath) const
{
// Retrieve value of the size attribute from the node
MStatus status;
MObject footprintNode = objPath.node(&status);
if (status)
{
MPlug plug(footprintNode, footPrint::size);
if (!plug.isNull())
{
MDistance sizeVal;
if (plug.getValue(sizeVal))
{
return (float)sizeVal.asCentimeters();
}
}
}
return 1.0f;
}
void KPlayerSubtitleTrackActionList::update (bool show, const QMap<int, QString>& sids, int sid,
const QMap<int, QString>& vsids, int vsid, QStringList files, const QString& vobsub, const QString& current)
{
unplug();
if ( sids.count() > 0 || vsids.count() > 0 || files.count() > 0 )
{
KToggleAction* action = new KToggleAction (m_action_group);
connect (action, SIGNAL (triggered()), SLOT (actionActivated()));
action -> setText (i18n("&None"));
action -> setStatusTip (i18n("Turns off subtitle display"));
action -> setWhatsThis (i18n("The 'Subtitles -- None' command turns off subtitle display."));
if ( ! show )
action -> setChecked (true);
m_actions.append (action);
addActions (sids, sid);
addActions (vsids, vsid);
if ( vsids.isEmpty() )
files << vobsub;
QStringList::ConstIterator iterator (files.constBegin()), end (files.constEnd());
while ( iterator != end )
{
QString text ((*iterator).section ('/', -1, -1));
#ifdef DEBUG_KPLAYER_ACTIONLIST
kdDebugTime() << " Subtitle file '" << text << "' " << *iterator << "\n";
#endif
if ( ! text.isEmpty() )
{
action = new KToggleAction (m_action_group);
connect (action, SIGNAL (triggered()), SLOT (actionActivated()));
action -> setText (text);
updateAction (action);
action -> setText (text);
if ( show && sid < 0 && vsid < 0 && *iterator == current )
action -> setChecked (true);
m_actions.append (action);
}
++ iterator;
}
}
plug();
}
MStatus PRTAttrs::addFloatParameter(MFnDependencyNode & node, MObject & attr, const MString & name, double value, double min, double max) {
MStatus stat;
MFnNumericAttribute nAttr;
attr = nAttr.create(longName(name), briefName(name), MFnNumericData::kDouble, value, &stat );
if ( stat != MS::kSuccess ) throw stat;
if(!isnan(min)) {
MCHECK(nAttr.setMin(min));
}
if(!isnan(max)) {
MCHECK(nAttr.setMax( max ));
}
MCHECK(addParameter(node, attr, nAttr));
MPlug plug(node.object(), attr);
MCHECK(plug.setValue(value));
return MS::kSuccess;
}
bool getObjectShadingGroups(const MObject& geoObject, MObject& sGroup, int instId)
{
MPlugArray connections;
MFnDependencyNode dependNode(geoObject);
MPlug plug(geoObject, dependNode.attribute("instObjGroups"));
plug.elementByLogicalIndex(instId).connectedTo(connections, false, true);
if (connections.length() > 0)
{
MObject shadingGroup(connections[0].node());
if (shadingGroup.apiType() == MFn::kShadingEngine)
{
sGroup = shadingGroup;
return true;
}
}
else
Logging::debug(MString("Object-instObjGroups has no connection to shading group."));
return false;
}
/**
* Set Extended File Attributes for Win32
*
* fname is the original filename
* ofile is the output filename (may be in a different directory)
*
* Returns: true on success
* false on failure
*/
static bool set_win32_attributes(JCR *jcr, ATTR *attr, BFILE *ofd)
{
char *p = attr->attrEx;
int64_t val;
WIN32_FILE_ATTRIBUTE_DATA atts;
ULARGE_INTEGER li;
POOLMEM *win32_ofile;
/** if we have neither Win ansi nor wchar API, get out */
if (!(p_SetFileAttributesW || p_SetFileAttributesA)) {
return false;
}
if (!p || !*p) { /* we should have attributes */
Dmsg2(100, "Attributes missing. of=%s ofd=%d\n", attr->ofname, ofd->fid);
if (is_bopen(ofd)) {
bclose(ofd);
}
return false;
} else {
Dmsg2(100, "Attribs %s = %s\n", attr->ofname, attr->attrEx);
}
p += from_base64(&val, p);
plug(atts.dwFileAttributes, val);
p++; /* skip space */
p += from_base64(&val, p);
li.QuadPart = val;
atts.ftCreationTime.dwLowDateTime = li.LowPart;
atts.ftCreationTime.dwHighDateTime = li.HighPart;
p++; /* skip space */
p += from_base64(&val, p);
li.QuadPart = val;
atts.ftLastAccessTime.dwLowDateTime = li.LowPart;
atts.ftLastAccessTime.dwHighDateTime = li.HighPart;
p++; /* skip space */
p += from_base64(&val, p);
li.QuadPart = val;
atts.ftLastWriteTime.dwLowDateTime = li.LowPart;
atts.ftLastWriteTime.dwHighDateTime = li.HighPart;
p++;
p += from_base64(&val, p);
plug(atts.nFileSizeHigh, val);
p++;
p += from_base64(&val, p);
plug(atts.nFileSizeLow, val);
/** Convert to Windows path format */
win32_ofile = get_pool_memory(PM_FNAME);
unix_name_to_win32(&win32_ofile, attr->ofname);
/** At this point, we have reconstructed the WIN32_FILE_ATTRIBUTE_DATA pkt */
if (!is_bopen(ofd)) {
Dmsg1(100, "File not open: %s\n", attr->ofname);
bopen(ofd, attr->ofname, O_WRONLY|O_BINARY, 0); /* attempt to open the file */
}
if (is_bopen(ofd)) {
Dmsg1(100, "SetFileTime %s\n", attr->ofname);
if (!SetFileTime(bget_handle(ofd),
&atts.ftCreationTime,
&atts.ftLastAccessTime,
&atts.ftLastWriteTime)) {
win_error(jcr, "SetFileTime:", win32_ofile);
}
bclose(ofd);
}
Dmsg1(100, "SetFileAtts %s\n", attr->ofname);
if (!(atts.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
if (p_SetFileAttributesW) {
POOLMEM* pwszBuf = get_pool_memory(PM_FNAME);
make_win32_path_UTF8_2_wchar(&pwszBuf, attr->ofname);
BOOL b=p_SetFileAttributesW((LPCWSTR)pwszBuf, atts.dwFileAttributes & SET_ATTRS);
free_pool_memory(pwszBuf);
if (!b)
win_error(jcr, "SetFileAttributesW:", win32_ofile);
}
else {
if (!p_SetFileAttributesA(win32_ofile, atts.dwFileAttributes & SET_ATTRS)) {
win_error(jcr, "SetFileAttributesA:", win32_ofile);
}
}
}
free_pool_memory(win32_ofile);
return true;
}
/** Decode a stat packet from base64 characters */
int decode_stat(char *buf, struct stat *statp, int stat_size, int32_t *LinkFI)
{
char *p = buf;
int64_t val;
/*
* We store into the stat packet so make sure the caller's conception
* is the same as ours. They can be different if LARGEFILE is not
* the same when compiling this library and the calling program.
*/
ASSERT(stat_size == (int)sizeof(struct stat));
p += from_base64(&val, p);
plug(statp->st_dev, val);
p++;
p += from_base64(&val, p);
plug(statp->st_ino, val);
p++;
p += from_base64(&val, p);
plug(statp->st_mode, val);
p++;
p += from_base64(&val, p);
plug(statp->st_nlink, val);
p++;
p += from_base64(&val, p);
plug(statp->st_uid, val);
p++;
p += from_base64(&val, p);
plug(statp->st_gid, val);
p++;
p += from_base64(&val, p);
plug(statp->st_rdev, val);
p++;
p += from_base64(&val, p);
plug(statp->st_size, val);
p++;
#ifndef HAVE_MINGW
p += from_base64(&val, p);
plug(statp->st_blksize, val);
p++;
p += from_base64(&val, p);
plug(statp->st_blocks, val);
p++;
#else
p += from_base64(&val, p);
// plug(statp->st_blksize, val);
p++;
p += from_base64(&val, p);
// plug(statp->st_blocks, val);
p++;
#endif
p += from_base64(&val, p);
plug(statp->st_atime, val);
p++;
p += from_base64(&val, p);
plug(statp->st_mtime, val);
p++;
p += from_base64(&val, p);
plug(statp->st_ctime, val);
/* Optional FileIndex of hard linked file data */
if (*p == ' ' || (*p != 0 && *(p+1) == ' ')) {
p++;
p += from_base64(&val, p);
*LinkFI = (uint32_t)val;
} else {
*LinkFI = 0;
return 0;
}
/* FreeBSD user flags */
if (*p == ' ' || (*p != 0 && *(p+1) == ' ')) {
p++;
p += from_base64(&val, p);
#ifdef HAVE_CHFLAGS
plug(statp->st_flags, val);
} else {
statp->st_flags = 0;
#endif
}
/* Look for data stream id */
if (*p == ' ' || (*p != 0 && *(p+1) == ' ')) {
p++;
p += from_base64(&val, p);
} else {
val = 0;
}
return (int)val;
}
