DataPath DataPath::member(const string& name) const {
auto& mgr = path.getNodeManager();
auto& ext = mgr.getLangExtension<lang::DatapathExtension>();
assert_true(getTargetType().isa<TagTypePtr>()) << "Current target must be a tag type!";
auto elementType = getTargetType().as<TagTypePtr>()->getFieldType(name);
assert_true(elementType) << "No member " << name << " in type " << *getTargetType() << "\n";
IRBuilder builder(mgr);
return DataPath(builder.callExpr(ext.getDataPathMember(), path, builder.getIdentifierLiteral(name), builder.getTypeLiteral(elementType)));
}
DataPath DataPath::component(unsigned index) const {
auto& mgr = path.getNodeManager();
auto& ext = mgr.getLangExtension<lang::DatapathExtension>();
assert_true(getTargetType().isa<TupleTypePtr>()) << "Current target must be a tuple type!";
assert_lt(index, getTargetType().as<TupleTypePtr>().size());
auto elementType = getTargetType().as<TupleTypePtr>()[index];
IRBuilder builder(mgr);
return DataPath(builder.callExpr(ext.getDataPathComponent(), path, builder.uintLit(index), builder.getTypeLiteral(elementType)));
}
// append an ascii-version of FastExtract into cachewa.qryText_
void FastExtract::generateCacheKey(CacheWA &cwa) const
{
RelExpr::generateCacheKeyNode(cwa);
char buf[40];
cwa += " targType_ ";
str_itoa(getTargetType(), buf);
cwa += buf;
cwa += " targName_ ";
cwa += getTargetName();
cwa += " delim_ ";
cwa += getDelimiter();
cwa += " isAppend_ ";
cwa += isAppend() ? "1" : "0";
cwa += " includeHeader_ ";
cwa += includeHeader() ? "1" : "0";
cwa += " cType_ ";
str_itoa(getCompressionType(), buf);
cwa += buf;
cwa += " nullString_ ";
cwa += getNullString();
cwa += " recSep_ ";
cwa += getRecordSeparator();
generateCacheKeyForKids(cwa);
}
serialization::UnaryOperation getProto() const override {
serialization::UnaryOperation proto;
proto.set_operation_id(serialization::UnaryOperation::CAST);
proto.MutableExtension(serialization::CastOperation::target_type)
->CopyFrom(getTargetType().getProto());
return proto;
}
int32_t getBusEndpoints( ExtensibleChip * i_chip,
TargetHandle_t & o_rxTrgt, TargetHandle_t & o_txTrgt,
TYPE i_busType, uint32_t i_busPos )
{
#define PRDF_FUNC "[CalloutUtil::getBusEndpoints] "
int32_t rc = SUCCESS;
o_rxTrgt = NULL;
o_txTrgt = NULL;
TargetHandle_t chipTrgt = i_chip->GetChipHandle();
TYPE chipType = getTargetType(chipTrgt);
if ( TYPE_PROC == chipType )
{
o_rxTrgt = getConnectedChild( chipTrgt, i_busType, i_busPos );
if ( TYPE_ABUS == i_busType || TYPE_XBUS == i_busType )
{
o_txTrgt = getConnectedPeerTarget( o_rxTrgt );
}
else if ( TYPE_MCS == i_busType )
{
o_txTrgt = getConnectedChild( o_rxTrgt, TYPE_MEMBUF, 0 );
}
}
else if ( TYPE_MCS == chipType )
{
o_rxTrgt = chipTrgt;
o_txTrgt = getConnectedChild( o_rxTrgt, TYPE_MEMBUF, 0 );
}
else if ( TYPE_MEMBUF == chipType )
{
o_rxTrgt = chipTrgt;
o_txTrgt = getConnectedParent( o_rxTrgt, TYPE_MCS );
}
// Note that all of the 'getConnected' functions above do proper parameter
// checking and will return NULL if anything is wrong. So this is the only
// NULL check we actually need in this function.
if ( NULL == o_rxTrgt || NULL == o_txTrgt )
{
PRDF_ERR( PRDF_FUNC "i_chip:0x%08x o_rxTrgt:0x%08x o_txTrgt:0x%08x "
"i_busType:%d i_busPos:%d", getHuid(chipTrgt),
getHuid(o_rxTrgt), getHuid(o_txTrgt), i_busType, i_busPos );
rc = FAIL;
}
return rc;
#undef PRDF_FUNC
}
TargetHandleList getConnectedDimms( TargetHandle_t i_mba )
{
TargetHandleList o_list;
if ( TYPE_MBA != getTargetType(i_mba) )
{
PRDF_ERR( "[CalloutUtil::getConnectedDimms] Invalid target type: "
"HUID=0x%08x", getHuid(i_mba) );
}
else
o_list = getConnected( i_mba, TYPE_DIMM );
return o_list;
}
int32_t mdiaSendEventMsg( TargetHandle_t i_mbaTarget,
MDIA::MaintCommandEventType i_eventType )
{
#define PRDF_FUNC "[PlatServices::mdiaSendCmdComplete] "
int32_t o_rc = SUCCESS;
do
{
if ( !isInMdiaMode() ) break; // no-op
// Verify type.
TYPE l_type = getTargetType(i_mbaTarget);
if ( TYPE_MBA != l_type )
{
PRDF_ERR( PRDF_FUNC"unsupported target type %d", l_type );
o_rc = FAIL;
break;
}
// Send command complete to MDIA.
MDIA::MaintCommandEvent l_mdiaEvent;
l_mdiaEvent.target = i_mbaTarget;
l_mdiaEvent.type = i_eventType;
errlHndl_t errl = MDIA::processEvent( l_mdiaEvent );
if ( NULL != errl )
{
PRDF_ERR( PRDF_FUNC"MDIA::processEvent() failed" );
PRDF_COMMIT_ERRL( errl, ERRL_ACTION_REPORT );
o_rc = FAIL;
break;
}
} while (0);
if ( SUCCESS != o_rc )
{
PRDF_ERR( PRDF_FUNC"Failed: i_target=0x%08x i_eventType=%d",
getHuid(i_mbaTarget), i_eventType );
}
return o_rc;
#undef PRDF_FUNC
}
TargetHandleList getConnectedDimms( TargetHandle_t i_mba,
const CenRank & i_rank )
{
#define PRDF_FUNC "[CalloutUtil::getConnectedDimms] "
TargetHandleList o_list;
if ( TYPE_MBA != getTargetType(i_mba) )
{
PRDF_ERR( PRDF_FUNC "Invalid target type: HUID=0x%08x", getHuid(i_mba) );
}
else
{
TargetHandleList dimmList = getConnected( i_mba, TYPE_DIMM );
for ( TargetHandleList::iterator dimmIt = dimmList.begin();
dimmIt != dimmList.end(); dimmIt++)
{
uint8_t dimmSlct;
int32_t l_rc = getMbaDimm( *dimmIt, dimmSlct );
if ( SUCCESS != l_rc )
{
PRDF_ERR( PRDF_FUNC "getMbaDimm(0x%08x) failed",
getHuid(*dimmIt) );
continue;
}
if ( dimmSlct == i_rank.getDimmSlct() )
{
o_list.push_back( *dimmIt );
}
}
}
return o_list;
#undef PRDF_FUNC
}
short
PhysicalFastExtract::codeGen(Generator *generator)
{
short result = 0;
Space *space = generator->getSpace();
CmpContext *cmpContext = generator->currentCmpContext();
const ULng32 downQueueMaxSize = getDefault(GEN_FE_SIZE_DOWN);
const ULng32 upQueueMaxSize = getDefault(GEN_FE_SIZE_UP);
const ULng32 defaultBufferSize = getDefault(GEN_FE_BUFFER_SIZE);
const ULng32 outputBufferSize = defaultBufferSize;
const ULng32 requestBufferSize = defaultBufferSize;
const ULng32 replyBufferSize = defaultBufferSize;
const ULng32 numOutputBuffers = getDefault(GEN_FE_NUM_BUFFERS);
// used in runtime stats
Cardinality estimatedRowCount = (Cardinality)
(getInputCardinality() * getEstRowsUsed()).getValue();
Int32 numChildren = getArity();
ex_cri_desc * givenDesc = generator->getCriDesc(Generator::DOWN);
ComTdb * childTdb = (ComTdb*) new (space) ComTdb();
ExplainTuple *firstExplainTuple = 0;
// Allocate a new map table for this child.
//
MapTable *localMapTable = generator->appendAtEnd();
generator->setCriDesc(givenDesc, Generator::DOWN);
child(0)->codeGen(generator);
childTdb = (ComTdb *)(generator->getGenObj());
firstExplainTuple = generator->getExplainTuple();
ComTdbFastExtract *newTdb = NULL;
char * targetName = NULL;
char * hiveTableName = NULL;
char * delimiter = NULL;
char * header = NULL;
char * nullString = NULL;
char * recordSeparator = NULL;
char * hdfsHostName = NULL;
Int32 hdfsPortNum = getHdfsPort();
char * newDelimiter = (char *)getDelimiter().data();
char specChar = '0';
if (!isHiveInsert() && isSpecialChar(newDelimiter, specChar))
{
newDelimiter = new (cmpContext->statementHeap()) char[2];
newDelimiter[0] = specChar;
newDelimiter[1] = '\0';
}
char * newRecordSep = (char *)getRecordSeparator().data();
specChar = '0';
if (!isHiveInsert() && isSpecialChar(newRecordSep, specChar))
{
newRecordSep = new (cmpContext->statementHeap()) char[2];
newRecordSep[0] = specChar;
newRecordSep[1] = '\0';
}
targetName = AllocStringInSpace(*space, (char *)getTargetName().data());
hdfsHostName = AllocStringInSpace(*space, (char *)getHdfsHostName().data());
hiveTableName = AllocStringInSpace(*space, (char *)getHiveTableName().data());
delimiter = AllocStringInSpace(*space, newDelimiter);
header = AllocStringInSpace(*space, (char *)getHeader().data());
nullString = AllocStringInSpace(*space, (char *)getNullString().data());
recordSeparator = AllocStringInSpace(*space, newRecordSep);
result = ft_codegen(generator,
*this, // RelExpr &relExpr
newTdb, // ComTdbUdr *&newTdb
estimatedRowCount,
targetName,
hdfsHostName,
hdfsPortNum,
hiveTableName,
delimiter,
header,
nullString,
recordSeparator,
downQueueMaxSize,
upQueueMaxSize,
outputBufferSize,
requestBufferSize,
replyBufferSize,
numOutputBuffers,
childTdb,
isSequenceFile());
if (!generator->explainDisabled())
{
generator->setExplainTuple(addExplainInfo(newTdb, firstExplainTuple, 0, generator));
}
if (getTargetType() == FILE)
newTdb->setTargetFile(1);
else if (getTargetType() == SOCKET)
newTdb->setTargetSocket(1);
else
GenAssert(0, "Unexpected Fast Extract target type")
if (isAppend())
newTdb->setIsAppend(1);
if (this->includeHeader())
newTdb->setIncludeHeader(1);
if (isHiveInsert())
{
newTdb->setIsHiveInsert(1);
newTdb->setIncludeHeader(0);
setOverwriteHiveTable( getOverwriteHiveTable());
}
else
{
if (includeHeader())
newTdb->setIncludeHeader(1);
}
if (getCompressionType() != NONE)
{
if (getCompressionType() == LZO)
newTdb->setCompressLZO(1);
else
GenAssert(0, "Unexpected Fast Extract compression type")
}
if((ActiveSchemaDB()->getDefaults()).getToken(FAST_EXTRACT_DIAGS) == DF_ON)
newTdb->setPrintDiags(1);
return result;
}
ExplainTuple *PhysicalFastExtract::addSpecificExplainInfo(ExplainTupleMaster *explainTuple, ComTdb *tdb,
Generator *generator)
{
NAString description = "Target_type: ";
if (getTargetType() == FILE)
{
if (isHiveInsert())
description += "hive table";
else
description += "file";
}
else if (getTargetType() == SOCKET)
description += "socket";
else
description += "none";
if (isHiveInsert())
{
NAString str = getTargetName();
size_t colonIndex = str.index(":", 1,0,NAString::ignoreCase);
while (colonIndex != NA_NPOS)
{
str = str.replace(colonIndex, 1, "_", 1);
colonIndex = str.index(":", 1,0,NAString::ignoreCase);
}
description += " location: ";
description += str;
}
if (isHiveInsert())
{
description += " table_name: ";
description += getHiveTableName();
}
else
{
description += " target_name: ";
description += getTargetName();
}
description += " delimiter: ";
description += getDelimiter();
if (isAppend())
description += " append: yes";
if ( !isHiveInsert() && includeHeader())
{
description += " header: ";
description += getHeader();
}
if (getCompressionType() != NONE)
{
description += " compression_type: ";
if (getCompressionType() == LZO)
description += "LZO";
else
description += "error";
}
description += " null_string: ";
description += getNullString();
description += " record_separator: ";
description += getRecordSeparator();
explainTuple->setDescription(description);
if (isHiveInsert())
explainTuple->setTableName(getHiveTableName());
return explainTuple;
}
// General function to get some basic game values
bool scrGenExternGet(UDWORD index)
{
INTERP_TYPE type;
INTERP_VAL scrFunctionResult; //function return value to be pushed to stack
switch (index)
{
case EXTID_TRACKTRANSPORTER:
type = VAL_BOOL;
scrFunctionResult.v.bval = bTrackTransporter;
break;
case EXTID_MAPWIDTH:
type = VAL_INT;
scrFunctionResult.v.ival = mapWidth;
break;
case EXTID_MAPHEIGHT:
type = VAL_INT;
scrFunctionResult.v.ival = mapHeight;
break;
case EXTID_GAMEINIT:
type = VAL_BOOL;
scrFunctionResult.v.bval = gameInitialised;
break;
case EXTID_SELECTEDPLAYER:
type = VAL_INT;
scrFunctionResult.v.ival = selectedPlayer;
break;
case EXTID_GAMELEVEL:
type = VAL_INT;
scrFunctionResult.v.ival = scrGameLevel;
break;
case EXTID_GAMETIME:
type = VAL_INT;
scrFunctionResult.v.ival = (SDWORD)(gameTime/SCR_TICKRATE);
break;
case EXTID_TUTORIAL:
type = VAL_BOOL;
scrFunctionResult.v.bval = bInTutorial;
break;
case EXTID_CURSOR:
type = VAL_INT;
scrFunctionResult.v.ival = 0; // FIXME Set to 0 since function returned undef value
break;
case EXTID_INTMODE:
type=VAL_INT;
scrFunctionResult.v.ival=intMode;
break;
case EXTID_TARGETTYPE:
type=VAL_INT;
scrFunctionResult.v.ival=getTargetType();
break;
case EXTID_EXTRAVICTORYFLAG:
type=VAL_BOOL;
scrFunctionResult.v.bval=bExtraVictoryFlag;
break;
case EXTID_EXTRAFAILFLAG:
type=VAL_BOOL;
scrFunctionResult.v.bval=bExtraFailFlag;
break;
case EXTID_MULTIGAMETYPE: // multiplayer variable..
type = VAL_INT;
scrFunctionResult.v.ival = game.type;
break;
case EXTID_MULTIGAMEHUMANMAX: // multiplayer variable..
type = VAL_INT;
scrFunctionResult.v.ival = game.maxPlayers;
break;
case EXTID_MULTIGAMEBASETYPE:
type = VAL_INT;
scrFunctionResult.v.ival = game.base;
break;
case EXTID_MULTIGAMEALLIANCESTYPE:
type = VAL_INT;
scrFunctionResult.v.ival = game.alliance;
break;
default:
ASSERT( false, "scrGenExternGet: unknown variable index" );
return false;
break;
}
if (!stackPushResult(type, &scrFunctionResult))
{
return false;
}
return true;
}
int32_t calloutBusInterface( TargetHandle_t i_rxTrgt, TargetHandle_t i_txTrgt,
PRDpriority i_priority )
{
#define PRDF_FUNC "[CalloutUtil::calloutBusInterface] "
int32_t rc = SUCCESS;
do
{
// Check for valid targets.
if ( NULL == i_rxTrgt || NULL == i_txTrgt )
{
PRDF_ERR( PRDF_FUNC "Given target(s) are NULL" );
rc = FAIL; break;
}
// Get the HWAS bus type.
HWAS::busTypeEnum hwasType;
TYPE rxType = getTargetType(i_rxTrgt);
TYPE txType = getTargetType(i_txTrgt);
if ( TYPE_ABUS == rxType && TYPE_ABUS == txType )
{
hwasType = HWAS::A_BUS_TYPE;
}
else if ( TYPE_XBUS == rxType && TYPE_XBUS == txType )
{
hwasType = HWAS::X_BUS_TYPE;
}
else if ( (TYPE_MCS == rxType && TYPE_MEMBUF == txType) ||
(TYPE_MEMBUF == rxType && TYPE_MCS == txType) )
{
hwasType = HWAS::DMI_BUS_TYPE;
}
else
{
PRDF_ERR( PRDF_FUNC "Unsupported target types" );
rc = FAIL; break;
}
// Get the global error log.
errlHndl_t errl = NULL;
errl = ServiceGeneratorClass::ThisServiceGenerator().getErrl();
if ( NULL == errl )
{
PRDF_ERR( PRDF_FUNC "Failed to get the global error log" );
rc = FAIL; break;
}
// Callout this bus interface.
PRDF_ADD_BUS_CALLOUT( errl, i_rxTrgt, i_txTrgt, hwasType, i_priority );
} while(0);
if ( SUCCESS != rc )
{
PRDF_ERR( PRDF_FUNC "i_rxTrgt:0x%08x i_txTrgt:0x%08x i_priority:%d",
getHuid(i_rxTrgt), getHuid(i_txTrgt), i_priority );
}
return rc;
#undef PRDF_FUNC
}
/**************************************************************************
* MIX_GetLineInfo [internal]
*/
static DWORD MIX_GetLineInfo(WORD wDevID, LPMIXERLINEW lpMl, DWORD_PTR fdwInfo)
{
int i;
DWORD ret = MMSYSERR_ERROR;
MixerLine *line = NULL;
TRACE("%04X, %p, %08lx\n", wDevID, lpMl, fdwInfo);
if (lpMl == NULL) {
WARN("invalid parameter: lpMl = NULL\n");
return MMSYSERR_INVALPARAM;
}
if (lpMl->cbStruct != sizeof(*lpMl)) {
WARN("invalid parameter: lpMl->cbStruct\n");
return MMSYSERR_INVALPARAM;
}
if (wDevID >= numMixers) {
WARN("bad device ID: %04X\n", wDevID);
return MMSYSERR_BADDEVICEID;
}
/* FIXME: set all the variables correctly... the lines below
* are very wrong...
*/
lpMl->dwUser = 0;
switch (fdwInfo & MIXER_GETLINEINFOF_QUERYMASK)
{
case MIXER_GETLINEINFOF_DESTINATION:
TRACE("MIXER_GETLINEINFOF_DESTINATION %d\n", lpMl->dwDestination);
if ( (lpMl->dwDestination >= 0) && (lpMl->dwDestination < mixer.caps.cDestinations) )
{
lpMl->dwLineID = lpMl->dwDestination;
line = &mixer.lines[lpMl->dwDestination];
}
else ret = MIXERR_INVALLINE;
break;
case MIXER_GETLINEINFOF_COMPONENTTYPE:
TRACE("MIXER_GETLINEINFOF_COMPONENTTYPE %s\n", getComponentType(lpMl->dwComponentType));
for (i = 0; i < mixer.caps.cDestinations; i++)
{
if (mixer.lines[i].componentType == lpMl->dwComponentType)
{
lpMl->dwDestination = lpMl->dwLineID = i;
line = &mixer.lines[i];
break;
}
}
if (line == NULL)
{
WARN("can't find component type %s\n", getComponentType(lpMl->dwComponentType));
ret = MIXERR_INVALVALUE;
}
break;
case MIXER_GETLINEINFOF_SOURCE:
FIXME("MIXER_GETLINEINFOF_SOURCE %d dst=%d\n", lpMl->dwSource, lpMl->dwDestination);
break;
case MIXER_GETLINEINFOF_LINEID:
TRACE("MIXER_GETLINEINFOF_LINEID %d\n", lpMl->dwLineID);
if ( (lpMl->dwLineID >= 0) && (lpMl->dwLineID < mixer.caps.cDestinations) )
{
lpMl->dwDestination = lpMl->dwLineID;
line = &mixer.lines[lpMl->dwLineID];
}
else ret = MIXERR_INVALLINE;
break;
case MIXER_GETLINEINFOF_TARGETTYPE:
FIXME("MIXER_GETLINEINFOF_TARGETTYPE (%s)\n", getTargetType(lpMl->Target.dwType));
switch (lpMl->Target.dwType) {
case MIXERLINE_TARGETTYPE_UNDEFINED:
case MIXERLINE_TARGETTYPE_WAVEOUT:
case MIXERLINE_TARGETTYPE_WAVEIN:
case MIXERLINE_TARGETTYPE_MIDIOUT:
case MIXERLINE_TARGETTYPE_MIDIIN:
case MIXERLINE_TARGETTYPE_AUX:
default:
FIXME("Unhandled target type (%s)\n",
getTargetType(lpMl->Target.dwType));
return MMSYSERR_INVALPARAM;
}
break;
default:
WARN("Unknown flag (%08lx)\n", fdwInfo & MIXER_GETLINEINFOF_QUERYMASK);
break;
}
if (line)
{
lpMl->dwComponentType = line->componentType;
lpMl->cChannels = line->numChannels;
lpMl->cControls = ControlsPerLine;
/* FIXME check there with CoreAudio */
lpMl->cConnections = 1;
lpMl->fdwLine = MIXERLINE_LINEF_ACTIVE;
MultiByteToWideChar(CP_ACP, 0, line->name, -1, lpMl->szShortName, sizeof(lpMl->szShortName) / sizeof(WCHAR));
MultiByteToWideChar(CP_ACP, 0, line->name, -1, lpMl->szName, sizeof(lpMl->szName) / sizeof(WCHAR));
if ( IsInput(line->direction) )
lpMl->Target.dwType = MIXERLINE_TARGETTYPE_WAVEIN;
else
lpMl->Target.dwType = MIXERLINE_TARGETTYPE_WAVEOUT;
lpMl->Target.dwDeviceID = line->deviceID;
lpMl->Target.wMid = mixer.caps.wMid;
lpMl->Target.wPid = mixer.caps.wPid;
lpMl->Target.vDriverVersion = mixer.caps.vDriverVersion;
MultiByteToWideChar(CP_ACP, 0, WINE_MIXER_NAME, -1, lpMl->Target.szPname, sizeof(lpMl->Target.szPname) / sizeof(WCHAR));
ret = MMSYSERR_NOERROR;
}
return ret;
}
QString TTool::updateEnabled() {
// Disable every tool during playback
if (m_application->getCurrentFrame()->isPlaying())
return (enable(false), QString());
// Release Generic tools at once
int toolType = getToolType();
int targetType = getTargetType();
if (toolType == TTool::GenericTool) return (enable(true), QString());
// Retrieve vars and view modes
TXsheet *xsh = m_application->getCurrentXsheet()->getXsheet();
int rowIndex = m_application->getCurrentFrame()->getFrame();
int columnIndex = m_application->getCurrentColumn()->getColumnIndex();
TXshColumn *column = (columnIndex >= 0) ? xsh->getColumn(columnIndex) : 0;
TXshLevel *xl = m_application->getCurrentLevel()->getLevel();
TXshSimpleLevel *sl = xl ? xl->getSimpleLevel() : 0;
int levelType = sl ? sl->getType() : NO_XSHLEVEL;
TStageObject *obj =
xsh->getStageObject(TStageObjectId::ColumnId(columnIndex));
bool spline = m_application->getCurrentObject()->isSpline();
bool filmstrip = m_application->getCurrentFrame()->isEditingLevel();
/*-- MultiLayerStylePickerONのときは、現状に関わらず使用可能 --*/
if (m_name == T_StylePicker &&
Preferences::instance()->isMultiLayerStylePickerEnabled())
return (enable(true), QString());
// Check against unplaced columns (not in filmstrip mode)
if (column && !filmstrip) {
if (column->isLocked())
return (enable(false), QObject::tr("The current column is locked."));
else if (!column->isCamstandVisible())
return (enable(false), QObject::tr("The current column is hidden."));
else if (column->getSoundColumn())
return (enable(false),
QObject::tr("It is not possible to edit the audio column."));
else if (column->getSoundTextColumn())
return (
enable(false),
QObject::tr(
"Note columns can only be edited in the xsheet or timeline."));
if (toolType == TTool::ColumnTool) {
// Check column target
if (column->getLevelColumn() && !(targetType & LevelColumns))
return (
enable(false),
QObject::tr("The current tool cannot be used on a Level column."));
if (column->getMeshColumn() && !(targetType & MeshColumns))
return (
enable(false),
QObject::tr("The current tool cannot be used on a Mesh column."));
}
}
// Check column tools
if (toolType == TTool::ColumnTool) {
if (filmstrip)
return (
enable(false),
QObject::tr("The current tool cannot be used in Level Strip mode."));
if ((!column || column->isEmpty()) && !(targetType & TTool::EmptyTarget))
return (enable(false), QString());
}
// Check LevelRead & LevelWrite tools
if (toolType & TTool::LevelTool) {
// Check against splines
if (spline) {
return (targetType & Splines)
? (enable(true), QString())
: (enable(false), QObject::tr("The current tool cannot be "
"used to edit a motion path."));
}
// Check against empty levels
if (!xl)
return (targetType & EmptyTarget) ? (enable(true), QString())
: (enable(false), QString());
// Check against simple-level-edness
if (!sl)
return (enable(false),
QObject::tr("The current level is not editable.")); // Does it
// happen at
// all btw?
// Check against level types
{
if ((levelType == PLI_XSHLEVEL) && !(targetType & VectorImage))
return (
enable(false),
QObject::tr("The current tool cannot be used on a Vector Level."));
if ((levelType == TZP_XSHLEVEL) && !(targetType & ToonzImage))
return (
enable(false),
QObject::tr("The current tool cannot be used on a Toonz Level."));
if ((levelType == OVL_XSHLEVEL) && !(targetType & RasterImage))
return (
enable(false),
QObject::tr("The current tool cannot be used on a Raster Level."));
if ((levelType == MESH_XSHLEVEL) && !(targetType & MeshImage))
return (
enable(false),
QObject::tr("The current tool cannot be used on a Mesh Level."));
}
// Check against impossibly traceable movements on the column
if ((levelType & LEVELCOLUMN_XSHLEVEL) && !filmstrip) {
// Test for Mesh-deformed levels
const TStageObjectId &parentId = obj->getParent();
if (parentId.isColumn() && obj->getParentHandle()[0] != 'H') {
TXshSimpleLevel *parentSl =
xsh->getCell(rowIndex, parentId.getIndex()).getSimpleLevel();
if (parentSl && parentSl->getType() == MESH_XSHLEVEL)
return (
enable(false),
QObject::tr(
"The current tool cannot be used on a mesh-deformed level"));
}
}
// Check TTool::ImageType tools
if (toolType == TTool::LevelWriteTool) {
// Check level against read-only status
if (sl->isReadOnly()) {
const std::set<TFrameId> &editableFrames = sl->getEditableRange();
TFrameId currentFid = getCurrentFid();
if (editableFrames.find(currentFid) == editableFrames.end())
return (
enable(false),
QObject::tr(
"The current frame is locked: any editing is forbidden."));
}
// Check level type write support
if (sl->getPath().getType() ==
"psd" || // We don't have the API to write psd files
sl->is16BitChannelLevel() || // Inherited by previous implementation.
// Could be fixed?
sl->getProperties()->getBpp() ==
1) // Black & White images. Again, could be fixed?
return (enable(false),
QObject::tr("The current level is not editable."));
}
}
return (enable(true), QString());
}
// General function to get some basic game values
BOOL scrGenExternGet(UDWORD index)
{
INTERP_TYPE type;
SDWORD val;
switch (index)
{
case EXTID_TRACKTRANSPORTER:
type = VAL_BOOL;
val = bTrackTransporter;
break;
case EXTID_ISPSX:
type = VAL_BOOL;
val = bIsPSX;
break;
case EXTID_MAPWIDTH:
type = VAL_INT;
val = mapWidth;
break;
case EXTID_MAPHEIGHT:
type = VAL_INT;
val = mapHeight;
break;
case EXTID_GAMEINIT:
type = VAL_BOOL;
val = gameInitialised;
break;
case EXTID_SELECTEDPLAYER:
type = VAL_INT;
val = selectedPlayer;
break;
case EXTID_GAMELEVEL:
type = VAL_INT;
val = scrGameLevel;
break;
case EXTID_GAMETIME:
type = VAL_INT;
val = (SDWORD)(gameTime/SCR_TICKRATE);
break;
case EXTID_TUTORIAL:
type = VAL_BOOL;
val = bInTutorial;
break;
case EXTID_CURSOR:
type = VAL_INT;
val = iV_GetMouseFrame(); // from rendfunc.c
// DBPRINTF(("CURSOR = %d val\n",val));
break;
case EXTID_INTMODE:
type=VAL_INT;
val=intMode;
break;
case EXTID_TARGETTYPE:
type=VAL_INT;
val=getTargetType();
break;
case EXTID_EXTRAVICTORYFLAG:
type=VAL_BOOL;
val=bExtraVictoryFlag;
break;
case EXTID_EXTRAFAILFLAG:
type=VAL_BOOL;
val=bExtraFailFlag;
break;
case EXTID_MULTIGAMETYPE: // multiplayer variable..
type = VAL_INT;
val = game.type;
break;
case EXTID_MULTIGAMEHUMANMAX: // multiplayer variable..
type = VAL_INT;
val = game.maxPlayers;
break;
case EXTID_MULTIGAMEBASETYPE:
type = VAL_INT;
val = game.base;
break;
default:
ASSERT((FALSE, "scrGenExternGet: unknown variable index"));
return FALSE;
break;
}
if (!stackPushResult(type, val))
{
return FALSE;
}
return TRUE;
}
