TSharedPtr<FClassDataNode> FClassBrowseHelper::CreateClassDataNode(const class FAssetData& AssetData)
{
TSharedPtr<FClassDataNode> Node;
const FString* GeneratedClassname = AssetData.TagsAndValues.Find("GeneratedClass");
const FString* ParentClassname = AssetData.TagsAndValues.Find("ParentClass");
if (GeneratedClassname && ParentClassname)
{
FString AssetClassName = *GeneratedClassname;
UObject* Outer1(NULL);
ResolveName(Outer1, AssetClassName, false, false);
FString AssetParentClassName = *ParentClassname;
UObject* Outer2(NULL);
ResolveName(Outer2, AssetParentClassName, false, false);
Node = MakeShareable(new FClassDataNode);
Node->ParentClassName = AssetParentClassName;
FClassData NewData(AssetData.AssetName.ToString(), AssetData.PackageName.ToString(), AssetClassName);
Node->Data = NewData;
}
return Node;
}
TSharedPtr<FGraphNodeClassNode> FGraphNodeClassHelper::CreateClassDataNode(const class FAssetData& AssetData)
{
TSharedPtr<FGraphNodeClassNode> Node;
const FString* GeneratedClassname = AssetData.TagsAndValues.Find("GeneratedClass");
const FString* ParentClassname = AssetData.TagsAndValues.Find("ParentClass");
if (GeneratedClassname && ParentClassname)
{
FString AssetClassName = *GeneratedClassname;
UObject* Outer1(NULL);
ResolveName(Outer1, AssetClassName, false, false);
FString AssetParentClassName = *ParentClassname;
UObject* Outer2(NULL);
ResolveName(Outer2, AssetParentClassName, false, false);
Node = MakeShareable(new FGraphNodeClassNode);
Node->ParentClassName = AssetParentClassName;
UObject* AssetOb = AssetData.IsAssetLoaded() ? AssetData.GetAsset() : NULL;
UBlueprint* AssetBP = Cast<UBlueprint>(AssetOb);
UClass* AssetClass = AssetBP ? *AssetBP->GeneratedClass : AssetOb ? AssetOb->GetClass() : NULL;
FGraphNodeClassData NewData(AssetData.AssetName.ToString(), AssetData.PackageName.ToString(), AssetClassName, AssetClass);
Node->Data = NewData;
}
return Node;
}
void UpdateThumbnailClass(const FName& InAssetName, UClass* InAssetClass)
{
ThumbnailClass = InAssetClass;
bIsClassType = false;
if( InAssetClass == UClass::StaticClass() )
{
ThumbnailClass = FindObject<UClass>(ANY_PACKAGE, *InAssetName.ToString());
bIsClassType = true;
}
else if( InAssetClass == UBlueprint::StaticClass() )
{
static const FName NativeParentClassTag = "NativeParentClass";
static const FName ParentClassTag = "ParentClass";
// We need to use the asset data to get the parent class as the blueprint may not be loaded
const FAssetData& AssetData = AssetThumbnail->GetAssetData();
const FString* ParentClassNamePtr = AssetData.TagsAndValues.Find(NativeParentClassTag);
if(!ParentClassNamePtr)
{
ParentClassNamePtr = AssetData.TagsAndValues.Find(ParentClassTag);
}
if(ParentClassNamePtr && !ParentClassNamePtr->IsEmpty())
{
UObject* Outer = nullptr;
FString ParentClassName = *ParentClassNamePtr;
ResolveName(Outer, ParentClassName, false, false);
ThumbnailClass = FindObject<UClass>(ANY_PACKAGE, *ParentClassName);
}
bIsClassType = true;
}
}
const UClass* FClassIconFinder::GetIconClassForAssetData(const FAssetData& InAssetData, bool* bOutIsClassType)
{
if ( bOutIsClassType )
{
*bOutIsClassType = false;
}
UClass* AssetClass = FindObject<UClass>(ANY_PACKAGE, *InAssetData.AssetClass.ToString());
if ( !AssetClass )
{
return nullptr;
}
if ( AssetClass == UClass::StaticClass() )
{
if ( bOutIsClassType )
{
*bOutIsClassType = true;
}
return FindObject<UClass>(ANY_PACKAGE, *InAssetData.AssetName.ToString());
}
if ( AssetClass == UBlueprint::StaticClass() )
{
static const FName NativeParentClassTag = "NativeParentClass";
static const FName ParentClassTag = "ParentClass";
if ( bOutIsClassType )
{
*bOutIsClassType = true;
}
// We need to use the asset data to get the parent class as the blueprint may not be loaded
const FString* ParentClassNamePtr = InAssetData.TagsAndValues.Find(NativeParentClassTag);
if ( !ParentClassNamePtr )
{
ParentClassNamePtr = InAssetData.TagsAndValues.Find(ParentClassTag);
}
if ( ParentClassNamePtr && !ParentClassNamePtr->IsEmpty() )
{
UObject* Outer = nullptr;
FString ParentClassName = *ParentClassNamePtr;
ResolveName(Outer, ParentClassName, false, false);
return FindObject<UClass>(ANY_PACKAGE, *ParentClassName);
}
}
// Default to using the class for the asset type
return AssetClass;
}
MainObject::MainObject(QObject *parent,const char *name)
{
input_fd=-1;
dest_hostname=RMLSEND_DEFAULT_ADDR;
dest_port=RMLSEND_DEFAULT_PORT;
rml_ptr=0;
ReadSwitches();
ResolveName();
InitStream();
ProcessCommands();
CloseStream();
exit(0);
}
void FClassBrowseHelper::OnAssetRemoved(const class FAssetData& AssetData)
{
const FString* GeneratedClassname = AssetData.TagsAndValues.Find("GeneratedClass");
if (GeneratedClassname)
{
FString AssetClassName = *GeneratedClassname;
UObject* Outer1(NULL);
ResolveName(Outer1, AssetClassName, false, false);
TSharedPtr<FClassDataNode> Node = FindBaseClassNode(RootNode, AssetClassName);
if (Node.IsValid() && Node->ParentNode.IsValid())
{
Node->ParentNode->SubNodes.RemoveSingleSwap(Node);
}
}
}
void FGraphNodeClassHelper::OnAssetRemoved(const class FAssetData& AssetData)
{
const FString* GeneratedClassname = AssetData.TagsAndValues.Find("GeneratedClass");
if (GeneratedClassname)
{
FString AssetClassName = *GeneratedClassname;
UObject* Outer1(NULL);
ResolveName(Outer1, AssetClassName, false, false);
TSharedPtr<FGraphNodeClassNode> Node = FindBaseClassNode(RootNode, AssetClassName);
if (Node.IsValid() && Node->ParentNode.IsValid())
{
Node->ParentNode->SubNodes.RemoveSingleSwap(Node);
}
}
FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>(TEXT("AssetRegistry"));
if (!AssetRegistryModule.Get().IsLoadingAssets())
{
UpdateAvailableBlueprintClasses();
}
}
NS_IMETHODIMP nsJSCID::ToString(char **_retval)
{ResolveName(); return mDetails.ToString(_retval);}
NS_IMETHODIMP nsJSCID::GetName(char * *aName)
{ResolveName(); return mDetails.GetName(aName);}
int
main(int argc, char *argv[])
{
Boolean exists;
char *filename;
FileAccess file_access;
Widget source;
XtAppContext appcon;
Boolean show_dir;
xedit_flist_item *first_item;
unsigned int i, lineno;
lineno = 0;
show_dir = FALSE;
first_item = NULL;
topwindow = XtAppInitialize(&appcon, "Xedit", NULL, 0, &argc, argv,
NULL,
NULL, 0);
XtAppAddActions(appcon, actions, XtNumber(actions));
XtOverrideTranslations(topwindow,
XtParseTranslationTable("<Message>WM_PROTOCOLS: quit()"));
XtGetApplicationResources(topwindow, (XtPointer) &app_resources, resources,
XtNumber(resources), NULL, 0);
CurDpy = XtDisplay(topwindow);
XawSimpleMenuAddGlobalActions(appcon);
XtRegisterGrabAction(PopupMenu, True,
ButtonPressMask | ButtonReleaseMask,
GrabModeAsync, GrabModeAsync);
makeButtonsAndBoxes(topwindow);
StartHints();
StartFormatPosition();
(void)StartHooks(appcon);
if (position_format_mask == 0) {
for (i = 0; i < 3; i++)
XtRemoveCallback(texts[i], XtNpositionCallback,
PositionChanged, NULL);
}
XtRealizeWidget(topwindow);
#ifndef __UNIXOS2__
XeditLispInitialize();
#endif
options_popup = XtCreatePopupShell("optionsMenu", simpleMenuWidgetClass,
topwindow, NULL, 0);
XtRealizeWidget(options_popup);
XtAddCallback(XtCreateManagedWidget("ispell", smeBSBObjectClass,
options_popup, NULL, 0),
XtNcallback, IspellCallback, NULL);
CreateEditPopup();
wm_delete_window = XInternAtom(XtDisplay(topwindow), "WM_DELETE_WINDOW",
False);
(void)XSetWMProtocols(XtDisplay(topwindow), XtWindow(topwindow),
&wm_delete_window, 1);
/* This first call is just to save the default font and colors */
UpdateTextProperties(0);
if (argc > 1) {
xedit_flist_item *item;
Arg args[2];
unsigned int num_args;
for (i = 1; i < argc; i++) {
struct stat st;
if (argv[i][0] == '+') {
char *endptr;
lineno = strtol(argv[i], &endptr, 10);
/* Don't warn about incorrect input? */
if (*endptr)
lineno = 0;
continue;
}
filename = ResolveName(argv[i]);
if (filename == NULL || FindTextSource(NULL, filename) != NULL)
continue;
num_args = 0;
if (stat(filename, &st) == 0 && !S_ISREG(st.st_mode)) {
if (S_ISDIR(st.st_mode)) {
if (!first_item) {
char path[BUFSIZ + 1];
strncpy(path, filename, sizeof(path) - 2);
path[sizeof(path) - 2] = '\0';
if (*path) {
if (path[strlen(path) - 1] != '/')
strcat(path, "/");
}
else
strcpy(path, "./");
XtSetArg(args[0], XtNlabel, "");
XtSetValues(dirlabel, args, 1);
SwitchDirWindow(True);
DirWindowCB(dirwindow, path, NULL);
show_dir = True;
}
continue;
}
}
switch (file_access = CheckFilePermissions(filename, &exists)) {
case NO_READ:
if (exists)
XeditPrintf("File %s exists, and could not be opened for "
"reading.\n", argv[i]);
else
XeditPrintf("File %s does not exist, and the directory "
"could not be opened for writing.\n", argv[i]);
break;
case READ_OK:
XtSetArg(args[num_args], XtNeditType, XawtextRead); num_args++;
XeditPrintf("File %s opened READ ONLY.\n", argv[i]);
break;
case WRITE_OK:
XtSetArg(args[num_args], XtNeditType, XawtextEdit); num_args++;
XeditPrintf("File %s opened read - write.\n", argv[i]);
break;
}
if (file_access != NO_READ) {
int flags;
if (exists) {
flags = EXISTS_BIT;
XtSetArg(args[num_args], XtNstring, filename);num_args++;
}
else {
flags = 0;
XtSetArg(args[num_args], XtNstring, NULL); num_args++;
}
source = XtVaCreateWidget("textSource", international ?
multiSrcObjectClass
: asciiSrcObjectClass, topwindow,
XtNtype, XawAsciiFile,
XtNeditType, XawtextEdit,
NULL, NULL);
XtSetValues(source, args, num_args);
item = AddTextSource(source, argv[i], filename,
flags, file_access);
XtAddCallback(item->source, XtNcallback, SourceChanged,
(XtPointer)item);
if (exists && file_access == WRITE_OK) {
item->mode = st.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO);
item->mtime = st.st_mtime;
}
if (!first_item && !show_dir)
first_item = item;
ResetSourceChanged(item);
}
}
}
if (!flist.pixmap && strlen(app_resources.changed_pixmap_name)) {
XrmValue from, to;
from.size = strlen(app_resources.changed_pixmap_name);
from.addr = app_resources.changed_pixmap_name;
to.size = sizeof(Pixmap);
to.addr = (XtPointer)&(flist.pixmap);
XtConvertAndStore(flist.popup, XtRString, &from, XtRBitmap, &to);
}
if (first_item == NULL) {
XtSetKeyboardFocus(topwindow, filenamewindow);
XtVaSetValues(textwindow, XtNwrap, XawtextWrapLine, NULL);
}
else {
SwitchTextSource(first_item);
XtSetKeyboardFocus(topwindow, textwindow);
if (lineno) {
XawTextPosition position;
source = XawTextGetSource(textwindow);
position = RSCAN(XawTextGetInsertionPoint(textwindow),
lineno, False);
position = LSCAN(position, 1, False);
XawTextSetInsertionPoint(textwindow, position);
}
}
XtAppMainLoop(appcon);
return EXIT_SUCCESS;
}
int DllLoader::ResolveImports(void)
{
int bResult = 1;
if ( NumOfDirectories >= 2 && Directory[IMPORT_TABLE].Size > 0 )
{
ImportDirTable = (ImportDirTable_t*)RVA2Data(Directory[IMPORT_TABLE].RVA);
#ifdef DUMPING_DATA
PrintImportTable(ImportDirTable);
#endif
ImportDirTable_t *Imp = ImportDirTable;
while ( Imp->ImportLookupTable_RVA != 0 ||
Imp->TimeStamp != 0 ||
Imp->ForwarderChain != 0 ||
Imp->Name_RVA != 0 ||
Imp->ImportAddressTable_RVA != 0)
{
const char *Name = (const char*)RVA2Data(Imp->Name_RVA);
const char* FileName=ResolveReferencedDll(Name);
// If possible use the dll name WITH path to resolve exports. We could have loaded
// a dll with the same name as another dll but from a different directory
if (FileName) Name=FileName;
unsigned long *Table = (unsigned long*)RVA2Data(Imp->ImportLookupTable_RVA);
unsigned long *Addr = (unsigned long*)RVA2Data(Imp->ImportAddressTable_RVA);
while (*Table)
{
if (*Table & 0x80000000)
{
void *Fixup;
if ( !ResolveOrdinal(Name, *Table&0x7ffffff, &Fixup) )
{
bResult = 0;
char szBuf[128];
CLog::Log(LOGDEBUG,"Unable to resolve ordinal %s %lu\n", Name, *Table&0x7ffffff);
sprintf(szBuf, "%lu", *Table&0x7ffffff);
*Addr = create_dummy_function(Name, szBuf);
tracker_dll_data_track(this, *Addr);
}
else
{
*Addr = (unsigned long)Fixup; //woohoo!!
}
}
else
{
// We don't handle Hint/Name tables yet!!!
char *ImpName = (char*)RVA2Data(*Table + 2);
void *Fixup;
if ( !ResolveName(Name, ImpName, &Fixup) )
{
*Addr=get_win_function_address(Name, ImpName);
if(!*Addr)
{
CLog::Log(LOGDEBUG,"Unable to resolve %s %s\n", Name, ImpName);
*Addr = create_dummy_function(Name, ImpName);
tracker_dll_data_track(this, *Addr);
bResult = 0;
}
}
else
{
*Addr = (unsigned long)Fixup;
}
}
Table++;
Addr++;
}
Imp++;
}
}
return bResult;
}
