bool BeHappy::CheckAddOn(const char *path,bool alert,BString *pName)
{
image_id addOnImage = load_add_on(path);
void *instFunc;
const char **projName;
const uint16 *BHVersion,*BHVLastCompatible;
bool ok = false;
BPath aoPath(path);
BString alTxt(aoPath.Leaf()); // chaîne utilisée pour générer des alertes d'erreur
if ((addOnImage>=0) &&
(get_image_symbol(addOnImage,"InstantiateProject",B_SYMBOL_TYPE_ANY,&instFunc) == B_OK) &&
(get_image_symbol(addOnImage,"projectName",B_SYMBOL_TYPE_ANY,(void**)&projName) == B_OK) &&
(get_image_symbol(addOnImage,"BHVersion",B_SYMBOL_TYPE_ANY,(void**)&BHVersion) == B_OK) &&
(get_image_symbol(addOnImage,"BHVLastCompatible",B_SYMBOL_TYPE_ANY,(void**)&BHVLastCompatible) == B_OK))
{
if ((*BHVLastCompatible) > bhv_application)
{
if (alert)
{
alTxt << " " << T("isn't compatible with this (old) version of BeHappy. Please download a more recent version of BeHappy.");
BAlert *myAlert = new BAlert("BeHappy",alTxt.String(),"OK",
NULL,NULL,B_WIDTH_AS_USUAL,B_WARNING_ALERT);
myAlert->Go();
}
}
else if ((*BHVersion) < bhv_last_addon)
{
if (alert)
{
alTxt << " " << T("is too old, and isn't compatible with this version of BeHappy. Please find a more recent version of the add-on.");
BAlert *myAlert = new BAlert("BeHappy",alTxt.String(),"OK",
NULL,NULL,B_WIDTH_AS_USUAL,B_WARNING_ALERT);
myAlert->Go();
}
}
else
{
ok = true;
if (pName != NULL)
*pName=*projName;
}
}
else
{
if (alert)
{
alTxt << " " << T("is an invalid BeHappy add-on.");
BAlert *myAlert = new BAlert("BeHappy",alTxt.String(),"OK",
NULL,NULL,B_WIDTH_AS_USUAL,B_WARNING_ALERT);
myAlert->Go();
}
}
if (addOnImage>=0)
unload_add_on(addOnImage);
return ok;
}
void
CayaProtocolAddOn::_Init()
{
const char* (*signature)();
const char* (*friendly_signature)();
fStatus = B_OK;
if (get_image_symbol(fImage, "protocol", B_SYMBOL_TYPE_TEXT,
(void**)&fGetProtocol) != B_OK) {
unload_add_on(fImage);
fStatus = B_ERROR;
return;
}
if (get_image_symbol(fImage, "signature", B_SYMBOL_TYPE_TEXT,
(void**)&signature) != B_OK) {
unload_add_on(fImage);
fStatus = B_ERROR;
return;
}
if (get_image_symbol(fImage, "friendly_signature", B_SYMBOL_TYPE_TEXT,
(void**)&friendly_signature) != B_OK) {
unload_add_on(fImage);
fStatus = B_ERROR;
return;
}
fSignature = signature();
fFriendlySignature = friendly_signature();
}
status_t PrintTransport::Open(BNode* printerFolder)
{
// already opened?
if (fDataIO != NULL) {
return B_ERROR;
}
// retrieve transport add-on name from printer folder attribute
BString transportName;
if (printerFolder->ReadAttrString("transport", &transportName) != B_OK) {
return B_ERROR;
}
// try first in user add-ons directory
BPath path;
find_directory(B_USER_ADDONS_DIRECTORY, &path);
path.Append("Print/transport");
path.Append(transportName.String());
fAddOnID = load_add_on(path.Path());
if (fAddOnID < 0) {
// on failure try in system add-ons directory
find_directory(B_BEOS_ADDONS_DIRECTORY, &path);
path.Append("Print/transport");
path.Append(transportName.String());
fAddOnID = load_add_on(path.Path());
}
if (fAddOnID < 0) {
// failed to load transport add-on
return B_ERROR;
}
// get init & exit proc
BDataIO* (*initProc)(BMessage*);
get_image_symbol(fAddOnID, "init_transport", B_SYMBOL_TYPE_TEXT, (void **) &initProc);
get_image_symbol(fAddOnID, "exit_transport", B_SYMBOL_TYPE_TEXT, (void **) &fExitProc);
if (initProc == NULL || fExitProc == NULL) {
// transport add-on has not the proper interface
return B_ERROR;
}
// now, initialize the transport add-on
node_ref ref;
BDirectory dir;
printerFolder->GetNodeRef(&ref);
dir.SetTo(&ref);
if (path.SetTo(&dir, NULL) != B_OK) {
return B_ERROR;
}
// request BDataIO object from transport add-on
BMessage input('TRIN');
input.AddString("printer_file", path.Path());
fDataIO = (*initProc)(&input);
return B_OK;
}
status_t TEncoderAddonManager::LoadAddons(const char *addondDir)
{
fp_text_convert_t fp_text_convert;
image_id id;
BDirectory dir(addondDir);
BEntry entry;
// load encoders add-on
while (dir.GetNextEntry(&entry) == B_OK) {
BPath addonPath(&entry);
if ((id = load_add_on(addonPath.Path())) < 0) continue;
if (get_image_symbol(id, "fp_text_convert", B_SYMBOL_TYPE_TEXT, (void **)&fp_text_convert)) {
unload_add_on(id);
continue;
}
encoder_addon_t *addon = (encoder_addon_t *)malloc(sizeof(encoder_addon_t));
if (!addon) {
fprintf(stderr, "%s\n", strerror(ENOMEM));
unload_add_on(id);
return ENOMEM;
}
addon->id = id;
addon->fp_text_convert = fp_text_convert;
strncpy(addon->name, addonPath.Leaf(), sizeof(addon->name));
fEncoderAddonList.AddItem(addon);
fprintf(stderr, "load: %s\n", addon->name);
}
return B_OK;
}
bool
BTranslatorRoster::IsTranslator(entry_ref* ref)
{
if (ref == NULL)
return false;
BPath path(ref);
image_id image = load_add_on(path.Path());
if (image < B_OK)
return false;
// Function pointer used to create post R4.5 style translators
BTranslator* (*makeNthTranslator)(int32 n, image_id you, uint32 flags, ...);
status_t status = get_image_symbol(image, "make_nth_translator",
B_SYMBOL_TYPE_TEXT, (void**)&makeNthTranslator);
if (status < B_OK) {
// If this is a translator add-on, it is in the C format
translator_data translatorData;
status = fPrivate->GetTranslatorData(image, translatorData);
}
unload_add_on(image);
return status == B_OK;
}
status_t
PrinterDriverAddOn::TakeJob(const char* spoolFile, BDirectory* spoolFolder)
{
if (!IsLoaded())
return B_ERROR;
BFile file(spoolFile, B_READ_WRITE);
take_job_func_t func;
status_t result = get_image_symbol(fAddOnID, "take_job", B_SYMBOL_TYPE_TEXT,
(void**)&func);
if (result != B_OK)
return result;
// This seems to be required for legacy?
// HP PCL3 add-on crashes without it!
BMessage parameters(B_REFS_RECEIVED);
parameters.AddInt32("file", (int32)&file);
parameters.AddInt32("printer", (int32)spoolFolder);
BMessage* message = (*func)(&file, spoolFolder, ¶meters);
if (message == NULL || message->what != 'okok')
result = B_ERROR;
delete message;
return result;
}
// ---------------------------------------------------------------
// PrintSpooledJob
//
// Loads the printer add-on and calls its take_job function with
// the spool file as argument.
//
// Parameters:
// spoolFile - the spool file.
//
// Returns:
// B_OK if successful.
// ---------------------------------------------------------------
status_t Printer::PrintSpooledJob(BFile* spoolFile)
{
status_t rc;
image_id id;
if ((rc = LoadPrinterAddon(id)) == B_OK) {
take_job_func_t func;
// Addon was loaded, so try and get the take_job symbol
if ((rc = get_image_symbol(id, "take_job", B_SYMBOL_TYPE_TEXT,
(void**)&func)) == B_OK) {
// This seems to be required for legacy?
// HP PCL3 add-on crashes without it!
BMessage params(B_REFS_RECEIVED);
params.AddInt32("file", (int32)spoolFile);
params.AddInt32("printer", (int32)SpoolDir());
// call the function and check its result
BMessage* result = (*func)(spoolFile, SpoolDir(), ¶ms);
if (result == NULL || result->what != 'okok')
rc = B_ERROR;
delete result;
}
::unload_add_on(id);
}
return rc;
}
// ---------------------------------------------------------------
// GetDefaultSettings
//
// Retrieve the default configuration message from printer add-on
//
// Parameters:
// settings, output paramter.
//
// Returns:
// B_OK if successful or errorcode otherwise.
// ---------------------------------------------------------------
status_t Printer::GetDefaultSettings(BMessage& settings)
{
status_t rc;
image_id id;
if ((rc = LoadPrinterAddon(id)) == B_OK) {
// Addon was loaded, so try and get the default_settings symbol
default_settings_t func;
if ((rc = get_image_symbol(id, "default_settings", B_SYMBOL_TYPE_TEXT,
(void**)&func)) == B_OK) {
// call the function and check its result
BMessage* new_settings = (*func)(SpoolDir());
if (new_settings) {
settings = *new_settings;
settings.what = 'okok';
AddCurrentPrinter(settings);
} else {
rc = B_ERROR;
}
delete new_settings;
}
::unload_add_on(id);
}
return rc;
}
// ---------------------------------------------------------------
// ConfigureJob
//
// Handles calling the printer addon's config_job function.
//
// Parameters:
// settings - Job settings to display. The contents of this
// message will be replaced with the new settings
// if the function returns success.
//
// Returns:
// B_OK if successful or errorcode otherwise.
// ---------------------------------------------------------------
status_t Printer::ConfigureJob(BMessage& settings)
{
status_t rc;
image_id id;
if ((rc = LoadPrinterAddon(id)) == B_OK) {
// Addon was loaded, so try and get the config_job symbol
config_func_t func;
if ((rc = get_image_symbol(id, "config_job", B_SYMBOL_TYPE_TEXT,
(void**)&func)) == B_OK) {
// call the function and check its result
BMessage* new_settings = (*func)(SpoolDir(), &settings);
if ((new_settings != NULL) && (new_settings->what != 'baad')) {
settings = *new_settings;
settings.what = 'okok';
AddCurrentPrinter(settings);
} else {
rc = B_ERROR;
}
delete new_settings;
}
::unload_add_on(id);
}
return rc;
}
void *
get_symbol (void *handle, char *symbol_name)
{
void *symptr;
#ifdef DJGPP
st_symbol_t *sym = map_get (dxe_map, handle);
if (sym == NULL)
{
fprintf (stderr, "ERROR: Invalid handle: %x\n", (int) handle);
exit (1);
}
symptr = sym->dxe_symbol (symbol_name);
if (symptr == NULL)
{
fprintf (stderr, "ERROR: Could not find symbol: %s\n", symbol_name);
exit (1);
}
#elif defined __unix__ || defined __APPLE__ // Mac OS X actually, see
char *strptr; // comment in open_module()
symptr = dlsym (handle, symbol_name);
if ((strptr = dlerror ()) != NULL) // this is "the correct way"
{ // according to the info page
fputs ("ERROR: ", stderr);
fputs (strptr, stderr);
fputc ('\n', stderr);
exit (1);
}
#elif defined _WIN32
u_func_ptr_t sym;
sym.func_ptr = (void (*) (void)) GetProcAddress ((HINSTANCE) handle, symbol_name);
symptr = sym.void_ptr;
if (symptr == NULL)
{
LPTSTR strptr;
fputs ("ERROR: ", stderr);
FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER |
FORMAT_MESSAGE_FROM_SYSTEM |
FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, GetLastError (),
MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
(LPTSTR) &strptr, 0, NULL);
fputs (strptr, stderr);
LocalFree (strptr);
exit (1);
}
#elif defined __BEOS__
int status = get_image_symbol ((int) handle, symbol_name,
B_SYMBOL_TYPE_ANY, &symptr); // B_SYMBOL_TYPE_TEXT/B_SYMBOL_TYPE_DATA
if (status != B_OK)
{
fprintf (stderr, "ERROR: Could not find symbol: %s\n", symbol_name);
exit (1);
}
#endif
return symptr;
}
template<class T> T*
instantiate_add_on(image_id image, const char* path, const char* type)
{
T* (*instantiateFunction)();
BString functionName = "instantiate_input_";
functionName += type;
if (get_image_symbol(image, functionName.String(), B_SYMBOL_TYPE_TEXT,
(void**)&instantiateFunction) < B_OK) {
ERROR("AddOnManager::_RegisterAddOn(): can't find %s() in \"%s\"\n",
functionName.String(), path);
return NULL;
}
T* addOn = (*instantiateFunction)();
if (addOn == NULL) {
ERROR("AddOnManager::_RegisterAddOn(): %s() in \"%s\" returned "
"NULL\n", functionName.String(), path);
return NULL;
}
status_t status = addOn->InitCheck();
if (status != B_OK) {
ERROR("AddOnManager::_RegisterAddOn(): InitCheck() in \"%s\" "
"returned %s\n", path, strerror(status));
delete addOn;
return NULL;
}
return addOn;
}
static DSO_FUNC_TYPE beos_bind_func (DSO * dso, const char *symname)
{
image_id id;
void *sym;
if ((dso == NULL) || (symname == NULL))
{
DSOerr (DSO_F_BEOS_BIND_FUNC, ERR_R_PASSED_NULL_PARAMETER);
return (NULL);
}
if (sk_num (dso->meth_data) < 1)
{
DSOerr (DSO_F_BEOS_BIND_FUNC, DSO_R_STACK_ERROR);
return (NULL);
}
id = (image_id) sk_value (dso->meth_data, sk_num (dso->meth_data) - 1);
if (id < 1)
{
DSOerr (DSO_F_BEOS_BIND_FUNC, DSO_R_NULL_HANDLE);
return (NULL);
}
if (get_image_symbol (id, symname, B_SYMBOL_TYPE_TEXT, &sym) != B_OK)
{
DSOerr (DSO_F_BEOS_BIND_FUNC, DSO_R_SYM_FAILURE);
ERR_add_error_data (3, "symname(", symname, ")");
return (NULL);
}
return ((DSO_FUNC_TYPE) sym);
}
int
main(int argc, char **argv)
{
// Parse command line arguments
bool ignorePunctuation = false;
char *addon = NULL;
BCollator *collator = NULL;
while ((++argv)[0]) {
if (argv[0][0] == '-') {
if (!strcmp(argv[0], "-i"))
ignorePunctuation = true;
else if (!strcmp(argv[0], "--help"))
usage();
} else {
// this will be the add-on to be loaded
addon = argv[0];
}
}
// load the collator add-on if necessary
if (addon != NULL) {
image_id image = load_add_on(addon);
if (image < B_OK)
fprintf(stderr, "could not load add-on at \"%s\": %s.\n", addon, strerror(image));
BCollatorAddOn *(*instantiate)(void);
if (get_image_symbol(image, "instantiate_collator",
B_SYMBOL_TYPE_TEXT, (void **)&instantiate) == B_OK) {
BCollatorAddOn *collatorAddOn = instantiate();
if (collatorAddOn != NULL)
collator = new BCollator(collatorAddOn, B_COLLATE_PRIMARY, true);
} else if (image >= B_OK) {
fprintf(stderr, "could not find instantiate_collator() function in add-on!\n");
unload_add_on(image);
}
}
if (collator == NULL) {
collator = be_locale->Collator();
addon = (char*)"default";
}
// test key creation speed
collator->SetIgnorePunctuation(ignorePunctuation);
printf("%s:\n", addon);
test(collator, "primary: ", B_COLLATE_PRIMARY);
test(collator, "secondary: ", B_COLLATE_SECONDARY);
test(collator, "tertiary: ", B_COLLATE_TERTIARY);
test(collator, "quaternary:", B_COLLATE_QUATERNARY);
test(collator, "identical: ", B_COLLATE_IDENTICAL);
return 0;
}
static int
xmlModulePlatformSymbol(void *handle, const char *name, void **symbol)
{
status_t rc;
rc = get_image_symbol((image_id) handle, name, B_SYMBOL_TYPE_ANY, symbol);
return (rc == B_OK) ? 0 : -1;
}
char *
AddonName(image_id id, int n)
{
static char name[MAX_QUA_NAME_LENGTH];
status_t err;
char **addon_tag_p;
if ((err=get_image_symbol(
id, "addon_name", B_SYMBOL_TYPE_DATA, (void**)&addon_tag_p)) >= B_NO_ERROR) {
strcpy(name, *addon_tag_p);
} else if ((err=get_image_symbol(
id, "addon_name_array", B_SYMBOL_TYPE_DATA, (void**)&addon_tag_p)) >= B_NO_ERROR) {
strcpy(name, addon_tag_p[n]);
} else {
strcpy(name, "boring");
}
return name;
}
static SDL_INLINE void *get_sdlapi_entry(const char *fname, const char *sym)
{
image_id lib = load_add_on(fname);
void *retval = NULL;
if ((lib < 0) || (get_image_symbol(lib, sym, B_SYMBOL_TYPE_TEXT, &retval) != B_NO_ERROR)) {
retval = NULL;
}
return retval;
}
void *
SDL_LoadFunction(void *handle, const char *name)
{
void *sym = NULL;
image_id library_id = (image_id) handle;
status_t rc = get_image_symbol(library_id, name, B_SYMBOL_TYPE_TEXT, &sym);
if (rc != B_NO_ERROR) {
SDL_SetError(strerror(rc));
}
return (sym);
}
void* CC_CALL cc_load_function(void *handle, const char_t *name)
{
void *sym = NULL;
image_id library_id = (image_id) handle;
status_t rc = get_image_symbol(library_id, name, B_SYMBOL_TYPE_TEXT, &sym);
if (rc != B_NO_ERROR) {
CC_ERROR_LOG(_T("Failed loading %s : %s"),sofile,strerror((int) rc));
return NULL;
}
return (sym);
}
void
__haiku_term_after(image_id id)
{
void (*after)(image_id);
HIDDEN_FUNCTION(__haiku_term_after);
if (get_image_symbol(id, B_TERM_AFTER_FUNCTION_NAME, B_SYMBOL_TYPE_TEXT,
(void**)&after) == B_OK) {
after(id);
}
}
void
__haiku_term_before(image_id id)
{
void (*before)(image_id);
HIDDEN_FUNCTION(__haiku_term_before);
if (get_image_symbol(id, B_TERM_BEFORE_FUNCTION_NAME, B_SYMBOL_TYPE_TEXT,
(void**)&before) == B_OK) {
before(id);
}
}
status_t
AddOnManager::_RegisterAddOn(const entry_ref& ref)
{
BPath path(&ref);
ImageLoader loader(path);
status_t status = loader.InitCheck();
if (status != B_OK)
return status;
MediaPlugin* (*instantiate_plugin_func)();
if (get_image_symbol(loader.Image(), "instantiate_plugin",
B_SYMBOL_TYPE_TEXT, (void**)&instantiate_plugin_func) < B_OK) {
printf("AddOnManager::_RegisterAddOn(): can't find instantiate_plugin "
"in \"%s\"\n", path.Path());
return B_BAD_TYPE;
}
MediaPlugin* plugin = (*instantiate_plugin_func)();
if (plugin == NULL) {
printf("AddOnManager::_RegisterAddOn(): instantiate_plugin in \"%s\" "
"returned NULL\n", path.Path());
return B_ERROR;
}
ReaderPlugin* reader = dynamic_cast<ReaderPlugin*>(plugin);
if (reader != NULL)
_RegisterReader(reader, ref);
DecoderPlugin* decoder = dynamic_cast<DecoderPlugin*>(plugin);
if (decoder != NULL)
_RegisterDecoder(decoder, ref);
WriterPlugin* writer = dynamic_cast<WriterPlugin*>(plugin);
if (writer != NULL)
_RegisterWriter(writer, ref);
EncoderPlugin* encoder = dynamic_cast<EncoderPlugin*>(plugin);
if (encoder != NULL)
_RegisterEncoder(encoder, ref);
StreamerPlugin* streamer = dynamic_cast<StreamerPlugin*>(plugin);
if (streamer != NULL)
_RegisterStreamer(streamer, ref);
delete plugin;
return B_OK;
}
bool
CatalogAddOnInfo::MakeSureItsLoaded()
{
if (!fIsEmbedded && fAddOnImage < B_OK) {
// add-on has not been loaded yet, so we try to load it:
BString fullAddOnPath(fPath);
fullAddOnPath << "/" << fName;
fAddOnImage = load_add_on(fullAddOnPath.String());
if (fAddOnImage >= B_OK) {
get_image_symbol(fAddOnImage, "instantiate_catalog",
B_SYMBOL_TYPE_TEXT, (void**)&fInstantiateFunc);
get_image_symbol(fAddOnImage, "create_catalog",
B_SYMBOL_TYPE_TEXT, (void**)&fCreateFunc);
get_image_symbol(fAddOnImage, "get_available_languages",
B_SYMBOL_TYPE_TEXT, (void**)&fLanguagesFunc);
} else
return false;
} else if (fIsEmbedded) {
// The built-in catalog still has to provide this function
fLanguagesFunc = default_catalog_get_available_languages;
}
return true;
}
/* A function called through the vtable to get the address of
a symbol loaded from a particular module. */
static void *
vm_sym (lt_user_data LT__UNUSED loader_data, lt_module module, const char *name)
{
void *address = 0;
image_id image = (image_id) module;
if (get_image_symbol (image, name, B_SYMBOL_TYPE_ANY, address) != B_OK)
{
LT__SETERROR (SYMBOL_NOT_FOUND);
address = 0;
}
return address;
}
void AmFilterAddOnHandle::ImageLoaded(image_id image)
{
if (!IsStatic()) {
ImageUnloading(image);
void *factory;
status_t err = get_image_symbol(image, "make_nth_filter",
B_SYMBOL_TYPE_TEXT, &factory);
if (err >= B_OK) {
mAddOn = (*((make_nth_filter_type)factory))(0, image, this, 0);
if (!mAddOn) err = B_ERROR;
}
}
}
status_t
PrinterDriverAddOn::AddPrinter(const char* spoolFolderName)
{
if (!IsLoaded())
return B_ERROR;
add_printer_func_t func;
status_t result = get_image_symbol(fAddOnID, "add_printer",
B_SYMBOL_TYPE_TEXT, (void**)&func);
if (result != B_OK)
return result;
if ((*func)(spoolFolderName) == NULL)
return B_ERROR;
return B_OK;
}
void
DecorManager::RescanDecorators()
{
BDirectory dir(DECORATORS_DIR);
if (dir.InitCheck() != B_OK)
return;
entry_ref ref;
while (dir.GetNextRef(&ref) == B_OK) {
BPath path;
path.SetTo(DECORATORS_DIR);
path.Append(ref.name);
// Because this function is used for both initialization and for keeping
// the list up to date, check for existence in the list. Note that we
// do not check to see if a decorator has been removed. This is for
// stability. If there is a decorator in memory already whose file has
// been deleted, it is still available until the next boot, at which point
// it will obviously not be loaded.
if (_FindDecor(ref.name))
continue;
image_id image = load_add_on(path.Path());
if (image < 0)
continue;
// As of now, we do nothing with decorator versions, but the possibility
// exists that the API will change even though I cannot forsee any reason
// to do so. If we *did* do anything with decorator versions, the
// assignment would go here.
create_decorator* createFunc;
// Get the instantiation function
status_t status = get_image_symbol(image, "instantiate_decorator",
B_SYMBOL_TYPE_TEXT, (void**)&createFunc);
if (status != B_OK) {
unload_add_on(image);
continue;
}
// TODO: unload images until they are actually used!
fDecorList.AddItem(new DecorInfo(image, ref.name, createFunc));
}
}
void
BF_GUI_FilesPanel::Action_Tracker_Addons_Run(const char *pc_AddOn)
{
ASSERT(pc_AddOn);
image_id uImage;
uImage = load_add_on(pc_AddOn);
if(0==uImage) return;
BEntry oEntry(oPath.Path());
entry_ref uEntryRef;
if(B_OK!=oEntry.GetRef(&uEntryRef)) return;
void (*Func_AddOn)(entry_ref dir_ref, BMessage *msg, void *);
if(B_OK!=get_image_symbol(uImage, "process_refs", B_SYMBOL_TYPE_TEXT, (void**)&Func_AddOn)) return;
BMessage *poMessage = new BMessage();
BF_NodeCollection loSelNode;
loNode.GetSelecting(loSelNode);
if(loSelNode.CountItems()==0) loSelNode.AddItem(Nodes_Focus());
if(loSelNode.CountItems()==0) return;
ASSERT(poMessage);
BF_Node *poNode=NULL;
entry_ref uNodeRef;
BL_String s;
for(int iNode=0;iNode<loSelNode.CountItems();iNode++){
poNode = loSelNode.NodeAt(iNode);
s=oPath.Path();
s<<"/";
s<<poNode->sName;
if(B_OK!=oEntry.SetTo(s.String()) || B_OK!=oEntry.GetRef(&uNodeRef)) continue;
poMessage->AddRef("refs",&uNodeRef);
}
poMessage->AddRef("folder_ref",&uEntryRef);
poMessage->AddPointer("func",(void*)Func_AddOn);
// run thread //
thread_id idThread = spawn_thread(BF_GUI_FilesPanel_Action_Tracker_Addons_Run_Thread,"tracker_addon_thread",B_THREAD_SUSPENDED,(void*)poMessage);
ASSERT(idThread>0,"can`t start thread\n");
ASSERT(B_OK==resume_thread(idThread));
set_thread_priority(idThread,1);
}
CGraphWindow::CGraphWindow(CCellWindow *inOwner, BRect inRect, image_id inAddOn)
: BWindow(inRect, "Graph", B_DOCUMENT_WINDOW, 0)
{
fOwner = inOwner;
fAddOnImage = inAddOn;
inOwner->GetCellView()->GetSelection(&fSelection);
fContainer = inOwner->GetCellView()->GetContainer();
CGraphPlugIn* (*createGraph)(BRect frame, range selection, CContainer *container);
if (get_image_symbol(fAddOnImage, "NewGraphPlugIn__F5BRect5rangeP10CContainer",
B_SYMBOL_TYPE_TEXT, &createGraph) != B_NO_ERROR)
THROW((errCreatingGraph));
BRect r(Bounds());
r.bottom = GetMBarHeight();
BMenuBar *mbar = new BMenuBar(r, "mbar");
AddChild(mbar);
BMenu *file = new BMenu("File");
file->AddItem(new BMenuItem("Close", new BMessage(B_QUIT_REQUESTED), 'W'));
mbar->AddItem(file);
BMenu *edit = new BMenu("Edit");
edit->AddItem(new BMenuItem("Copy", new BMessage(B_COPY), 'C'));
mbar->AddItem(edit);
r = Bounds();
r.top += GetMBarHeight();
BView *background = new BView(r, "background", B_FOLLOW_ALL_SIDES,
B_WILL_DRAW | B_FULL_UPDATE_ON_RESIZE);
AddChild(background);
r.OffsetTo(0, 0);
r.InsetBy(B_V_SCROLL_BAR_WIDTH, B_H_SCROLL_BAR_HEIGHT);
fMainView = (*createGraph)(r, fSelection, fContainer);
if (fMainView == NULL)
THROW((errCreatingGraphView));
background->AddChild(fMainView);
fMainView->DataChanged();
Show();
} /* CGraphWindow::CGraphWindow */
status_t
BTranslatorRoster::Private::GetTranslatorData(image_id image,
translator_data& data)
{
// If this is a translator add-on, it is in the C format
memset(&data, 0, sizeof(translator_data));
// find all the symbols
int32* version;
if (get_image_symbol(image, "translatorName", B_SYMBOL_TYPE_DATA,
(void**)&data.name) < B_OK
|| get_image_symbol(image, "translatorInfo", B_SYMBOL_TYPE_DATA,
(void**)&data.info) < B_OK
|| get_image_symbol(image, "translatorVersion", B_SYMBOL_TYPE_DATA,
(void**)&version) < B_OK || version == NULL
|| get_image_symbol(image, "inputFormats", B_SYMBOL_TYPE_DATA,
(void**)&data.input_formats) < B_OK
|| get_image_symbol(image, "outputFormats", B_SYMBOL_TYPE_DATA,
(void**)&data.output_formats) < B_OK
|| get_image_symbol(image, "Identify", B_SYMBOL_TYPE_TEXT,
(void**)&data.identify_hook) < B_OK
|| get_image_symbol(image, "Translate", B_SYMBOL_TYPE_TEXT,
(void**)&data.translate_hook) < B_OK) {
return B_BAD_TYPE;
}
data.version = *version;
// those calls are optional
get_image_symbol(image, "MakeConfig", B_SYMBOL_TYPE_TEXT,
(void**)&data.make_config_hook);
get_image_symbol(image, "GetConfigMessage", B_SYMBOL_TYPE_TEXT,
(void**)&data.get_config_message_hook);
return B_OK;
}
status_t
PrinterDriverAddOn::ConfigJob(BDirectory* spoolFolder, BMessage* settings)
{
if (!IsLoaded())
return B_ERROR;
config_func_t func;
status_t result = get_image_symbol(fAddOnID, "config_job",
B_SYMBOL_TYPE_TEXT, (void**)&func);
if (result != B_OK)
return result;
BMessage* newSettings = (*func)(spoolFolder, settings);
result = CopyValidSettings(settings, newSettings);
delete newSettings;
return result;
}