Note::Note():
LayerElement("note-"), StemmedDrawingInterface(), DurationInterface(), PitchInterface(),
AttColoration(),
AttGraced(),
AttNoteLogMensural(),
AttStemmed(),
AttStemmedCmn(),
AttTiepresent()
{
RegisterAttClass(ATT_COLORATION);
RegisterAttClass(ATT_GRACED);
RegisterAttClass(ATT_NOTELOGMENSURAL);
RegisterAttClass(ATT_STEMMED);
RegisterAttClass(ATT_STEMMEDCMN);
RegisterAttClass(ATT_TIEPRESENT);
RegisterInterface( DurationInterface::GetAttClasses(), DurationInterface::IsInterface() );
RegisterInterface( PitchInterface::GetAttClasses(), PitchInterface::IsInterface() );
m_drawingTieAttr = NULL;
m_drawingAccid = NULL;
m_isDrawingAccidAttr = false;
Reset();
}
Rest::Rest():
LayerElement("rest-"), DurationInterface(), PositionInterface()
{
RegisterInterface( DurationInterface::GetAttClasses(), DurationInterface::IsInterface() );
RegisterInterface( PositionInterface::GetAttClasses(), PositionInterface::IsInterface() );
Reset();
}
Tempo::Tempo()
: ControlElement("tempo-"), TextDirInterface(), TimePointInterface(), AttLang(), AttMiditempo(), AttMmtempo()
{
RegisterInterface(TextDirInterface::GetAttClasses(), TextDirInterface::IsInterface());
RegisterInterface(TimePointInterface::GetAttClasses(), TimePointInterface::IsInterface());
RegisterAttClass(ATT_LANG);
RegisterAttClass(ATT_MIDITEMPO);
RegisterAttClass(ATT_MMTEMPO);
Reset();
}
Tempo::Tempo():
FloatingElement("tempo-"), TextDirInterface()
{
RegisterInterface( TextDirInterface::GetAttClasses(), TextDirInterface::IsInterface() );
Reset();
}
Tie::Tie() : ControlElement("tie-"), TimeSpanningInterface(), AttCurvature()
{
RegisterInterface(TimeSpanningInterface::GetAttClasses(), TimeSpanningInterface::IsInterface());
RegisterAttClass(ATT_CURVATURE);
Reset();
}
Slur::Slur() : ControlElement("slur-"), TimeSpanningInterface(), AttColor(), AttCurvature()
{
RegisterInterface(TimeSpanningInterface::GetAttClasses(), TimeSpanningInterface::IsInterface());
RegisterAttClass(ATT_COLOR);
RegisterAttClass(ATT_CURVATURE);
Reset();
}
Breath::Breath() : ControlElement("breath-"), TimePointInterface(), AttColor(), AttPlacement()
{
RegisterInterface(TimePointInterface::GetAttClasses(), TimePointInterface::IsInterface());
RegisterAttClass(ATT_COLOR);
RegisterAttClass(ATT_PLACEMENT);
Reset();
}
Syl::Syl() : LayerElement("syl-"), TextListInterface(), TimeSpanningInterface(), AttTypography(), AttSylLog()
{
RegisterInterface(TimeSpanningInterface::GetAttClasses(), TimeSpanningInterface::IsInterface());
RegisterAttClass(ATT_TYPOGRAPHY);
RegisterAttClass(ATT_SYLLOG);
Reset();
}
Accid::Accid() : LayerElement("accid-"), PositionInterface(), AttAccidental(), AttAccidLog()
{
RegisterInterface(PositionInterface::GetAttClasses(), PositionInterface::IsInterface());
RegisterAttClass(ATT_ACCIDENTAL);
RegisterAttClass(ATT_ACCIDLOG);
Reset();
}
Hairpin::Hairpin() : ControlElement("hairpin-"), TimeSpanningInterface(), AttColor(), AttHairpinLog(), AttPlacement()
{
RegisterInterface(TimeSpanningInterface::GetAttClasses(), TimeSpanningInterface::IsInterface());
RegisterAttClass(ATT_COLOR);
RegisterAttClass(ATT_HAIRPINLOG);
RegisterAttClass(ATT_PLACEMENT);
Reset();
}
PRIORITY_PRELOAD( ImageRegisterInterface, IMAGE_PRELOAD_PRIORITY )
{
RegisterInterface( WIDE("vulkan.image"), (void*(CPROC*)(void))GetImageInterface, (void(CPROC*)(void*))DropImageInterface );
RegisterInterface( WIDE("vulkan.image.3d"), GetImage3dInterface, DropImage3dInterface );
l.scale = (RCOORD)SACK_GetProfileInt( GetProgramName(), WIDE("SACK/Image Library/Scale"), 10 );
if( l.scale == 0.0 )
{
l.scale = (RCOORD)SACK_GetProfileInt( GetProgramName(), WIDE("SACK/Image Library/Inverse Scale"), 2 );
if( l.scale == 0.0 )
l.scale = 1;
}
else
l.scale = 1.0f / l.scale;
// this initializes some of the interface methods
//SetBlotMethod( BLOT_C );
RealImageInterface._IsImageTargetFinal = IsImageTargetFinal;
}
Mordent::Mordent()
: ControlElement("mordent-"), TimePointInterface(), AttColor(), AttOrnamentAccid(), AttPlacement(), AttMordentLog()
{
RegisterInterface(TimePointInterface::GetAttClasses(), TimePointInterface::IsInterface());
RegisterAttClass(ATT_COLOR);
RegisterAttClass(ATT_ORNAMENTACCID);
RegisterAttClass(ATT_PLACEMENT);
RegisterAttClass(ATT_MORDENTLOG);
Reset();
}
nsresult
nsScriptNameSpaceManager::FillHashWithDOMInterfaces()
{
nsCOMPtr<nsIInterfaceInfoManager>
iim(do_GetService(NS_INTERFACEINFOMANAGER_SERVICE_CONTRACTID));
NS_ENSURE_TRUE(iim, NS_ERROR_UNEXPECTED);
// First look for all interfaces whose name starts with nsIDOM
nsCOMPtr<nsIEnumerator> domInterfaces;
nsresult rv =
iim->EnumerateInterfacesWhoseNamesStartWith(NS_DOM_INTERFACE_PREFIX,
getter_AddRefs(domInterfaces));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsISupports> entry;
rv = domInterfaces->First();
if (NS_FAILED(rv)) {
// Empty interface list?
NS_WARNING("What, no nsIDOM interfaces installed?");
return NS_OK;
}
bool found_old;
nsCOMPtr<nsIInterfaceInfo> if_info;
const char *if_name = nsnull;
const nsIID *iid;
for ( ; domInterfaces->IsDone() == NS_ENUMERATOR_FALSE; domInterfaces->Next()) {
rv = domInterfaces->CurrentItem(getter_AddRefs(entry));
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIInterfaceInfo> if_info(do_QueryInterface(entry));
if_info->GetNameShared(&if_name);
if_info->GetIIDShared(&iid);
rv = RegisterInterface(if_name + sizeof(NS_DOM_INTERFACE_PREFIX) - 1,
iid, &found_old);
#ifdef DEBUG
NS_ASSERTION(!found_old,
"Whaaa, interface name already in hash!");
#endif
}
// Next, look for externally registered DOM interfaces
rv = RegisterExternalInterfaces(false);
return rv;
}
PRIORITY_PRELOAD( ImageRegisterInterface, IMAGE_PRELOAD_PRIORITY )
{
RegisterInterface( WIDE("d3d.image"), _ImageGetImageInterface, _ImageDropImageInterface );
#ifndef __NO_OPTIONS__
l.scale = (RCOORD)SACK_GetProfileInt( GetProgramName(), WIDE("SACK/Image Library/Scale"), 10 );
if( l.scale == 0.0 )
{
l.scale = (RCOORD)SACK_GetProfileInt( GetProgramName(), WIDE("SACK/Image Library/Inverse Scale"), 2 );
if( l.scale == 0.0 )
l.scale = 1;
}
else
l.scale = 1.0f / l.scale;
#else
l.scale = 1.0f;
#endif
// this initializes some of the interface methods
//SetBlotMethod( BLOT_C );
RealImageInterface._IsImageTargetFinal = IsImageTargetFinal;
}
Hairpin::Hairpin() : FloatingElement("hairpin-"), TimeSpanningInterface(), AttHairpinLog(), AttPlacement()
{
RegisterInterface(TimeSpanningInterface::GetAttClasses(), TimeSpanningInterface::IsInterface());
Reset();
}
void asCBuilder::ParseScripts()
{
asCArray<asCParser*> parsers;
// Parse all the files as if they were one
asUINT n = 0;
for( n = 0; n < scripts.GetLength(); n++ )
{
asCParser *parser = new asCParser(this);
parsers.PushLast(parser);
// Parse the script file
parser->ParseScript(scripts[n]);
}
if( numErrors == 0 )
{
// Find all type declarations
for( n = 0; n < scripts.GetLength(); n++ )
{
asCScriptNode *node = parsers[n]->GetScriptNode();
// Find structure definitions first
node = node->firstChild;
while( node )
{
asCScriptNode *next = node->next;
if( node->nodeType == snClass )
{
node->DisconnectParent();
RegisterClass(node, scripts[n]);
}
else if( node->nodeType == snInterface )
{
node->DisconnectParent();
RegisterInterface(node, scripts[n]);
}
node = next;
}
}
// Register script methods found in the structures
for( n = 0; n < classDeclarations.GetLength(); n++ )
{
sClassDeclaration *decl = classDeclarations[n];
asCScriptNode *node = decl->node->firstChild->next;
// Skip list of classes and interfaces
while( node && node->nodeType == snIdentifier )
node = node->next;
while( node )
{
asCScriptNode *next = node->next;
if( node->nodeType == snFunction )
{
node->DisconnectParent();
RegisterScriptFunction(module->GetNextFunctionId(), node, decl->script, decl->objType);
}
node = next;
}
// Make sure the default constructor exists for classes
if( decl->objType->beh.construct == engine->scriptTypeBehaviours.beh.construct )
{
AddDefaultConstructor(decl->objType, decl->script);
}
}
// Register script methods found in the interfaces
for( n = 0; n < interfaceDeclarations.GetLength(); n++ )
{
sClassDeclaration *decl = interfaceDeclarations[n];
asCScriptNode *node = decl->node->firstChild->next;
while( node )
{
asCScriptNode *next = node->next;
if( node->nodeType == snFunction )
{
node->DisconnectParent();
RegisterScriptFunction(module->GetNextFunctionId(), node, decl->script, decl->objType, true);
}
node = next;
}
}
// Find other global nodes
for( n = 0; n < scripts.GetLength(); n++ )
{
// Find other global nodes
asCScriptNode *node = parsers[n]->GetScriptNode();
node = node->firstChild;
while( node )
{
asCScriptNode *next = node->next;
node->DisconnectParent();
if( node->nodeType == snFunction )
{
RegisterScriptFunction(module->GetNextFunctionId(), node, scripts[n]);
}
else if( node->nodeType == snGlobalVar )
{
RegisterGlobalVar(node, scripts[n]);
}
else if( node->nodeType == snImport )
{
RegisterImportedFunction(module->GetNextImportedFunctionId(), node, scripts[n]);
}
else
{
// Unused script node
int r, c;
scripts[n]->ConvertPosToRowCol(node->tokenPos, &r, &c);
WriteWarning(scripts[n]->name.AddressOf(), TXT_UNUSED_SCRIPT_NODE, r, c);
delete node;
}
node = next;
}
}
}
for( n = 0; n < parsers.GetLength(); n++ )
delete parsers[n];
}
F::F() : TextElement("f-"), TimeSpanningInterface()
{
RegisterInterface(TimeSpanningInterface::GetAttClasses(), TimeSpanningInterface::IsInterface());
Reset();
}
nsresult
nsScriptNameSpaceManager::RegisterExternalInterfaces(bool aAsProto)
{
nsresult rv;
nsCOMPtr<nsICategoryManager> cm =
do_GetService(NS_CATEGORYMANAGER_CONTRACTID, &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIInterfaceInfoManager>
iim(do_GetService(NS_INTERFACEINFOMANAGER_SERVICE_CONTRACTID));
NS_ENSURE_TRUE(iim, NS_ERROR_NOT_AVAILABLE);
nsCOMPtr<nsISimpleEnumerator> enumerator;
rv = cm->EnumerateCategory(JAVASCRIPT_DOM_INTERFACE,
getter_AddRefs(enumerator));
NS_ENSURE_SUCCESS(rv, rv);
nsXPIDLCString IID_string;
nsCAutoString category_entry;
const char* if_name;
nsCOMPtr<nsISupports> entry;
nsCOMPtr<nsIInterfaceInfo> if_info;
bool found_old, dom_prefix;
while (NS_SUCCEEDED(enumerator->GetNext(getter_AddRefs(entry)))) {
nsCOMPtr<nsISupportsCString> category(do_QueryInterface(entry));
if (!category) {
NS_WARNING("Category entry not an nsISupportsCString!");
continue;
}
rv = category->GetData(category_entry);
NS_ENSURE_SUCCESS(rv, rv);
rv = cm->GetCategoryEntry(JAVASCRIPT_DOM_INTERFACE, category_entry.get(),
getter_Copies(IID_string));
NS_ENSURE_SUCCESS(rv, rv);
nsIID primary_IID;
if (!primary_IID.Parse(IID_string) ||
primary_IID.Equals(NS_GET_IID(nsISupports))) {
NS_ERROR("Invalid IID registered with the script namespace manager!");
continue;
}
iim->GetInfoForIID(&primary_IID, getter_AddRefs(if_info));
while (if_info) {
const nsIID *iid;
if_info->GetIIDShared(&iid);
NS_ENSURE_TRUE(iid, NS_ERROR_UNEXPECTED);
if (iid->Equals(NS_GET_IID(nsISupports))) {
break;
}
if_info->GetNameShared(&if_name);
dom_prefix = (strncmp(if_name, NS_DOM_INTERFACE_PREFIX,
sizeof(NS_DOM_INTERFACE_PREFIX) - 1) == 0);
const char* name;
if (dom_prefix) {
if (!aAsProto) {
// nsIDOM* interfaces have already been registered.
break;
}
name = if_name + sizeof(NS_DOM_INTERFACE_PREFIX) - 1;
} else {
name = if_name + sizeof(NS_INTERFACE_PREFIX) - 1;
}
if (aAsProto) {
RegisterClassProto(name, iid, &found_old);
} else {
RegisterInterface(name, iid, &found_old);
}
if (found_old) {
break;
}
nsCOMPtr<nsIInterfaceInfo> tmp(if_info);
tmp->GetParent(getter_AddRefs(if_info));
}
}
return NS_OK;
}
