#include "global.h"
#include <Alert.h>
#include <Application.h>
#include <Beep.h>
#include <Bitmap.h>
#include <BitmapStream.h>
#include <Box.h>
#include <Button.h>
#include <Catalog.h>
#include <CheckBox.h>
#include <ClassInfo.h>
#include <Clipboard.h>
#include <ColorControl.h>
#include <Deskbar.h>
#include <Entry.h>
#include <File.h>
#include <FindDirectory.h>
#include <Font.h>
#include <Locale.h>
#include <List.h>
#include <ListView.h>
#include <Menu.h>
#include <MenuBar.h>
#include <MenuItem.h>
#include <MenuField.h>
#include <NodeInfo.h>
#include <OS.h>
#include <OutlineListView.h>
#include <Path.h>
#include <Picture.h>
#include <PictureButton.h>
#include <PopUpMenu.h>
#include <PrintJob.h>
#include <PropertyInfo.h>
#include <RadioButton.h>
#include <Roster.h>
#include <Screen.h>
#include <ScrollBar.h>
#include <ScrollView.h>
#include <Slider.h>
#include <StatusBar.h>
#include <String.h>
//#include <PlaySound.h>
//#include <FileGameSound.h>
//#include "GameSoundDevice.h"
#include <Sound.h>
#include <SoundPlayer.h>
#include <Url.h>
#include <MediaPlay.h>
#include <MediaFile.h>
#include <MediaTrack.h>
//#include <MediaFiles.h>
#include <scheduler.h>
#include <interface/StringView.h>
#include <kernel/fs_attr.h>
#include <TextControl.h>
#include <TextView.h>
#include <TranslatorRoster.h>
#include <View.h>
#include <Window.h>
#include "config.h"
#include "CalendarControl.h"
#include "YabFilePanel.h"
#include "SplitPane.h"
#include "URLView.h"
#include "Spinner.h"
#include "YabTabView.h"
#include "TabView.h"
#ifdef LIBBSVG
#include <SVGView.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include "YabInterface.h"
#include "YabWindow.h"
#include "YabView.h"
#include "YabBitmapView.h"
#include "YabList.h"
#include "YabText.h"
#include "YabMenu.h"
#include "YabStackView.h"
#include "column/YabColumnType.h"
#include "column/ColorTools.h"
#include "column/ColumnListView.h"
thread_id reader = -1;
sem_id finished = -1;
BMediaTrack* playTrack;
media_format playFormat;
BSoundPlayer* player = 0;
const uint32 YABBUTTON = 'YBbu';
const uint32 YABMENU = 'YBme';
const uint32 YABSUBMENU = 'YBsu';
const uint32 YABTEXTCONTROL = 'YBtc';
const uint32 YABCHECKBOX = 'YBcb';
const uint32 YABRADIOBUTTON = 'YBrb';
const uint32 YABLISTBOXSELECT = 'YBls';
const uint32 YABLISTBOXINVOKE = 'YBli';
const uint32 YABDROPBOX = 'YBdb';
const uint32 YABSLIDER = 'YBsl';
const uint32 YABCOLORCONTROL = 'YBco';
const uint32 YABTREEBOXSELECT = 'YBts';
const uint32 YABTREEBOXINVOKE = 'YBti';
const uint32 YABFILEBOXSELECT = 'YBfs';
const uint32 YABFILEBOXINVOKE = 'YBfi';
const uint32 YABSHORTCUT = 'YBsh';
const uint32 TYPE_YABVIEW = 1;
char * refsRec=(char*)"";
BCatalog *yabCatalog;
static bool localize = false;
static bool quitting = false;
static property_info prop_list[] = {
{ "YabSendString", {B_SET_PROPERTY, 0}, {B_NAME_SPECIFIER, 0}, "Send a string to MESSAGE$"},
0 // terminate list
};
const char* _L(const char* text)
{
if(localize && yabCatalog)
return yabCatalog->GetString(text, NULL); //B_TRANSLATE_CONTEXT);
return text;
}
/**
* Start the interpreter thread
*/
int32 interpreter(void *data)
{
int argc,t;
char **argv;
YabInterface *yab;
BList *myData = (BList*)data;
argc = (int)(addr_t)myData->ItemAt(0);
argv = (char**)myData->ItemAt(1);
yab = (YabInterface*)myData->ItemAt(2);
t = mmain(argc,argv, yab);
return t;
}
/**
* Constructor sets application directory, spawn the interpreter thread
*/
YabInterface::YabInterface(int argc, char **argv, const char* signature)
:BApplication(signature)
{
BPath AppDirectory;
// app directory
app_info appinfo;
if( GetAppInfo( &appinfo) == B_OK)
{
BEntry ApplicationEntry( &appinfo.ref);
BEntry ApplicationDirectoryEntry;
if( ApplicationEntry.GetParent( &ApplicationDirectoryEntry) == B_OK)
{
if( AppDirectory.SetTo( &ApplicationDirectoryEntry) == B_OK)
{
strcpy(ApplicationDirectory, AppDirectory.Path());
// ApplicationDirectory.SetTo(AppDirectory.Path());
}
}
}
localMessage = "";
BList *myData = new BList(3);
myData->AddItem((void*)(addr_t)argc);
myData->AddItem((void*)argv);
myData->AddItem((void*)this);
myThread = spawn_thread(interpreter,"YabInterpreter",B_NORMAL_PRIORITY,(void*)myData);
if(myThread < B_OK)
{
printf("Can not start thread. Out of memory or maximum thread amount reached.\n");
printf("Exiting now \n\n");
exit(1);
}
if(resume_thread(myThread) < B_OK)
{
printf("Error while starting interpreter!\n");
printf("Exiting now \n\n");
exit(1);
}
viewList = new YabList();
yabbitmaps = new BList();
yabcanvas = new BList();
drawStroking = false;
yabPattern = B_SOLID_HIGH;
yabAlpha = 255;
errorCode = 0;
Roster = NULL;
currentLineNumber = -1;
exiting = false;
for(int i=0; i<63; i++)
mousemessagebuffer[i] = ' ';
mousemessagebuffer[63] = '\0';
myProps = new BPropertyInfo(prop_list);
currentLib = "";
lastMouseMsg = "";
}
YabInterface::~YabInterface()
{
delete mainFileName;
// delete song;
// delete fopen;
// delete fsave;
delete viewList;
//delete Roster;
delete myProps;
delete fPlayer;
if(yabCatalog)
delete yabCatalog;
while(yabbitmaps->CountItems()>0)
{
int i = 0;
BBitmap *b = (BBitmap*)yabbitmaps->RemoveItem(i);
delete b;
}
}
/**
* Returns the application directory
*/
const char* YabInterface::GetApplicationDirectory()
{
return (const char*) ApplicationDirectory;
}
status_t YabInterface::GetSupportedSuites(BMessage *msg)
{
msg->AddString("suites", "suite/vnd.yab-YabInterface");
BPropertyInfo prop_info(prop_list);
msg->AddFlat("messages", &prop_info);
return BApplication::GetSupportedSuites(msg);
}
BHandler* YabInterface::ResolveSpecifier(BMessage *msg, int32 index, BMessage *spec, int32 form, const char *prop)
{
if (myProps->FindMatch(msg, index, spec, form, prop) >= 0)
return (BHandler*)this;
return BApplication::ResolveSpecifier(msg, index, spec, form, prop);
}
void YabInterface::MessageReceived(BMessage *message)
{
// message->PrintToStream();
switch(message->what)
{
case B_SET_PROPERTY:
{
BMessage msg;
int32 i,w;
const char *prop;
if(message->GetCurrentSpecifier(&i, &msg, &w, &prop) != B_BAD_SCRIPT_SYNTAX)
{
BString s;
msg.FindString("name", &s);
localMessage += "_Scripting:";
localMessage += s;
localMessage +="|";
}
}
break;
case B_REFS_RECEIVED:
{
entry_ref ref;
if(message->FindRef("refs", 0, &ref)==B_OK)
{
BEntry e(&ref);
BPath path;
e.GetPath(&path);
localMessage += "_RefsReceived:";
localMessage += path.Path();
localMessage +="|";
}
}
break;
default:
BApplication::MessageReceived(message);
break;
}
}
/**
* The QUIT_REQUESTED message arrived. If the interpreter thread is still active,
* kill it, otherwise exit directly.
*/
bool YabInterface::QuitRequested()
{
/*printf("%d\n",player);
if (player == NULL) {
}
else{
player->Stop();
player->SetHasData(false);
delete player;
delete Roster;
}*/
if (fPlayer->IsPlaying()) {
fPlayer->StopPlaying();
}
kill_thread(reader);
delete fPlayer;
fPlayer = NULL;
//exiting = true;
//return false;
exiting = true;
ExitRequested();
snooze(20000);
return true;
}
void YabInterface::RefsReceived(BMessage *message){
entry_ref ref;
BString tempstr;
if(message->FindRef("refs", 0, &ref)==B_OK)
{
BEntry e(&ref);
BPath path;
e.GetPath(&path);
tempstr += path.Path();
refsRec = strdup(tempstr.String());
}
}
bool YabInterface::ExitRequested()
{
status_t exit_val;
thread_info t;
// printf("QUITDEBUG: Exit\n");
Lock();
// printf("QUITDEBUG: Locked Ok\n");
// if(!quitting)
// {
// printf("QUITDEBUG: quitting\n");
// kill_thread(myThread);
// printf("QUITDEBUG: Kill Thread Ok\n");
// }
// printf("QUITDEBUG: 1\n");
for(int i=0; i<CountWindows(); i++)
{
YabWindow *w = cast_as(WindowAt(i), YabWindow);
if(w)
if(w->Lock())
w->Quit();
}
snooze(15000);
// printf("QUITDEBUG: 3\n");
// BMessenger(be_app).SendMessage(new BMessage(B_QUIT_REQUESTED));
Quit();
// printf("QUITDEBUG: Quit\n");
// printf("QUITDEBUG: wait\n");
// wait_for_thread(myThread, &exit_val);
// get_thread_info(myThread, &t);
// kill_team(t.team);
// printf("QUITDEBUG: Stopped waiting\n");
Unlock();
// printf("QUITDEBUG: Unlock\n");
exit_thread(B_OK);
return true;
}
/**
* Open a window, add the main view.
*/
void YabInterface::OpenWindow(const BRect frame, const char* id, const char* title)
{
YabWindow* w = new YabWindow(frame,title,id, B_TITLED_WINDOW_LOOK, B_NORMAL_WINDOW_FEEL, B_ASYNCHRONOUS_CONTROLS);
YabView* myView = new YabView(w->Bounds(), id, B_FOLLOW_ALL_SIDES, B_WILL_DRAW|B_NAVIGABLE_JUMP);
w->Lock();
w->AddChild(myView);
viewList->AddView(id, myView, TYPE_YABVIEW);
// viewList->PrintOut();
// w->Minimize();
w->SetSizeLimits(10,3000,10,3000);
w->Show();
w->Unlock();
w->layout = -1;
}
int YabInterface::CloseWindow(const char* view)
{
int tmp = 0;
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BView *child, *oldchild;
if(child = myView->ChildAt(0))
{
while(child)
{
CleanupYabTabView(child);
if(is_kind_of(child, YabBitmapView))
yabcanvas->RemoveItem(child);
// viewList->PrintOut();
CleanupSubchildView(child->ChildAt(0));
if(viewList->GetView(child->Name()))
{
RemoveView(child);
viewList->DelView(child->Name());
}
oldchild = child;
child = child->NextSibling();
if(is_kind_of(oldchild, YabView))
DrawClear(oldchild->Name(), true);
if(is_kind_of(oldchild, BMenuBar))
{
oldchild->Hide();
}
oldchild->RemoveSelf();
delete oldchild;
}
}
if(is_kind_of(myView, YabView))
DrawClear(myView->Name(), true);
if(is_kind_of(myView, BMenuBar))
myView->Hide();
myView->RemoveSelf();
delete myView;
viewList->DelView(view);
// viewList->PrintOut();
w->Quit();
tmp = 1;
}
else
ErrorGen("Unable to lock window");
}
else
Error(view, "VIEW");
return tmp;
}
void YabInterface::View(BRect frame, const char* id, const char* view)
{
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
YabView *newView = new YabView(frame, id, B_FOLLOW_ALL_SIDES, B_WILL_DRAW|B_NAVIGABLE_JUMP);
if(w->layout == -1)
newView->SetResizingMode(B_FOLLOW_RIGHT|B_FOLLOW_BOTTOM);
else
newView->SetResizingMode(w->layout);
myView->AddChild(newView);
viewList->AddView(id, newView, TYPE_YABVIEW);
// viewList->PrintOut();
newView->Invalidate();
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
Error(view, "VIEW");
}
void YabInterface::BoxView(BRect frame, const char* id, const char* text, int lineType, const char* view)
{
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BBox *newBox = new BBox(frame, id, B_FOLLOW_ALL_SIDES, B_WILL_DRAW|B_FULL_UPDATE_ON_RESIZE|B_NAVIGABLE_JUMP);
font_height fh;
(be_bold_font)->GetHeight(&fh);
float y1 = fh.ascent + fh.descent + fh.leading + 1.0;
YabView *newView = new YabView(BRect(3,y1,frame.Width()-3,frame.Height()-3), id, B_FOLLOW_ALL_SIDES, B_WILL_DRAW|B_FULL_UPDATE_ON_RESIZE|B_NAVIGABLE_JUMP);
if(w->layout == -1)
{
newBox->SetResizingMode(B_FOLLOW_RIGHT|B_FOLLOW_BOTTOM);
newView->SetResizingMode(B_FOLLOW_RIGHT|B_FOLLOW_BOTTOM);
}
else
{
newBox->SetResizingMode(w->layout);
newView->SetResizingMode(w->layout);
}
newBox->SetLabel(text);
switch(lineType)
{
case 0: newBox->SetBorder(B_NO_BORDER);
break;
case 1: newBox->SetBorder(B_PLAIN_BORDER);
break;
default: newBox->SetBorder(B_FANCY_BORDER);
break;
}
newBox->AddChild(newView);
myView->AddChild(newBox);
viewList->AddView(id, newView, TYPE_YABVIEW);
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
Error(view, "VIEW");
}
void YabInterface::BoxViewSet(const char* id, const char* option, const char* value)
{
YabView *myView = NULL;
BString tmpOption(option);
BString tmpValue(value);
BBox *myBox = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myBox = cast_as(myView->FindView(id), BBox);
if(myBox)
{
if(tmpOption.IFindFirst("label")!=B_ERROR)
{
myBox->SetLabel(tmpValue);
w->Unlock();
return;
}
if(tmpOption.IFindFirst("line")!=B_ERROR)
{
if(tmpValue.IFindFirst("0")!=B_ERROR)
{
myBox->SetBorder(B_NO_BORDER);
w->Unlock();
return;
}
if(tmpValue.IFindFirst("1")!=B_ERROR)
{
myBox->SetBorder(B_PLAIN_BORDER);
w->Unlock();
return;
}
if(tmpValue.IFindFirst("2")!=B_ERROR)
{
myBox->SetBorder(B_FANCY_BORDER);
w->Unlock();
return;
}
}
w->Unlock();
}
else
w->Unlock();
Error(id, "BOXVIEW");
}
}
}
}
void YabInterface::Tab(BRect frame, const char* id, const char* mode, const char* view)
{
BTabView::tab_side side;
BString option(mode);
if(option.IFindFirst("top") != B_ERROR)
side = BTabView::kTopSide;
else if(option.IFindFirst("bottom") != B_ERROR)
side = BTabView::kBottomSide;
else if(option.IFindFirst("left") != B_ERROR)
side = BTabView::kLeftSide;
else if(option.IFindFirst("right") != B_ERROR)
side = BTabView::kRightSide;
else ErrorGen("Invalid Option");
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
YabTabView *myTabView = new YabTabView(frame, id);
if(w->layout == -1)
myTabView->SetResizingMode(B_FOLLOW_ALL);
else
myTabView->SetResizingMode(w->layout);
myTabView->SetFlags(B_WILL_DRAW|B_FULL_UPDATE_ON_RESIZE|B_NAVIGABLE|B_NAVIGABLE_JUMP);
myTabView->SetTabSide(side);
myTabView->SetTabWidth(B_WIDTH_FROM_LABEL);
//myTabView->SetTabWidth(B_WIDTH_AS_USUAL);
myView->AddChild(myTabView);
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
Error(view, "VIEW");
}
void YabInterface::TabAdd(const char* id, const char* tabname)
{
YabView *myView = NULL;
YabTabView *myTabView = NULL;
const char* oldtabview;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
//viewList->PrintOut();
//fprintf(stderr, "Viewlist %d\n",viewList->ItemAt(i));
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myTabView = cast_as(myView->FindView(id), YabTabView);
//printf("\t View %d and the id %d\n", viewList->ItemAt(i));
//printf ("%d \n",myTabView);
//
//myTabView->PrintOut();
oldtabview=myTabView->GetTabName(i);
//printf ("oldtabview: ");
//printf (oldtabview);
//printf("\n");
myTabView->FindTabName(tabname);
//printf("\n");
if (oldtabview==tabname)
{
//BRect contentFrame = myTabView->Bounds();
//YabView *newView = new YabView(contentFrame, id, B_FOLLOW_ALL_SIDES,B_WILL_DRAW|B_NAVIGABLE_JUMP);
//viewList->AddView(id, tabname, TYPE_YABVIEW);
//myTabView=cast_as(myView->FindView(id), YabTabView);
//printf ("%d \n",myTabView);
//myTabView->AddTab(cast_as(myView->FindView(id), YabTabView),oldtabview);
//YabTabView* tabView = static_cast<YabTabView*>(myTabView);
//YabView *t = static_cast<YabView*>(tabView->TabAt(num)->View());
//YabView *t = static_cast<YabView*>(cast_as(myView->FindView(id), YabTabView));
//AddView(i,tabname,TYPE_YABVIEW);
//tabView->show();
//myTabView->AddTab(Tab2, tabname);
}
else
{
if(myTabView)
{
BString t(id);
t << myTabView->CountTabs()+1;
BRect contentFrame = myTabView->Bounds();
YabView *newView = new YabView(contentFrame, t.String(), B_FOLLOW_ALL_SIDES,B_WILL_DRAW|B_NAVIGABLE_JUMP);
viewList->AddView(t.String(), newView, TYPE_YABVIEW);
myTabView->AddTab(newView, tabname);
w->Unlock();
return;
}
}
w->Unlock();
}
}
}
Error(id, "TABVIEW");
}
void YabInterface::TabDel(const char* id, int num) //Reactivating Lorenz Glaser (aka lorglas) 20200801
{
YabView *myView = NULL;
YabTabView *myTabView=NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myTabView = cast_as(myView->FindView(id), YabTabView);
if(myTabView)
{
if(num>=0 && num<=myTabView->CountTabs() && num != myTabView->Selection())
{
if (num<=0) {
num=1; //If you deleted Tab Zero you must reselect Tab Zero
}
myTabView->Select(num-1); //Selection of tab before
YabTabView* tabView = static_cast<YabTabView*>(myTabView);
YabView *t = static_cast<YabView*>(tabView->TabAt(num)->View());
RemoveView(t);
//viewList->DelView(t->NameForTabView());
myTabView->RemoveTab(num); //Remove Tab
//printf ("HAllo %d \n",t);
}
w->Unlock();
//viewList->PrintOut();
return ;
}
//w->Unlock();
}
}
}
Error(id, "TABVIEW");
}
/*
void YabInterface::TabDel(const char* id, int num)
{
YabView *myView = NULL;
#ifdef BUILD_HAIKUTAB
YabTabView *myTabView = NULL;
#else
BTabView *myTabView = NULL;
#endif
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
#ifdef BUILD_HAIKUTAB
myTabView = cast_as(myView->FindView(id), YabTabView);
#else
myTabView = cast_as(myView->FindView(id), BTabView);
#endif
if(myTabView)
{
if(num-1<0 || num-1>myTabView->CountTabs()) ErrorGen("Invalid tab number");
BView *child, *oldchild;
if(child = myView->ChildAt(0))
{
while(child)
{
BView *subchild;
if(subchild = child->ChildAt(0))
while(subchild)
{
#ifdef BUILD_HAIKUTAB
if(is_kind_of(subchild, YabTabView))
{
for(int i = 0; i<((YabTabView*)subchild)->CountTabs(); i++)
{
YabView *t = (YabView*)((YabTabView*)subchild)->TabAt(i);
RemoveView(t);
viewList->DelView(t->Name());
}
}
#endif
if(viewList->GetView(subchild->Name()))
{
RemoveView(subchild);
viewList->DelView(subchild->Name());
}
subchild = subchild->NextSibling();
}
if(viewList->GetView(child->Name()))
{
RemoveView(child);
viewList->DelView(child->Name());
}
oldchild = child;
child = child->NextSibling();
if(is_kind_of(oldchild, YabView))
DrawClear(oldchild->Name(), true);
if(is_kind_of(oldchild, BMenuBar))
{
oldchild->Hide();
}
oldchild->RemoveSelf();
delete oldchild;
}
}
if(is_kind_of(myView, YabView))
DrawClear(myView->Name(), true);
if(is_kind_of(myView, BMenuBar))
myView->Hide();
BBox *box = cast_as(myView->Parent(), BBox);
myView->RemoveSelf();
delete myView;
//viewList->DelView(w);
//viewList->DelView(window);
//viewList->DelView(id);
viewList->PrintOut();
if(box)
{
box->RemoveSelf();
delete box;
}
viewList->PrintOut();
#ifdef BUILD_HAIKUTAB
WindowClear(myTabView->ItemAt(num-1)->Name());
RemoveView(myTabView->ItemAt(num-1));
//#endif
#else
//WindowClear((myTabView->Selection()));
//WindowClear(myTabView->TabAt(num-1)->Name());
//WindowClear(myTabView->ItemAt(num-1)->Name());
//RemoveView(myTabView->ItemAt(num-1));
#endif
myTabView->RemoveTab(num);
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(id, "TABVIEW");
}*/
void YabInterface::TabSet(const char* id, int num)
{
YabView *myView = NULL;
YabTabView *myTabView = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myTabView = cast_as(myView->FindView(id), YabTabView);
if(myTabView)
{
if(num>0 && num<=myTabView->CountTabs() && num != myTabView->Selection()+1)
myTabView->Select(num-1);
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(id, "TABVIEW");
}
int YabInterface::TabViewGet(const char* id)
{
int ret = -1;
YabView *myView = NULL;
YabTabView *myTabView = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myTabView = cast_as(myView->FindView(id), YabTabView);
if(myTabView)
{
ret = myTabView->Selection();
w->Unlock();
return ret+1;
}
w->Unlock();
}
}
}
Error(id, "TABVIEW");
}
void YabInterface::Launch(const char* strg)
{
BString tst(strg);
entry_ref *ref = new entry_ref();
BEntry entry(strg);
entry.GetRef(ref);
if(entry.IsDirectory())
{
BMessage msg, reply;
msg.what = B_REFS_RECEIVED;
msg.AddRef("refs", ref);
BMessenger("application/x-vnd.Be-TRAK").SendMessage(&msg, &reply);
return;
}
status_t t = be_roster->Launch(ref);
if(t != B_OK)
{
if(tst.FindFirst("http://") != B_ERROR || tst.FindFirst("https://") != B_ERROR || tst.FindFirst("file://") != B_ERROR || tst.FindFirst("www.") != B_ERROR)
{
char *link = tst.LockBuffer( tst.Length()+1 );
status_t result = be_roster->Launch( "text/html", 1, &link );
tst.UnlockBuffer();
}
}
delete ref;
}
void YabInterface::CreateButton(BRect frame, const char* id, const char* title, const char* view)
{
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BButton* myButton = new BButton(frame,id,title,new BMessage(YABBUTTON));
if(w->layout == -1)
myButton->SetResizingMode(B_FOLLOW_RIGHT|B_FOLLOW_BOTTOM);
else
myButton->SetResizingMode(w->layout);
myButton->SetFlags(B_WILL_DRAW|B_FULL_UPDATE_ON_RESIZE|B_NAVIGABLE);
// trick Haiku, resize button again
myButton->ResizeTo(frame.Width(), frame.Height());
myView->AddChild(myButton);
// viewList->AddView(id, myButton, TYPE_BBUTTON);
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
Error(view, "VIEW");
}
int YabInterface::CreateImage(BPoint coordinates, const char* FileName, const char* window)
{
BBitmap* myBitmap = NULL;
BFile imageFile;
BPath imagePath;
int ret = 0;
if(*FileName=='/')
imageFile.SetTo(FileName, B_READ_ONLY);
else
if(!strcmp(ApplicationDirectory,""))
{
if(imagePath.SetTo((const char*)ApplicationDirectory, FileName)==B_OK)
imageFile.SetTo(imagePath.Path(), B_READ_ONLY);
}
if(imageFile.InitCheck()!=B_OK)
imageFile.SetTo(FileName, B_READ_ONLY);
if(imageFile.InitCheck()!=B_OK)
return 1;
Roster = BTranslatorRoster::Default();
if(!Roster)
return 2;
BBitmapStream Stream;
if(Roster->Translate(&imageFile, NULL, NULL, &Stream, B_TRANSLATOR_BITMAP)<B_OK)
return 3;
if(Stream.DetachBitmap(&myBitmap)!=B_OK)
return 4;
YabView *myView = cast_as((BView*)viewList->GetView(window), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
YabDrawing *t = new YabDrawing();
t->command = 10;
t->x1 = coordinates.x; t->y1 = coordinates.y;
t->bitmap = myBitmap;
myView->drawList->AddItem(t);
myView->Invalidate(BRect(coordinates.x, coordinates.y, coordinates.x+myBitmap->Bounds().Width(), coordinates.y+myBitmap->Bounds().Height()));
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
{
for(int i=0; i<yabbitmaps->CountItems(); i++)
{
BBitmap *b = (BBitmap*)yabbitmaps->ItemAt(i);
BView *bview = b->FindView(window);
if(bview)
{
b->Lock();
drawing_mode mode = bview->DrawingMode();
bview->SetDrawingMode(B_OP_ALPHA);
bview->DrawBitmap(myBitmap, coordinates);
bview->SetDrawingMode(mode);
bview->Sync();
b->Unlock();
delete Roster;
delete myBitmap;
return 0;
}
}
for(int i=0; i<yabcanvas->CountItems(); i++)
{
YabBitmapView *myView = (YabBitmapView*)yabcanvas->ItemAt(i);
if(!strcmp(myView->Name(), window))
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BBitmap *b = myView->GetBitmap();
BView *bView = myView->GetBitmapView();
b->Lock();
drawing_mode mode = bView->DrawingMode();
bView->SetDrawingMode(B_OP_ALPHA);
bView->DrawBitmap(myBitmap, coordinates);
bView->SetDrawingMode(mode);
bView->Sync();
b->Unlock();
myView->Draw(BRect(coordinates.x, coordinates.y, coordinates.x+myBitmap->Bounds().Width(), coordinates.y+myBitmap->Bounds().Height()));
w->Unlock();
delete Roster;
delete myBitmap;
return 0;
}
else
ErrorGen("Unable to lock window");
}
}
Error(window, "VIEW, BITMAP or CANVAS");
}
delete Roster;
return 0;
}
int YabInterface::CreateImage(BRect frame, const char* FileName, const char* window)
{
int scaling = 0;
if(frame.right == -1) scaling = 1;
if(frame.bottom == -1) scaling = 2;
if(frame.right == -1 && frame.bottom == -1) scaling = 3;
BBitmap* myBitmap = NULL;
BFile ImageFile;
BPath ImagePath;
int ret = 0;
if(*FileName=='/')
ImageFile.SetTo(FileName, B_READ_ONLY);
else
if(!strcmp(ApplicationDirectory,""))
{
if( ImagePath.SetTo((const char*)ApplicationDirectory, FileName) == B_OK)
ImageFile.SetTo(ImagePath.Path(), B_READ_ONLY);
}
if(ImageFile.InitCheck()!=B_OK)
ImageFile.SetTo(FileName, B_READ_ONLY);
if(ImageFile.InitCheck()!=B_OK)
return 1;
Roster = BTranslatorRoster::Default();
if(!Roster)
return 2;
BBitmapStream Stream;
if(Roster->Translate(&ImageFile, NULL, NULL, &Stream, B_TRANSLATOR_BITMAP) < B_OK)
return 3;
if(Stream.DetachBitmap(&myBitmap) != B_OK)
return 4;
BRect newframe;
switch(scaling)
{
case 1:
{
BRect t(myBitmap->Bounds());
double width;
newframe = frame;
width = (t.right-t.left)*((frame.bottom-frame.top)/(t.bottom-t.top));
newframe.right = newframe.left+width;
}
break;
case 2:
{
BRect t(myBitmap->Bounds());
double height;
newframe = frame;
height = (t.bottom-t.top)*((frame.right-frame.left)/(t.right-t.left));
newframe.bottom = newframe.top+height;
}
break;
case 3: newframe = myBitmap->Bounds();
break;
default: newframe = frame;
}
YabView *myView = cast_as((BView*)viewList->GetView(window), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
YabDrawing *t = new YabDrawing();
t->command = 11;
t->x1 = newframe.left; t->y1 = newframe.top;
t->x2 = newframe.right; t->y2 = newframe.bottom;
t->bitmap = myBitmap;
myView->drawList->AddItem(t);
myView->Invalidate(newframe);
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
{
for(int i=0; i<yabbitmaps->CountItems(); i++)
{
BBitmap *b = (BBitmap*)yabbitmaps->ItemAt(i);
BView *bview = b->FindView(window);
if(bview)
{
b->Lock();
drawing_mode mode = bview->DrawingMode();
bview->SetDrawingMode(B_OP_ALPHA);
bview->DrawBitmap(myBitmap, newframe);
bview->SetDrawingMode(mode);
bview->Sync();
b->Unlock();
delete Roster;
delete myBitmap;
return 0;
}
}
for(int i=0; i<yabcanvas->CountItems(); i++)
{
YabBitmapView *myView = (YabBitmapView*)yabcanvas->ItemAt(i);
if(!strcmp(myView->Name(), window))
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BBitmap *b = myView->GetBitmap();
BView *bView = myView->GetBitmapView();
b->Lock();
drawing_mode mode = bView->DrawingMode();
bView->SetDrawingMode(B_OP_ALPHA);
bView->DrawBitmap(myBitmap, newframe);
bView->SetDrawingMode(mode);
bView->Sync();
b->Unlock();
myView->Draw(newframe);
w->Unlock();
delete Roster;
delete myBitmap;
return 0;
}
else
ErrorGen("Unable to lock window");
}
}
Error(window, "VIEW, BITMAP or CANVAS");
}
delete Roster;
return 0;
}
int YabInterface::CreateSVG(BRect frame, const char* FileName, const char* window)
{
#ifdef LIBBSVG
BPath path;
BString file;
file.SetTo(FileName);
if(FileName[0]!='/')
{
if(!strcmp(ApplicationDirectory,""))
{
if(path.SetTo((const char*)ApplicationDirectory, FileName) == B_OK)
file.SetTo(path.Path());
}
}
int ret = 0;
YabView *myView = cast_as((BView*)viewList->GetView(window), YabView); // untested!
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BSVGView *mySVG = new BSVGView(frame,"svgview",0);
mySVG->SetViewColor(myView->ViewColor());
mySVG->SetScaleToFit(true);
if(w->layout == -1)
mySVG->SetResizingMode(B_FOLLOW_RIGHT|B_FOLLOW_BOTTOM);
else
mySVG->SetResizingMode(w->layout);
mySVG->SetFlags(B_WILL_DRAW|B_FULL_UPDATE_ON_RESIZE);
if(mySVG->LoadFromFile(file.String())!=B_OK)
ret = 1;
else
myView->AddChild(mySVG);
myView->Invalidate();
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
Error(window, "VIEW");
return ret;
#else
return 2;
#endif
}
void YabInterface::StatusBar(BRect frame, const char* id, const char* label1, const char* label2, const char* view)
{
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BStatusBar *bar = new BStatusBar(frame, id, label1, label2);
bar->SetBarHeight((float)frame.Height()-(be_plain_font)->Size()-5);
if(w->layout == -1)
bar->SetResizingMode(B_FOLLOW_RIGHT|B_FOLLOW_BOTTOM);
else
bar->SetResizingMode(w->layout);
myView->AddChild(bar);
bar->Draw(frame);
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
Error(view, "VIEW");
}
void YabInterface::StatusBarSet(const char* id, const char* label1, const char* label2, double state)
{
YabView *myView = NULL;
BStatusBar *myBar = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myBar = cast_as(myView->FindView(id), BStatusBar);
if(myBar)
{
myBar->Reset();
myBar->Update((float)state, label1, label2);
w->Unlock();
return;
}
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
}
Error(id, "STATUSBAR");
}
void YabInterface::StatusBarSet(BRect frame, const char* id, const char* view)
{
// empty!
}
void YabInterface::StatusBarSet(const char* id, int r, int g, int b)
{
YabView *myView = NULL;
BStatusBar *myBar = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myBar = cast_as(myView->FindView(id), BStatusBar);
if(myBar)
{
rgb_color rgb = {r,g,b,255};
myBar->SetBarColor(rgb);
w->Unlock();
return;
}
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
}
Error(id, "STATUSBAR");
}
void YabInterface::CreateMenu(const char* menuhead, const char* menuitem, const char *shortcut, const char* window)
{
char myShortcut;
int32 modifiers = 0;
BString t(shortcut);
if(t.Length()>1)
{
myShortcut = shortcut[t.Length()-1];
if(t.IFindFirst("s")!=B_ERROR && t.IFindFirst("s")<t.Length()-1)
modifiers = modifiers|B_SHIFT_KEY;
if(t.IFindFirst("c")!=B_ERROR && t.IFindFirst("c")<t.Length()-1)
modifiers = modifiers|B_CONTROL_KEY;
if(t.IFindFirst("o")!=B_ERROR && t.IFindFirst("o")<t.Length()-1)
modifiers = modifiers|B_OPTION_KEY;
}
else
myShortcut = shortcut[0];
YabView *myView = cast_as((BView*)viewList->GetView(window), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
BMenuBar *menubar;
YabMenu *menu = NULL;
BMenuItem *item = NULL;
w->Lock();
menubar = cast_as(myView->FindView("menubar"), BMenuBar);
if(menubar == NULL)
{
menubar = new BMenuBar(myView->Bounds(),"menubar");
myView->AddChild(menubar);
}
for(int i=0; i<menubar->CountItems(); i++)
if(!strcmp( menubar->ItemAt(i)->Label(), menuhead))
menu = cast_as(menubar->SubmenuAt(i), YabMenu);
if(menu == NULL)
{
menu = new YabMenu(menuhead);
menubar->AddItem((BMenu*)menu);
}
if(!strcmp(menuitem,"--"))
menu->AddItem(new BSeparatorItem());
else
menu->AddItem(new BMenuItem(menuitem, new BMessage(YABMENU), myShortcut, modifiers));
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
Error(window, "VIEW");
}
void YabInterface::CreateTextControl(BRect frame, const char* id, const char* label, const char* text, const char* window)
{
YabView *myView = cast_as((BView*)viewList->GetView(window), YabView);
//viewList->PrintOut();
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BTextControl *textControl = new BTextControl(frame, id ,label, text, new BMessage(YABTEXTCONTROL));
//If the label is not set, a space of 5 pixels was still reserved to the left of the field. This place is now fully used
if (strcmp(label, "") == 0) //check if Label was set
{
textControl->SetDivider(textControl->StringWidth(label)); //+5.0);
}
else if (strcmp(label,"") != 0)
{
textControl->SetDivider(textControl->StringWidth(label)+5.0);
}
if(w)
{
if(w->layout == -1)
textControl->SetResizingMode(B_FOLLOW_RIGHT|B_FOLLOW_BOTTOM);
else
textControl->SetResizingMode(w->layout);
}
textControl->SetFlags(B_WILL_DRAW|B_FULL_UPDATE_ON_RESIZE|B_NAVIGABLE);
myView->AddChild(textControl);
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
Error(window, "VIEW");
}
void YabInterface::CreateCheckBox(double x, double y, const char* id, const char* label, int isActivated, const char* window)
{
YabView *myView = cast_as((BView*)viewList->GetView(window), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BRect frame(x,y,x+1,y+1);
BCheckBox *checkBox = new BCheckBox(frame, id, label, new BMessage(YABCHECKBOX));
checkBox->ResizeToPreferred();
if(isActivated>0) checkBox->SetValue(B_CONTROL_ON);
if(w->layout == -1)
checkBox->SetResizingMode(B_FOLLOW_RIGHT|B_FOLLOW_BOTTOM);
else
checkBox->SetResizingMode(w->layout);
checkBox->SetFlags(B_WILL_DRAW|B_FULL_UPDATE_ON_RESIZE|B_NAVIGABLE);
myView->AddChild(checkBox);
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
Error(window, "VIEW");
}
void YabInterface::CreateRadioButton(double x, double y, const char* groupID, const char* label, int isActivated, const char* window)
{
YabView *myView = cast_as((BView*)viewList->GetView(window), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BRect frame(x,y,x+1,y+1);
BRadioButton *radio = new BRadioButton(frame, groupID, label, new BMessage(YABRADIOBUTTON));
radio->ResizeToPreferred();
if(isActivated>0) radio->SetValue(B_CONTROL_ON);
if(w->layout == -1)
radio->SetResizingMode(B_FOLLOW_RIGHT|B_FOLLOW_BOTTOM);
else
radio->SetResizingMode(w->layout);
radio->SetFlags(B_WILL_DRAW|B_FULL_UPDATE_ON_RESIZE|B_NAVIGABLE);
myView->AddChild(radio);
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
Error(window, "VIEW");
}
void YabInterface::CreateListBox(BRect frame, const char* title, int scrollbar, const char* window)
{
YabView *myView = cast_as(((BView*)viewList->GetView(window)), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
uint32 resizeMode;
w->Lock();
if(scrollbar == 3 || scrollbar == 1) frame.right -= B_V_SCROLL_BAR_WIDTH;
if(scrollbar>2) frame.bottom -= B_H_SCROLL_BAR_HEIGHT;
BListView *list = new BListView(frame,title);
if(w->layout == -1)
resizeMode = B_FOLLOW_ALL;
else
resizeMode = w->layout;
list->SetResizingMode(resizeMode);
list->SetFlags(B_WILL_DRAW|B_FULL_UPDATE_ON_RESIZE|B_NAVIGABLE);
list->SetSelectionMessage(new BMessage(YABLISTBOXSELECT));
list->SetInvocationMessage(new BMessage(YABLISTBOXINVOKE));
switch(scrollbar)
{
case 3: // both
myView->AddChild(new BScrollView("scroll_list", list, resizeMode, B_WILL_DRAW|B_FULL_UPDATE_ON_RESIZE, true, true));
break;
case 2: // horizontal
myView->AddChild(new BScrollView("scroll_list", list, resizeMode, B_WILL_DRAW|B_FULL_UPDATE_ON_RESIZE, true, false));
break;
case 0: // none
myView->AddChild(list);
break;
default: // vertical is default
myView->AddChild(new BScrollView("scroll_list", list, resizeMode, B_WILL_DRAW|B_FULL_UPDATE_ON_RESIZE, false, true));
break;
}
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
Error(window, "VIEW");
}
void YabInterface::CreateDropBox(BRect frame, const char* title, const char* label, const char* window)
{
YabView *myView = cast_as((BView*)viewList->GetView(window), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BPopUpMenu *dropmenu = new BPopUpMenu("");
BMenuField *drop = new BMenuField(frame,title,label, dropmenu, true);
drop->ResizeToPreferred();
//If the label is not set, a space of 5 pixels was still reserved to the left of the field. This place is now fully used
if (strcmp(label, "") == 0) //check if label was set
{
drop->SetDivider(drop->StringWidth(label));
}
else if (strcmp(label,"") != 0)
{
drop->SetDivider(drop->StringWidth(label)+5.0);
}
//drop->SetDivider(drop->StringWidth(label)+5.0);
if(w->layout == -1)
drop->SetResizingMode(B_FOLLOW_RIGHT|B_FOLLOW_BOTTOM);
else
drop->SetResizingMode(w->layout);
drop->SetFlags(B_WILL_DRAW|B_FULL_UPDATE_ON_RESIZE|B_NAVIGABLE);
myView->AddChild(drop);
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
Error(window, "VIEW");
}
void YabInterface::CreateItem(const char* id, const char* item)
{
YabView *myView = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BMenuField *myMenuField = cast_as(myView->FindView(id), BMenuField);
if(myMenuField)
{
BPopUpMenu *myPopup = cast_as(myMenuField->Menu(), BPopUpMenu);
if(myPopup)
{
if(!strcmp(item,"--"))
myPopup->AddItem(new BSeparatorItem());
else
{
BMenuItem *tmp = new BMenuItem(item, new BMessage(YABDROPBOX));
myPopup->AddItem(tmp);
if(myPopup->CountItems()==1) // first Item
tmp->SetMarked(true);
}
w->Unlock();
return;
}
}
w->Unlock();
}
}
}
Error(id, "DROPBOX");
}
void YabInterface::RemoveItem(const char* title, const char* item)
{
YabView *myView = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BListView *myList = cast_as(myView->FindView(title), BListView);
if(myList)
{
for(int i=0; i<myList->CountItems(); i++)
{
BStringItem *stritem = cast_as(myList->ItemAt(i), BStringItem);
if(stritem && !strcmp(stritem->Text(), item))
{
myList->RemoveItem(i);
w->Unlock();
return;
}
}
w->Unlock();
ErrorGen("Item not found");
}
w->Unlock();
}
}
}
Error(title, "DROPBOX");
}
void YabInterface::ClearItems(const char* title)
{
YabView *myView = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BListView *myList = cast_as(myView->FindView(title), BListView);
if(myList)
{
myList->RemoveItems(0,myList->CountItems());
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(title, "DROPBOX");
}
void YabInterface::DrawText(BPoint coordinates, const char* text, const char* window)
{
YabView *myView = cast_as((BView*)viewList->GetView(window), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
YabDrawing *t = new YabDrawing();
t->command = 0;
t->x1 = coordinates.x; t->y1 = coordinates.y;
t->chardata = strdup(text);
myView->drawList->AddItem(t);
font_height height;
myView->GetFontHeight(&height);
BRect bbox;
bbox.left = coordinates.x;
bbox.top = coordinates.y - height.ascent;
bbox.right = coordinates.x + myView->StringWidth(text);
bbox.bottom = coordinates.y + height.descent;
BFont tFont;
myView->GetFont(&tFont);
if(tFont.Rotation() == 0.0 && tFont.Shear() == 90.0)
myView->Invalidate(bbox);
else
myView->Invalidate();
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
{
for(int i=0; i<yabbitmaps->CountItems(); i++)
{
BBitmap *b = (BBitmap*)yabbitmaps->ItemAt(i);
BView *bview = b->FindView(window);
if(bview)
{
b->Lock();
bview->SetDrawingMode(B_OP_ALPHA);
bview->SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_COMPOSITE);
bview->DrawString(text, coordinates);
bview->Sync();
b->Unlock();
return;
}
}
for(int i=0; i<yabcanvas->CountItems(); i++)
{
YabBitmapView *myView = (YabBitmapView*)yabcanvas->ItemAt(i);
if(!strcmp(myView->Name(), window))
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BBitmap *b = myView->GetBitmap();
BView *bView = myView->GetBitmapView();
b->Lock();
bView->SetDrawingMode(B_OP_ALPHA);
bView->SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_COMPOSITE);
bView->DrawString(text, coordinates);
bView->Sync();
b->Unlock();
font_height height;
bView->GetFontHeight(&height);
BRect bbox;
bbox.left = coordinates.x;
bbox.top = coordinates.y - height.ascent;
bbox.right = coordinates.x + bView->StringWidth(text);
bbox.bottom = coordinates.y + height.descent;
myView->Draw(bbox);
w->Unlock();
return;
}
else
ErrorGen("Unable to lock window");
}
}
Error(window, "VIEW, BITMAP or CANVAS");
}
}
void YabInterface::DrawRect(BRect frame, const char* window)
{
YabView *myView = cast_as((BView*)viewList->GetView(window), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
YabDrawing *t = new YabDrawing();
if(drawStroking)
t->command = 4;
else
t->command = 5;
t->x1 = frame.left; t->y1 = frame.top;
t->x2 = frame.right; t->y2 = frame.bottom;
t->p = yabPattern;
myView->drawList->AddItem(t);
myView->Invalidate(frame);
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
{
for(int i=0; i<yabbitmaps->CountItems(); i++)
{
BBitmap *b = (BBitmap*)yabbitmaps->ItemAt(i);
BView *bview = b->FindView(window);
if(bview)
{
b->Lock();
bview->SetDrawingMode(B_OP_ALPHA);
bview->SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_COMPOSITE);
if(drawStroking)
bview->StrokeRect(frame, yabPattern);
else
bview->FillRect(frame, yabPattern);
bview->Sync();
b->Unlock();
return;
}
}
for(int i=0; i<yabcanvas->CountItems(); i++)
{
YabBitmapView *myView = (YabBitmapView*)yabcanvas->ItemAt(i);
if(!strcmp(myView->Name(), window))
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BBitmap *b = myView->GetBitmap();
BView *bView = myView->GetBitmapView();
b->Lock();
// bView->SetDrawingMode(B_OP_ALPHA);
//bView->SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_COMPOSITE);
if(drawStroking)
bView->StrokeRect(frame, yabPattern);
else
bView->FillRect(frame, yabPattern);
bView->Sync();
b->Unlock();
myView->Draw(frame);
w->Unlock();
return;
}
else
ErrorGen("Unable to lock window");
}
}
Error(window, "VIEW, BITMAP or CANVAS");
}
}
void YabInterface::DrawClear(const char* window, bool isExit)
{
YabView *myView = cast_as((BView*)viewList->GetView(window), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
rgb_color lowcolor = myView->LowColor();
rgb_color highcolor = myView->HighColor();
BFont lastfont;
myView->GetFont(&lastfont);
while(myView->drawList->CountItems()>0)
{
YabDrawing *t = (YabDrawing*)myView->drawList->LastItem();
myView->drawList->RemoveItem(t);
if(t->command == 0) delete [] t->chardata;
if(t->command == 10 || t->command == 11) delete t->bitmap;
delete t;
}
YabDrawing *t1 = new YabDrawing();
t1->command = 7;
t1->r = lowcolor.red; t1->g = lowcolor.green;
t1->b = lowcolor.blue; t1->alpha = yabAlpha;
myView->drawList->AddItem(t1);
YabDrawing *t2 = new YabDrawing();
t2->command = 6;
t2->r = highcolor.red; t2->g = highcolor.green;
t2->b = highcolor.blue; t2->alpha = yabAlpha;
myView->drawList->AddItem(t2);
YabDrawing *t3 = new YabDrawing();
t3->command = 12;
t3->font = lastfont;
myView->drawList->AddItem(t3);
myView->Invalidate();
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
if(!isExit) Error(window, "VIEW");
}
void YabInterface::DrawDot(double x, double y, const char* window)
{
YabView *myView = cast_as((BView*)viewList->GetView(window), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
YabDrawing *t = new YabDrawing();
t->command = 1;
t->x1 = x; t->y1 = y;
t->x2 = x; t->y2 = y;
t->p = yabPattern;
myView->drawList->AddItem(t);
myView->Invalidate(BRect(x,y,x,y));
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
{
for(int i=0; i<yabbitmaps->CountItems(); i++)
{
BBitmap *b = (BBitmap*)yabbitmaps->ItemAt(i);
BView *bview = b->FindView(window);
if(bview)
{
b->Lock();
bview->SetDrawingMode(B_OP_ALPHA);
bview->SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_COMPOSITE);
bview->StrokeLine(BPoint(x,y), BPoint(x,y), yabPattern);
bview->Sync();
b->Unlock();
return;
}
}
for(int i=0; i<yabcanvas->CountItems(); i++)
{
YabBitmapView *myView = (YabBitmapView*)yabcanvas->ItemAt(i);
if(!strcmp(myView->Name(), window))
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BBitmap *b = myView->GetBitmap();
BView *bView = myView->GetBitmapView();
b->Lock();
// bView->SetDrawingMode(B_OP_ALPHA);
// bView->SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_COMPOSITE);
bView->StrokeLine(BPoint(x,y), BPoint(x,y), yabPattern);
bView->Sync();
b->Unlock();
myView->Draw(BRect(x,y,x,y));
w->Unlock();
return;
}
else
ErrorGen("Unable to lock window");
}
}
Error(window, "VIEW, BITMAP or CANVAS");
}
}
void YabInterface::DrawLine(double x1, double y1, double x2, double y2, const char* window)
{
YabView *myView = cast_as((BView*)viewList->GetView(window), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
YabDrawing *t = new YabDrawing();
t->command = 1;
t->x1 = x1; t->y1 = y1;
t->x2 = x2; t->y2 = y2;
t->p = yabPattern;
myView->drawList->AddItem(t);
double minx1 = x1<x2?x1:x2; double minx2 = x1<x2?x2:x1;
double miny1 = y1<y2?y1:y2; double miny2 = y1<y2?y2:y1;
myView->Invalidate(BRect(minx1,miny1,minx2,miny2));
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
{
for(int i=0; i<yabbitmaps->CountItems(); i++)
{
BBitmap *b = (BBitmap*)yabbitmaps->ItemAt(i);
BView *bview = b->FindView(window);
if(bview)
{
b->Lock();
bview->SetDrawingMode(B_OP_ALPHA);
bview->SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_COMPOSITE);
bview->StrokeLine(BPoint(x1,y1), BPoint(x2,y2), yabPattern);
bview->Sync();
b->Unlock();
return;
}
}
for(int i=0; i<yabcanvas->CountItems(); i++)
{
YabBitmapView *myView = (YabBitmapView*)yabcanvas->ItemAt(i);
if(!strcmp(myView->Name(), window))
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BBitmap *b = myView->GetBitmap();
BView *bView = myView->GetBitmapView();
b->Lock();
//bView->SetDrawingMode(B_OP_ALPHA);
//bView->SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_COMPOSITE);
bView->StrokeLine(BPoint(x1,y1), BPoint(x2,y2), yabPattern);
bView->Sync();
b->Unlock();
double minx1 = x1<x2?x1:x2; double minx2 = x1<x2?x2:x1;
double miny1 = y1<y2?y1:y2; double miny2 = y1<y2?y2:y1;
// myView->Invalidate(BRect(minx1,miny1,minx2,miny2));
myView->Draw(BRect(minx1,miny1,minx2,miny2));
w->Unlock();
return;
}
else
ErrorGen("Unable to lock window");
}
}
Error(window, "VIEW, BITMAP or CANVAS");
}
}
void YabInterface::DrawCircle(double x, double y, double r, const char* window)
{
YabView *myView = cast_as((BView*)viewList->GetView(window), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
YabDrawing *t = new YabDrawing();
if(drawStroking)
t->command = 2;
else
t->command = 3;
t->x1 = x; t->y1 = y;
t->x2 = r; t->y2 = r;
t->p = yabPattern;
myView->drawList->AddItem(t);
myView->Invalidate(BRect(x-r,y-r,x+r,y+r));
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
{
for(int i=0; i<yabbitmaps->CountItems(); i++)
{
BBitmap *b = (BBitmap*)yabbitmaps->ItemAt(i);
BView *bview = b->FindView(window);
if(bview)
{
b->Lock();
bview->SetDrawingMode(B_OP_ALPHA);
bview->SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_COMPOSITE);
if(drawStroking)
bview->StrokeEllipse(BPoint(x,y), r, r, yabPattern);
else
bview->FillEllipse(BPoint(x,y), r, r, yabPattern);
bview->Sync();
b->Unlock();
return;
}
}
for(int i=0; i<yabcanvas->CountItems(); i++)
{
YabBitmapView *myView = (YabBitmapView*)yabcanvas->ItemAt(i);
if(!strcmp(myView->Name(), window))
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BBitmap *b = myView->GetBitmap();
BView *bView = myView->GetBitmapView();
b->Lock();
// bView->SetDrawingMode(B_OP_ALPHA);
// bView->SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_COMPOSITE);
// bView->SetDrawingMode(B_OP_OVER);
if(drawStroking)
bView->StrokeEllipse(BPoint(x,y), r, r, yabPattern);
else
bView->FillEllipse(BPoint(x,y), r, r, yabPattern);
bView->Sync();
b->Unlock();
myView->Draw(BRect(x-r,y-r,x+r,y+r));
w->Unlock();
return;
}
else
ErrorGen("Unable to lock window");
}
}
Error(window, "VIEW, BITMAP or CANVAS");
}
}
void YabInterface::DrawEllipse(double x, double y, double r1, double r2, const char* window)
{
YabView *myView = cast_as((BView*)viewList->GetView(window), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
YabDrawing *t = new YabDrawing();
if(drawStroking)
t->command = 2;
else
t->command = 3;
t->x1 = x; t->y1 = y;
t->x2 = r1; t->y2 = r2;
t->p = yabPattern;
myView->drawList->AddItem(t);
myView->Invalidate(BRect(x-r1,y-r2,x+r1,y+r2));
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
{
for(int i=0; i<yabbitmaps->CountItems(); i++)
{
BBitmap *b = (BBitmap*)yabbitmaps->ItemAt(i);
BView *bview = b->FindView(window);
if(bview)
{
b->Lock();
bview->SetDrawingMode(B_OP_ALPHA);
bview->SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_COMPOSITE);
if(drawStroking)
bview->StrokeEllipse(BPoint(x,y), r1, r2, yabPattern);
else
bview->FillEllipse(BPoint(x,y), r1, r2, yabPattern);
bview->Sync();
b->Unlock();
return;
}
}
for(int i=0; i<yabcanvas->CountItems(); i++)
{
YabBitmapView *myView = (YabBitmapView*)yabcanvas->ItemAt(i);
if(!strcmp(myView->Name(), window))
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BBitmap *b = myView->GetBitmap();
BView *bView = myView->GetBitmapView();
b->Lock();
// bView->SetDrawingMode(B_OP_ALPHA);
// bView->SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_COMPOSITE);
if(drawStroking)
bView->StrokeEllipse(BPoint(x,y), r1, r2, yabPattern);
else
bView->FillEllipse(BPoint(x,y), r1, r2, yabPattern);
bView->Sync();
b->Unlock();
myView->Draw(BRect(x-r1,y-r2,x+r1,y+r2));
w->Unlock();
return;
}
else
ErrorGen("Unable to lock window");
}
}
Error(window, "VIEW, BITMAP or CANVAS");
}
}
void YabInterface::DrawCurve(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4, const char* window)
{
double invx1 = x1<x2?x1:x2; invx1 = invx1<x3?invx1:x3; invx1 = invx1<x4?invx1:x4;
double invx2 = x1>x2?x1:x2; invx2 = invx2>x3?invx2:x3; invx2 = invx2>x4?invx2:x4;
double invy1 = y1<y2?y1:y2; invy1 = invy1<y3?invy1:y3; invy1 = invy1<y4?invy1:y4;
double invy2 = y1>y2?y1:y2; invy2 = invy2>y3?invy2:y3; invy2 = invy2>y4?invy2:y4;
YabView *myView = cast_as((BView*)viewList->GetView(window), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
YabDrawing *t = new YabDrawing();
if(drawStroking)
t->command = 8;
else
t->command = 9;
t->x1 = x1; t->y1 = y1;
t->x2 = x2; t->y2 = y2;
t->x3 = x3; t->y3 = y3;
t->x4 = x4; t->y4 = y4;
t->p = yabPattern;
myView->drawList->AddItem(t);
myView->Invalidate(BRect(invx1,invy1,invx2,invy2));
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
{
for(int i=0; i<yabbitmaps->CountItems(); i++)
{
BBitmap *b = (BBitmap*)yabbitmaps->ItemAt(i);
BView *bview = b->FindView(window);
if(bview)
{
b->Lock();
bview->SetDrawingMode(B_OP_ALPHA);
bview->SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_COMPOSITE);
BPoint p[4];
p[0].Set(x1,y1);
p[1].Set(x2,y2);
p[2].Set(x3,y3);
p[3].Set(x4,y4);
if(drawStroking)
{
bview->SetPenSize(1.01);
bview->StrokeBezier(p, yabPattern);
bview->SetPenSize(1.0);
}
else
bview->FillBezier(p, yabPattern);
bview->Sync();
b->Unlock();
return;
}
}
for(int i=0; i<yabcanvas->CountItems(); i++)
{
YabBitmapView *myView = (YabBitmapView*)yabcanvas->ItemAt(i);
if(!strcmp(myView->Name(), window))
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BBitmap *b = myView->GetBitmap();
BView *bView = myView->GetBitmapView();
b->Lock();
// bView->SetDrawingMode(B_OP_ALPHA);
// bView->SetBlendingMode(B_PIXEL_ALPHA, B_ALPHA_COMPOSITE);
BPoint p[4];
p[0].Set(x1,y1);
p[1].Set(x2,y2);
p[2].Set(x3,y3);
p[3].Set(x4,y4);
if(drawStroking)
{
bView->SetPenSize(1.01);
bView->StrokeBezier(p, yabPattern);
bView->SetPenSize(1.0);
}
else
bView->FillBezier(p, yabPattern);
bView->Sync();
b->Unlock();
myView->Draw(BRect(invx1,invy1,invx2,invy2));
w->Unlock();
return;
}
else
ErrorGen("Unable to lock window");
}
}
Error(window, "VIEW, BITMAP or CANVAS");
}
}
void YabInterface::CreateText(double x, double y, const char* id, const char* text, const char* window)
{
YabView *myView = cast_as((BView*)viewList->GetView(window), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
double h,b;
b = be_plain_font->StringWidth(text)+1;
h = be_plain_font->Size();
BStringView *s = new BStringView(BRect(x,y-3,x+b,y+h-3), id, text);
s->ResizeToPreferred();
if(w->layout == -1)
s->SetResizingMode(B_FOLLOW_RIGHT|B_FOLLOW_BOTTOM);
else
s->SetResizingMode(w->layout);
s->SetFlags(B_WILL_DRAW|B_FULL_UPDATE_ON_RESIZE);
myView->AddChild(s);
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
Error(window, "VIEW");
}
void YabInterface::Text2(BRect frame, const char* id, const char* text, const char* window)
{
YabView *myView = cast_as((BView*)viewList->GetView(window), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BStringView *s = new BStringView(frame, id, text);
if(w->layout == -1)
s->SetResizingMode(B_FOLLOW_RIGHT|B_FOLLOW_BOTTOM);
else
s->SetResizingMode(w->layout);
s->SetFlags(B_WILL_DRAW|B_FULL_UPDATE_ON_RESIZE);
myView->AddChild(s);
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
Error(window, "VIEW");
}
void YabInterface::TextAlign(const char* txt, const char* option)
{
BString tmp(option);
alignment align;
if(tmp.IFindFirst("align-left")!=B_ERROR)
align = B_ALIGN_LEFT;
else if(tmp.IFindFirst("align-center")!=B_ERROR)
align = B_ALIGN_CENTER;
else if(tmp.IFindFirst("align-right")!=B_ERROR)
align = B_ALIGN_RIGHT;
else
ErrorGen("Unknown option");
YabView *myView = NULL;
BStringView *myStringView = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myStringView = cast_as(myView->FindView(txt), BStringView);
if(myStringView)
{
myStringView->SetAlignment(align);
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(txt, "TEXT");
}
void YabInterface::Slider(BRect frame, const char* id, const char* title, int min, int max, const char* view)
{
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BSlider *mySlider = new BSlider(frame, id, title, new BMessage(YABSLIDER), min, max);
if(w->layout == -1)
mySlider->SetResizingMode(B_FOLLOW_RIGHT|B_FOLLOW_BOTTOM);
else
mySlider->SetResizingMode(w->layout);
mySlider->SetFlags(B_WILL_DRAW|B_FULL_UPDATE_ON_RESIZE|B_NAVIGABLE);
myView->AddChild(mySlider);
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
Error(view, "VIEW");
}
void YabInterface::Slider(BRect frame, const char* id, const char* title, int min, int max, const char* option, const char* view)
{
BString tmp(option);
bool thumb = true, orient = true;
if(tmp.IFindFirst("vertical")!=B_ERROR)
orient = false;
if(tmp.IFindFirst("triangle")!=B_ERROR)
thumb = false;
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BSlider *mySlider = new BSlider(frame, id, title, new BMessage(YABSLIDER), min, max);
if(w->layout == -1)
mySlider->SetResizingMode(B_FOLLOW_RIGHT|B_FOLLOW_BOTTOM);
else
mySlider->SetResizingMode(w->layout);
mySlider->SetFlags(B_WILL_DRAW|B_FULL_UPDATE_ON_RESIZE|B_NAVIGABLE);
if(!orient)
{
mySlider->SetOrientation(B_VERTICAL);
mySlider->SetBarThickness(10);
}
if(!thumb) mySlider->SetStyle(B_TRIANGLE_THUMB);
myView->AddChild(mySlider);
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
Error(view, "VIEW");
}
void YabInterface::SetSlider(const char* id, const char* label1, const char* label2)
{
YabView *myView = NULL;
BSlider *mySlider = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
mySlider = cast_as(myView->FindView(id), BSlider);
if(mySlider)
{
mySlider->SetLimitLabels(label1, label2);
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(id, "SLIDER");
}
void YabInterface::SetSlider(const char* id, const char* bottomtop, int count)
{
hash_mark_location location = B_HASH_MARKS_BOTH;
BString tmp(bottomtop);
if(tmp.IFindFirst("none")!=B_ERROR)
location = B_HASH_MARKS_NONE;
if(tmp.IFindFirst("left")!=B_ERROR)
location = B_HASH_MARKS_LEFT;
if(tmp.IFindFirst("right")!=B_ERROR)
location = B_HASH_MARKS_RIGHT;
if(tmp.IFindFirst("top")!=B_ERROR)
location = B_HASH_MARKS_TOP;
if(tmp.IFindFirst("bottom")!=B_ERROR)
location = B_HASH_MARKS_BOTTOM;
YabView *myView = NULL;
BSlider *mySlider = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
mySlider = cast_as(myView->FindView(id), BSlider);
if(mySlider)
{
mySlider->SetHashMarks(location);
mySlider->SetHashMarkCount(count);
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(id, "SLIDER");
}
void YabInterface::SetSlider(const char* id, const char* part, int r, int g, int b)
{
bool barcolor = true;
BString tmp(part);
if(tmp.IFindFirst("fillcolor"))
barcolor = false;
YabView *myView = NULL;
BSlider *mySlider = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
mySlider = cast_as(myView->FindView(id), BSlider);
if(mySlider)
{
rgb_color rgb = {r,g,b,255};
if(barcolor)
mySlider->SetBarColor(rgb);
else
mySlider->UseFillColor(true,&rgb);
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(id, "SLIDER");
}
void YabInterface::SetSlider(const char* id, int value)
{
YabView *myView = NULL;
BSlider *mySlider = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
mySlider = cast_as(myView->FindView(id), BSlider);
if(mySlider)
{
mySlider->SetValue(value);
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(id, "SLIDER");
}
void YabInterface::SetOption(const char* id, const char* option, const char* value)
{
bool label = false;
BString tmpOption(option);
if(tmpOption.IFindFirst("label")!=B_ERROR)
label = true;
if(!label)
ErrorGen("Unknown option");
YabView *myView = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BControl *target = cast_as(myView->FindView(id), BControl);
if(target)
{
target->SetLabel(value);
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(id, "CONTROL");
}
void YabInterface::SetOption(const char* id, const char* option, int r, int g, int b)
{
YabView *myView = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BView *target = myView->FindView(id);
if(target)
{
rgb_color rgb = {r,g,b,0};
target->SetViewColor(rgb);
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(id, "VIEW");
}
void YabInterface::SetOption(const char* id, const char* option)
{
BString tmpOption(option);
if(tmpOption.IFindFirst("auto-resize")==B_ERROR)
ErrorGen("Unknown option");
YabView *myView = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BView *target = myView->FindView(id);
if(target)
{
target->ResizeToPreferred();
w->Unlock();
return;
}
w->Unlock();
}
}
}
ErrorGen("View not found");
}
void YabInterface::SetOption(const char* id, const char* option, int value)
{
BString tmpOption(option);
bool isFocus = false;
bool isEnabled = false;
bool isVisible = false;
if(tmpOption.IFindFirst("enabled")!=B_ERROR)
isEnabled = true;
if(tmpOption.IFindFirst("focus")!=B_ERROR)
isFocus = true;
if(tmpOption.IFindFirst("visible")!=B_ERROR)
isVisible = true;
if(!isFocus && !isEnabled && !isVisible)
ErrorGen("Unknown option");
YabView *myView = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BView *target = myView->FindView(id);
if(target)
{
if(isEnabled)
{
BControl *myControl = cast_as(target, BControl);
if(myControl)
myControl->SetEnabled(value);
else
{
BMenuField *myMenu = cast_as(target, BMenuField);
if(myMenu)
myMenu->SetEnabled(value);
else
Error(id, "CONTROL or DROPBOX");
}
}
if(isFocus)
{
target->MakeFocus(value);
}
if(isVisible)
{
BControl *myControl = cast_as(target, BControl);
if(myControl)
{
if(value)
{
if (myControl->IsHidden())
{
myControl->Show();
}
}
else
{
if (!myControl->IsHidden())
{
myControl->Hide();
}
}
}
}
w->Unlock();
return;
}
w->Unlock();
}
}
}
ErrorGen("View not found");
}
void YabInterface::DropZone(const char* view)
{
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView)
myView->dropZone = true;
else
Error(view, "VIEW");
}
void YabInterface::ColorControl(double x, double y, const char* id, const char* view)
{
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BColorControl *myCControl = new BColorControl(BPoint(x,y), B_CELLS_32x8, 2, id, new BMessage(YABCOLORCONTROL),false);
if(w->layout == -1)
myCControl->SetResizingMode(B_FOLLOW_RIGHT|B_FOLLOW_BOTTOM);
else
myCControl->SetResizingMode(w->layout);
myCControl->SetFlags(B_WILL_DRAW|B_FULL_UPDATE_ON_RESIZE|B_NAVIGABLE);
myView->AddChild(myCControl);
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
Error(view, "VIEW");
}
void YabInterface::ColorControl(const char* id, int r, int g, int b)
{
YabView *myView = NULL;
BColorControl *myCControl = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myCControl = cast_as(myView->FindView(id), BColorControl);
if(myCControl)
{
rgb_color t = {r,g,b,255};
myCControl->SetValue(t);
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(id, "COLORCONTROL");
}
void YabInterface::TextControl(const char* id, const char* text)
{
YabView *myView = NULL;
BTextControl *myTControl = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myTControl = cast_as(myView->FindView(id), BTextControl);
if(myTControl)
{
myTControl->SetText(text);
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(id, "TEXTCONTROL");
}
void YabInterface::TextControl(const char* id, int mode)
{
YabView *myView = NULL;
BTextControl *myTControl = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myTControl = cast_as(myView->FindView(id), BTextControl);
if(myTControl)
{
BTextView *myTView = myTControl->TextView();
switch(mode)
{
case 1:
myTView->HideTyping(true);
break;
default:
myTView->HideTyping(false);
break;
}
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(id, "TEXTCONTROL");
}
void YabInterface::TextControl(const char* id, const char* option, const char* value)
{
YabView *myView = NULL;
BString tmpOption(option);
BString tmpValue(value);
BTextControl *myTControl = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
int32 x=0;
myTControl = cast_as(myView->FindView(id), BTextControl);
if(myTControl)
{
BTextView *myTView = myTControl->TextView();
if(tmpOption.IFindFirst("focus")!=B_ERROR)
{
if(tmpValue.IFindFirst("true")!=B_ERROR)
{
bool focused = true;
int32 ofset=0;
myTControl -> MakeFocus(focused);
myTView-> Select(ofset,ofset);
}
if(tmpValue.IFindFirst("false")!=B_ERROR)
{
bool focused = false;
myTControl -> MakeFocus(focused);
}
}
if(tmpOption.IFindFirst("Curser")!=B_ERROR || tmpOption.IFindFirst("Cursor")!=B_ERROR )
{
const char* str_int = tmpValue.String();
bool focused = true;
int32 ofset=0;
ofset= atoi(str_int);
myTControl -> MakeFocus(focused);
myTView-> Select(ofset,ofset);
}
if(tmpOption.IFindFirst("type")!=B_ERROR)
{
if(tmpValue.IFindFirst("number")!=B_ERROR)
{
//Changing from for to String Method because it was possible to enter äöü and so on
//20.02.2019 Lorent Glaser
/*for (x=0;x<48; x++)
{
myTView->DisallowChar(x);
}
for (x=58;x<128; x++)
{
myTView->DisallowChar(x);
}
x=46;
myTView-> AllowChar(x);*/
BString string("QWERTYUIOP[]\\ASDFGHJKL;'ZXCVBNM,/qwertyuiop{}| "
"asdfghjkl:\"zxcvbnm<>?!@#$%^&*()-_=+`´°~\röäüÖÄÜß");
for(int32 i=0; i<string.CountChars(); i++)
{
char c=string.ByteAt(i);
myTView->DisallowChar(c);
}
}
if(tmpValue.IFindFirst("alphanumeric")!=B_ERROR)
{
for (x=0;x<128; x++)
{
myTView->AllowChar(x);
}
}
}
if(tmpOption.IFindFirst("align")!=B_ERROR)
{
if(tmpValue.IFindFirst("right")!=B_ERROR)
{
myTControl->SetAlignment(B_ALIGN_LEFT,B_ALIGN_RIGHT);
}
if(tmpValue.IFindFirst("center")!=B_ERROR)
{
myTControl->SetAlignment(B_ALIGN_LEFT,B_ALIGN_CENTER);
}
if(tmpValue.IFindFirst("left")!=B_ERROR)
{
myTControl->SetAlignment(B_ALIGN_LEFT,B_ALIGN_LEFT);
}
}
if(tmpOption.IFindFirst("length")!=B_ERROR)
{
const char* str_int = tmpValue.String();
int i = atoi(str_int);
if (i>0)
{
myTView->SetMaxBytes(i);
myTView->SetFontAndColor(be_fixed_font);
}
if (i=0)
{
ErrorGen("Bad length");
}
}
if(tmpOption.IFindFirst("exclude")!=B_ERROR)
{
int i;
for (i=0; i<= tmpValue.CountChars();i++)
{
x=tmpValue.ByteAt(i);
myTView->DisallowChar(x);
}
}
if(tmpOption.IFindFirst("include")!=B_ERROR)
{
int i;
for (i=0; i<= tmpValue.CountChars();i++)
{
x=tmpValue.ByteAt(i);
myTView->AllowChar(x);
}
}
}
w->Unlock();
return;
}
w->Unlock();
}
}
Error(id, "TEXTCONTROL");
}
void YabInterface::TextControl(const char* id)
{
YabView *myView = NULL;
BTextControl *myTControl = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myTControl = cast_as(myView->FindView(id), BTextControl);
if(myTControl)
{
myTControl->SetText("");
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(id, "TEXTCONTROL");
}
void YabInterface::CreateAlert(const char* text, const char* button1, const char* option)
{
alert_type tmp;
BString typ(option);
tmp = B_EMPTY_ALERT;
if(typ.IFindFirst("info")!=B_ERROR) tmp = B_INFO_ALERT;
else if(typ.IFindFirst("idea")!=B_ERROR) tmp = B_IDEA_ALERT;
else if(typ.IFindFirst("warning")!=B_ERROR) tmp = B_WARNING_ALERT;
else if(typ.IFindFirst("stop")!=B_ERROR) tmp = B_STOP_ALERT;
(new BAlert("Alert!",text,button1,NULL,NULL,B_WIDTH_AS_USUAL,tmp))->Go();
}
const char* YabInterface::LoadFilePanel(const char *mode, const char* title, const char* directory)
{
int myMode = -1;
BString opt(mode);
if(opt.IFindFirst("Load-File")!=B_ERROR)
myMode = 0;
if(opt.IFindFirst("Save-File")!=B_ERROR)
myMode = 1;
if(opt.IFindFirst("Load-Directory")!=B_ERROR)
myMode = 2;
if(opt.IFindFirst("Load-File-and-Directory")!=B_ERROR)
myMode = 3;
if(myMode == -1) ErrorGen("Invalid Option");
YabFilePanel tmp;
BPath path;
BString myTitle(title);
BEntry *entry = tmp.MyFilePanel(myTitle.String(),directory, "", myMode);
entry->GetPath(&path);
if(myMode != 1 && !entry->Exists())
loadPanel[0] = '\0';
else
{
if(path.InitCheck() == B_OK)
strcpy(loadPanel,path.Path());
else
loadPanel[0] = '\0';
}
delete entry;
return (const char*)loadPanel;
}
const char* YabInterface::SaveFilePanel(const char *mode, const char* title, const char* directory, const char* filename)
{
int myMode = -1;
BString opt(mode);
if(opt.IFindFirst("Load-File")!=B_ERROR)
myMode = 0;
if(opt.IFindFirst("Save-File")!=B_ERROR)
myMode = 1;
if(opt.IFindFirst("Load-Directory")!=B_ERROR)
myMode = 2;
if(opt.IFindFirst("Load-File-and-Directory")!=B_ERROR)
myMode = 3;
if(myMode == -1) ErrorGen("Invalid Option");
YabFilePanel tmp;
BPath path;
BString myTitle(title);
BEntry *entry = tmp.MyFilePanel(myTitle.String(),directory, filename, myMode);
entry->GetPath(&path);
if(myMode != 1 && !entry->Exists())
loadPanel[0] = '\0';
else
{
if(path.InitCheck() == B_OK)
strcpy(loadPanel,path.Path());
else
loadPanel[0] = '\0';
}
delete entry;
return (const char*)loadPanel;
}
void YabInterface::SetLayout(const char* layout, const char* window)
{
BString tmp(layout);
YabView *myView = cast_as((BView*)viewList->GetView(window), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
if(tmp.IFindFirst("standard")!=B_ERROR)
w->layout = -1;
else if(tmp.IFindFirst("all")!=B_ERROR)
w->layout = B_FOLLOW_ALL;
else if(tmp.IFindFirst("none")!=B_ERROR)
w->layout = B_FOLLOW_NONE;
else
{
uint32 horizontal, vertical;
if(tmp.IFindFirst("h-center")!=B_ERROR)
horizontal = B_FOLLOW_H_CENTER;
else if((tmp.IFindFirst("left")!=B_ERROR)&&(tmp.IFindFirst("right")!=B_ERROR))
horizontal = B_FOLLOW_LEFT_RIGHT;
else if(tmp.IFindFirst("right")!=B_ERROR)
horizontal = B_FOLLOW_RIGHT;
else
horizontal = B_FOLLOW_LEFT;
if(tmp.IFindFirst("v-center")!=B_ERROR)
vertical = B_FOLLOW_V_CENTER;
else if((tmp.IFindFirst("top")!=B_ERROR)&&(tmp.IFindFirst("bottom")!=B_ERROR))
vertical = B_FOLLOW_TOP_BOTTOM;
else if(tmp.IFindFirst("bottom")!=B_ERROR)
vertical = B_FOLLOW_BOTTOM;
else
vertical = B_FOLLOW_TOP;
w->layout = horizontal|vertical;
}
}
else
ErrorGen("Unable to lock window");
}
else
Error(window, "VIEW");
}
void YabInterface::WindowSet(const char* option, const char* value, const char* window)
{
BString tmp(option);
BString val(value);
uint32 flags = 0;
YabView *myView = cast_as((BView*)viewList->GetView(window), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
if(tmp.IFindFirst("Flags")!=B_ERROR)
{
if(val.IFindFirst("Reset")!=B_ERROR)
{
w->SetFlags(0);
w->SetFlags(B_ASYNCHRONOUS_CONTROLS);
}
else
{
flags = w->Flags();
if(val.IFindFirst("Not-Movable")!=B_ERROR)
flags = flags|B_NOT_MOVABLE;
if(val.IFindFirst("Not-Closable")!=B_ERROR)
flags = flags|B_NOT_CLOSABLE;
if(val.IFindFirst("Not-Zoomable")!=B_ERROR)
flags = flags|B_NOT_ZOOMABLE;
if(val.IFindFirst("Not-Minimizable")!=B_ERROR)
flags = flags|B_NOT_MINIMIZABLE;
if(val.IFindFirst("Not-Resizable")!=B_ERROR)
flags = flags|B_NOT_RESIZABLE;
if(val.IFindFirst("Not-H-Resizable")!=B_ERROR)
flags = flags|B_NOT_H_RESIZABLE;
if(val.IFindFirst("Not-V-Resizable")!=B_ERROR)
flags = flags|B_NOT_V_RESIZABLE;
if(val.IFindFirst("Accept-First-Click")!=B_ERROR)
flags = flags|B_WILL_ACCEPT_FIRST_CLICK;
if(val.IFindFirst("No-Workspace-Activation")!=B_ERROR)
flags = flags|B_NO_WORKSPACE_ACTIVATION;
w->SetFlags(flags|B_ASYNCHRONOUS_CONTROLS);
}
}
else if(tmp.IFindFirst("Look")!=B_ERROR)
{
if(val.IFindFirst("Document")!=B_ERROR)
w->SetLook(B_DOCUMENT_WINDOW_LOOK);
else if(val.IFindFirst("Titled")!=B_ERROR)
w->SetLook(B_TITLED_WINDOW_LOOK);
else if(val.IFindFirst("Floating")!=B_ERROR)
w->SetLook(B_FLOATING_WINDOW_LOOK);
else if(val.IFindFirst("Modal")!=B_ERROR)
w->SetLook(B_MODAL_WINDOW_LOOK);
else if(val.IFindFirst("Bordered")!=B_ERROR)
w->SetLook(B_BORDERED_WINDOW_LOOK);
else if(val.IFindFirst("No-Border")!=B_ERROR)
w->SetLook(B_NO_BORDER_WINDOW_LOOK);
else
ErrorGen("Unknown option");
}
else if(tmp.IFindFirst("Feel")!=B_ERROR)
{
if(val.IFindFirst("Normal")!=B_ERROR)
w->SetFeel(B_NORMAL_WINDOW_FEEL);
else if(val.IFindFirst("Modal-App")!=B_ERROR)
w->SetFeel(B_MODAL_APP_WINDOW_FEEL);
else if(val.IFindFirst("Modal-All")!=B_ERROR)
w->SetFeel(B_MODAL_ALL_WINDOW_FEEL);
else if(val.IFindFirst("Floating-App")!=B_ERROR)
w->SetFeel(B_FLOATING_APP_WINDOW_FEEL);
else if(val.IFindFirst("Floating-All")!=B_ERROR)
w->SetFeel(B_FLOATING_ALL_WINDOW_FEEL);
else
ErrorGen("Unknown option");
}
else if(tmp.IFindFirst("Workspace")!=B_ERROR)
{
if(val.IFindFirst("Current")!=B_ERROR)
w->SetWorkspaces(B_CURRENT_WORKSPACE);
else if(val.IFindFirst("All")!=B_ERROR)
w->SetWorkspaces(B_ALL_WORKSPACES);
else if(atoi(val.String()) >= 1)
{
int bit = 1 << atoi(val.String()) - 1;
w->SetWorkspaces(bit);
}
else
ErrorGen("Unknown option");
}
else if(tmp.IFindFirst("Title")!=B_ERROR)
{
w->SetTitle(value);
}
else
ErrorGen("Unknown option");
// w->UpdateIfNeeded();
}
else
ErrorGen("Unable to lock window");
}
else
Error(window, "VIEW");
}
void YabInterface::WindowSet(const char* option, const char* window)
{
BString tmp(option);
uint32 flags = 0;
YabView *myView = cast_as((BView*)viewList->GetView(window), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
if(tmp.IFindFirst("maximize")!=B_ERROR)
w->Zoom();
else if(tmp.IFindFirst("minimize")!=B_ERROR)
w->Minimize(!w->IsMinimized());
else if(tmp.IFindFirst("deactivate")!=B_ERROR)
w->Activate(false);
else if(tmp.IFindFirst("activate")!=B_ERROR)
w->Activate(true);
else if(tmp.IFindFirst("disable-updates")!=B_ERROR)
w->DisableUpdates();
else if(tmp.IFindFirst("enable-updates")!=B_ERROR)
w->EnableUpdates();
else
ErrorGen("Unknown option");
}
else
ErrorGen("Unable to lock window");
}
else
Error(window, "VIEW");
}
void YabInterface::WindowSet(const char* option, int r, int g, int b, const char* window)
{
BString tmp(option);
if(r>255) r=255; if(r<0) r=0;
if(g>255) g=255; if(g<0) g=0;
if(b>255) b=255; if(b<0) b=0;
YabView *myView = cast_as((BView*)viewList->GetView(window), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
if(tmp.IFindFirst("BGColor")!=B_ERROR)
{
myView->SetViewColor(r,g,b,yabAlpha);
myView->Invalidate();
}
else if(tmp.IFindFirst("HighColor")!=B_ERROR)
{
if(yabAlpha == 255)
myView->SetDrawingMode(B_OP_COPY);
else
myView->SetDrawingMode(B_OP_ALPHA);
myView->SetHighColor(r,g,b,yabAlpha);
YabDrawing *t = new YabDrawing();
t->command = 6;
t->r = r; t->g = g;
t->b = b; t->alpha = yabAlpha;
myView->drawList->AddItem(t);
}
else if(tmp.IFindFirst("LowColor")!=B_ERROR)
{
if(yabAlpha == 255)
myView->SetDrawingMode(B_OP_COPY);
else
myView->SetDrawingMode(B_OP_ALPHA);
myView->SetLowColor(r,g,b,yabAlpha);
YabDrawing *t = new YabDrawing();
t->command = 7;
t->r = r; t->g = g;
t->b = b; t->alpha = yabAlpha;
myView->drawList->AddItem(t);
}
else
ErrorGen("Unknown option");
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
{
for(int i=0; i<yabbitmaps->CountItems(); i++)
{
BBitmap *bmp = (BBitmap*)yabbitmaps->ItemAt(i);
BView *bView = bmp->FindView(window);
if(bView)
{
if(tmp.IFindFirst("HighColor")!=B_ERROR)
{
bmp->Lock();
if(yabAlpha == 255)
bView->SetDrawingMode(B_OP_COPY);
else
bView->SetDrawingMode(B_OP_ALPHA);
bView->SetHighColor(r,g,b,yabAlpha);
bView->Sync();
bmp->Unlock();
return;
}
else if(tmp.IFindFirst("LowColor")!=B_ERROR)
{
bmp->Lock();
if(yabAlpha == 255)
bView->SetDrawingMode(B_OP_COPY);
else
bView->SetDrawingMode(B_OP_ALPHA);
bView->SetLowColor(r,g,b,yabAlpha);
bView->Sync();
bmp->Unlock();
return;
}
else
ErrorGen("Unknown option");
}
}
for(int i=0; i<yabcanvas->CountItems(); i++)
{
YabBitmapView *myView = (YabBitmapView*)yabcanvas->ItemAt(i);
if(!strcmp(myView->Name(), window))
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BBitmap *bmp = myView->GetBitmap();
BView *bView = myView->GetBitmapView();
if(tmp.IFindFirst("HighColor")!=B_ERROR)
{
bmp->Lock();
if(yabAlpha == 255)
bView->SetDrawingMode(B_OP_COPY);
else
bView->SetDrawingMode(B_OP_ALPHA);
bView->SetHighColor(r,g,b,yabAlpha);
bView->Sync();
bmp->Unlock();
w->Unlock();
return;
}
else if(tmp.IFindFirst("LowColor")!=B_ERROR)
{
bmp->Lock();
if(yabAlpha == 255)
bView->SetDrawingMode(B_OP_COPY);
else
bView->SetDrawingMode(B_OP_ALPHA);
bView->SetLowColor(r,g,b,yabAlpha);
bView->Sync();
bmp->Unlock();
w->Unlock();
return;
}
else
ErrorGen("Unknown option");
}
else
ErrorGen("Unable to lock window");
}
}
Error(window, "VIEW, BITMAP or CANVAS");
}
}
void YabInterface::WindowSet(const char* option, double x, double y, const char* window)
{
BString tmp(option);
YabView *myView = cast_as((BView*)viewList->GetView(window), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
if(tmp.IFindFirst("ResizeTo")!=B_ERROR)
w->ResizeTo(x,y);
else if(tmp.IFindFirst("MoveTo")!=B_ERROR)
w->MoveTo(x,y);
else if(tmp.IFindFirst("MinimumTo")!=B_ERROR)
{
float x1, x2, y1, y2;
w->GetSizeLimits(&x1,&x2,&y1,&y2);
w->SetSizeLimits((float)x,x2,(float)y,y2);
}
else if(tmp.IFindFirst("MaximumTo")!=B_ERROR)
{
float x1, x2, y1, y2;
w->GetSizeLimits(&x1,&x2,&y1,&y2);
w->SetSizeLimits(x1,(float)x,y1,(float)y);
}
else
ErrorGen("Unknown option");
w->Unlock();
// w->UpdateIfNeeded();
}
else
ErrorGen("Unable to lock window");
}
else
Error(window, "VIEW");
}
void YabInterface::WindowClear(const char* window)
{
bool delMenuBar;
YabView *myView = cast_as((BView*)viewList->GetView(window), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w && myView->Parent())
{
w->Lock();
BView *child, *oldchild;
if(child = myView->ChildAt(0))
{
while(child)
{
CleanupYabTabView(child);
if(is_kind_of(child, YabBitmapView))
yabcanvas->RemoveItem(child);
CleanupSubchildView(child->ChildAt(0));
if(viewList->GetView(child->Name()))
{
RemoveView(child);
viewList->DelView(child->Name());
}
oldchild = child;
child = child->NextSibling();
if(is_kind_of(oldchild, YabView))
DrawClear(oldchild->Name(), true);
if(is_kind_of(oldchild, BMenuBar))
{
oldchild->Hide();
}
oldchild->RemoveSelf();
delete oldchild;
}
}
if(is_kind_of(myView, YabView))
DrawClear(myView->Name(), true);
if(is_kind_of(myView, BMenuBar))
myView->Hide();
BBox *box = cast_as(myView->Parent(), BBox);
myView->RemoveSelf();
delete myView;
viewList->DelView(window);
if(box)
{
box->RemoveSelf();
delete box;
}
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
Error(window, "VIEW");
}
void YabInterface::RemoveView(BView *myView)
{
BView *child, *oldchild;
if(child = myView->ChildAt(0))
while(child)
{
CleanupYabTabView(child);
if(is_kind_of(child, YabBitmapView))
yabcanvas->RemoveItem(child);
CleanupSubchildView(child->ChildAt(0));
if(viewList->GetView(child->Name()))
{
RemoveView(child);
viewList->DelView(child->Name());
}
oldchild = child;
child = child->NextSibling();
if(is_kind_of(oldchild, YabView))
DrawClear(oldchild->Name(), true);
if(is_kind_of(oldchild, BMenuBar))
oldchild->Hide();
if(is_kind_of(oldchild, BMenuBar))
{
BMenuBar *b = cast_as(oldchild, BMenuBar);
for(int i=0; i<b->CountItems(); i++)
{
YabMenu *m = (YabMenu*)b->SubmenuAt(i);
if(m)
{
// check for subsubmenus
for(int j=0; j<m->CountItems(); j++)
{
YabMenu *n = (YabMenu*)m->SubmenuAt(j);
if(n) n->MyHide();
}
m->MyHide();
// printf("hiden\n");
}
}
b->Hide();
}
oldchild->RemoveSelf();
delete oldchild;
}
}
void YabInterface::CleanupYabTabView(BView* view)
{
if(view == NULL || viewList == NULL) return;
if(is_kind_of(view, YabTabView)) {
YabTabView* tabView = static_cast<YabTabView*>(view);
for(int i = 0; i < tabView->CountTabs(); i++)
{
YabView *t = static_cast<YabView*>(tabView->TabAt(i)->View());
RemoveView(t);
viewList->DelView(t->NameForTabView());
}
}
}
void YabInterface::CleanupSubchildView(BView* view)
{
if(view == NULL || viewList == NULL) return;
while(view)
{
CleanupYabTabView(view);
if(viewList->GetView(view->Name()))
{
RemoveView(view);
viewList->DelView(view->Name());
}
view = view->NextSibling();
}
}
void YabInterface::TextEdit(BRect frame, const char* title, int scrollbar, const char* window)
{
YabView *myView = cast_as((BView*)viewList->GetView(window), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
uint32 resizeMode;
BRect textframe;
w->Lock();
if(scrollbar == 3 || scrollbar == 1) frame.right -= B_V_SCROLL_BAR_WIDTH;
if(scrollbar>2) frame.bottom -= B_H_SCROLL_BAR_HEIGHT;
textframe = frame;
textframe.OffsetTo(B_ORIGIN);
textframe.right -=2;
textframe.bottom -=2;
textframe.top +=2;
textframe.left +=2;
if(w->layout == -1)
resizeMode = B_FOLLOW_ALL;
else
resizeMode = w->layout;
// BTextView *txtView = new BTextView(frame, title, textframe, B_FOLLOW_ALL_SIDES, B_WILL_DRAW|B_PULSE_NEEDED|B_NAVIGABLE);
YabText *txtView = new YabText(frame, title, textframe, B_FOLLOW_ALL_SIDES, B_WILL_DRAW|B_PULSE_NEEDED|B_NAVIGABLE);
txtView->SetWordWrap(true);
// txtView->SetFontAndColor(be_fixed_font);
switch(scrollbar)
{
case 3: // both
myView->AddChild(new BScrollView("scroll_list", txtView, resizeMode, B_WILL_DRAW|B_FULL_UPDATE_ON_RESIZE, true, true));
break;
case 2: // horizontal
myView->AddChild(new BScrollView("scroll_list", txtView, resizeMode, B_WILL_DRAW|B_FULL_UPDATE_ON_RESIZE, true, false));
break;
case 0: // none
myView->AddChild(txtView);
break;
default: // vertical is default
myView->AddChild(new BScrollView("scroll_list", txtView, resizeMode, B_WILL_DRAW|B_FULL_UPDATE_ON_RESIZE, false, true));
break;
}
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
Error(window, "VIEW");
}
void YabInterface::TextAdd(const char* title, const char* text)
{
YabView *myView = NULL;
YabText *myText = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(),YabWindow);
if(w)
{
w->Lock();
myText = cast_as(myView->FindView(title),YabText);
if(myText)
{
myText->Insert(text);
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(title, "TEXTEDIT");
}
void YabInterface::TextSet(const char* title, const char* option)
{
BString tmp(option);
YabView *myView = NULL;
YabText *myText = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(),YabWindow);
if(w)
{
w->Lock();
myText = cast_as(myView->FindView(title),YabText);
if(myText)
{
if(tmp.IFindFirst("Cut")!=B_ERROR)
myText->Cut(be_clipboard);
else if(tmp.IFindFirst("Copy")!=B_ERROR)
{
int32 a,b;
myText->GetSelection(&a, &b);
if(a != b)
myText->Copy(be_clipboard);
}
else if(tmp.IFindFirst("Paste")!=B_ERROR)
myText->Paste(be_clipboard);
else if(tmp.IFindFirst("Clear")!=B_ERROR)
myText->Clear();
else if(tmp.IFindFirst("Select-All")!=B_ERROR)
myText->SelectAll();
else if(tmp.IFindFirst("Undo")!=B_ERROR)
myText->Undo(be_clipboard);
else if(tmp.IFindFirst("Redo")!=B_ERROR)
// myText->Redo(be_clipboard);
;
else
ErrorGen("Unknown option");
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(title, "TEXTEDIT");
}
void YabInterface::TextSet(const char* title, const char* option, const char* value)
{
YabView *myView = NULL;
YabText *myText = NULL;
BString tmp(option);
BString tmp2(value);
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(),YabWindow);
if(w)
{
w->Lock();
myText = cast_as(myView->FindView(title),YabText);
if(myText)
{
if(tmp.IFindFirst("align")!=B_ERROR)
{
if(tmp2.IFindFirst("left")!=B_ERROR)
myText->SetAlignment(B_ALIGN_LEFT);
else if(tmp2.IFindFirst("center")!=B_ERROR)
myText->SetAlignment(B_ALIGN_CENTER);
else if(tmp2.IFindFirst("right")!=B_ERROR)
myText->SetAlignment(B_ALIGN_RIGHT);
}
else if(tmp.IFindFirst("fixed")!=B_ERROR)
{
const char* str_int = tmp2.String();
int i = atoi(str_int);
if (i>6)
{
BFont myFont=(be_fixed_font);
int myFontSize = i;
myFont.SetSize(myFontSize);
int TL = myText->TextLength();
const rgb_color Textcolor = {0,0,0,255};
myText->SetFontAndColor(0,TL,&myFont,B_FONT_ALL,&Textcolor);
}
}
else if(tmp.IFindFirst("plain")!=B_ERROR)
{
const char* str_int = tmp2.String();
int i = atoi(str_int);
if (i>6)
{
BFont myFont=(be_plain_font);
int myFontSize = i;
myFont.SetSize(myFontSize);
int TL = myText->TextLength();
const rgb_color Textcolor = {0,0,0,255};
myText->SetFontAndColor(0,TL,&myFont,B_FONT_ALL,&Textcolor);
}
}
else if(tmp.IFindFirst("bold")!=B_ERROR)
{
const char* str_int = tmp2.String();
int i = atoi(str_int);
if (i>6)
{
BFont myFont=(be_bold_font);
int myFontSize = i;
myFont.SetSize(myFontSize);
int TL = myText->TextLength();
const rgb_color Textcolor = {0,0,0,255};
myText->SetFontAndColor(0,TL,&myFont,B_FONT_ALL,&Textcolor);
}
}
else if(tmp.IFindFirst("autocomplete")!=B_ERROR)
myText->AddWord(new BString(value));
else if(tmp.IFindFirst("font")!=B_ERROR)
{
BFont myFont;
BString opt;
// Font family
int pos1 = 0;
int pos2 = tmp2.FindFirst(',');
if(pos2 != B_ERROR)
{
tmp2.CopyInto(opt, pos1, pos2-pos1);
while(opt[0] == ' ') opt.RemoveFirst(" ");
while(opt[opt.Length()-1] == ' ') opt.RemoveLast(" ");
font_family fam;
sprintf((char*)fam, "%s" , opt.String());
if(myFont.SetFamilyAndFace(fam, B_REGULAR_FACE) == B_OK)
{
myView->SetFont(&myFont, B_FONT_FAMILY_AND_STYLE);
// Font style
pos1 = pos2+1;
pos2 = tmp2.FindFirst(',', pos2+1);
if(pos2 != B_ERROR)
{
tmp2.CopyInto(opt, pos1, pos2-pos1);
while(opt[0] == ' ') opt.RemoveFirst(" ");
while(opt[opt.Length()-1] == ' ') opt.RemoveLast(" ");
font_style style;
sprintf((char*)style, "%s" , opt.String());
if(myFont.SetFamilyAndStyle(fam,style) == B_OK)
{
// Font size
pos1 = pos2+1;
pos2 = tmp2.FindFirst(',', pos2+1);
if(pos2 == B_ERROR) pos2 = tmp2.Length();
tmp2.CopyInto(opt, pos1, pos2-pos1);
while(opt[0] == ' ') opt.RemoveFirst(" ");
while(opt[opt.Length()-1] == ' ') opt.RemoveLast(" ");
double size = atof(opt.String());
myFont.SetSize(size);
}
}
}
}
else if(tmp2.IFindFirst("system-plain")!=B_ERROR)
myFont = be_plain_font;
else if(tmp2.IFindFirst("system-fixed")!=B_ERROR)
myFont = be_fixed_font;
else if(tmp2.IFindFirst("system-bold")!=B_ERROR)
myFont = be_bold_font;
else
ErrorGen("Unknown option");
int32 start,finish;
myText->GetSelection(&start, &finish);
myText->SelectAll();
myText->SetFontAndColor(&myFont);
myText->Select(start,finish);
}
else if (tmp.IFindFirst("focus")!=B_ERROR)
{
if (tmp2.IFindFirst("true")!=B_ERROR)
{
bool focused = true;
myText->MakeFocus(focused);
}
else
{
bool focused = false;
myText->MakeFocus(focused);
}
}
else
ErrorGen("Unknown option");
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(title, "TEXTEDIT");
}
void YabInterface::TextSet(const char* title, const char* option, int value)
{
YabView *myView = NULL;
YabText *myText = NULL;
BString tmp(option);
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(),YabWindow);
if(w)
{
w->Lock();
myText = cast_as(myView->FindView(title),YabText);
if(myText)
{
if(tmp.IFindFirst("autocomplete-start")!=B_ERROR)
myText->SetAutoCompleteStart(value-1);
else if(tmp.IFindFirst("has-autocompletion")!=B_ERROR)
myText->HasAutoCompletion((bool)value);
else if(tmp.IFindFirst("autoindent")!=B_ERROR)
myText->SetAutoindent((bool)value);
else if(tmp.IFindFirst("wordwrap")!=B_ERROR)
myText->SetWordWrap((bool)value);
else if(tmp.IFindFirst("editable")!=B_ERROR)
myText->MakeEditable((bool)value);
else if(tmp.IFindFirst("color-case-sensitive")!=B_ERROR)
myText->SetCaseSensitive((bool)value);
else if(tmp.IFindFirst("tabwidth")!=B_ERROR)
myText->SetTabWidth(value);
else if(tmp.IFindFirst("cursor")!=B_ERROR)
myText->Select(value, value);
else if(tmp.IFindFirst("textwidth")!=B_ERROR)
{
// BRect txtframe = myText->TextRect();
// txtframe.right = txtframe.left + value;
// myText->SetTextRect(txtframe);
myText->SetTextRect(BRect(0,0, value,1));
// BRect txtbounds = myText->Bounds();
// myText->FrameResized(txtbounds.Width(), txtbounds.Height());
BRect bounds(myText->Bounds());
BScrollBar* horizontalScrollBar = myText->ScrollBar(B_HORIZONTAL);
// do we have a horizontal scroll bar?
if (horizontalScrollBar != NULL) {
long viewWidth = bounds.IntegerWidth();
long dataWidth = (long)value;
long maxRange = dataWidth - viewWidth;
maxRange = max_c(maxRange, 0);
horizontalScrollBar->SetRange(0, 1000); //(float)maxRange);
// horizontalScrollBar->SetProportion((float)viewWidth / (float)dataWidth);
// horizontalScrollBar->SetSteps(10.0, dataWidth / 10);
// std::cout << "dataWidth: " << dataWidth << " maxrange: " << maxRange << std::endl;
}
}
else if(tmp.IFindFirst("gotoline")!=B_ERROR)
{
if(value<1) value = 1;
myText->GoToLine(value-1);
myText->ScrollToSelection();
}
else if(tmp.IFindFirst("select")!=B_ERROR)
{
int start, num;
if(value <= 0)
myText->Select(0,0);
else
{
if(value-1 == 0)
start = 0;
else
start = myText->OffsetAt(value-1);
if(myText->CountLines()>value)
num = myText->OffsetAt(value)-start-1;
else
num = myText->OffsetAt(value)-start;
// num = myText->TextLength()-start;
myText->Select(start,start+num);
myText->ScrollToSelection();
}
}
else if(tmp.IFindFirst("changed")!=B_ERROR)
myText->SetChanged((bool)value);
else
ErrorGen("Unknown option");
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(title, "TEXTEDIT");
}
void YabInterface::TextColor(const char* title, const char* option, const char* command)
{
YabView *myView = NULL;
YabText *myText = NULL;
BString tmp(option);
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(),YabWindow);
if(w)
{
w->Lock();
myText = cast_as(myView->FindView(title),YabText);
if(myText)
{
if(tmp.IFindFirst("Color1")!=B_ERROR)
myText->AddCommand(command,0);
else if(tmp.IFindFirst("Color2")!=B_ERROR)
myText->AddCommand(command,1);
else if(tmp.IFindFirst("Color3")!=B_ERROR)
myText->AddCommand(command,2);
else if(tmp.IFindFirst("Color4")!=B_ERROR)
myText->AddCommand(command,3);
else if(tmp.IFindFirst("char-color")!=B_ERROR)
myText->AddCommand(command,4);
else
ErrorGen("Unknown option");
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(title, "TEXTEDIT");
}
void YabInterface::TextColor(const char* title, const char* option, int r, int g, int b)
{
YabView *myView = NULL;
YabText *myText = NULL;
BString tmp(option);
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(),YabWindow);
if(w)
{
w->Lock();
myText = cast_as(myView->FindView(title),YabText);
if(myText)
{
if(tmp.IFindFirst("color1")!=B_ERROR)
myText->SetColors(0,r,g,b);
else if(tmp.IFindFirst("color2")!=B_ERROR)
myText->SetColors(1,r,g,b);
else if(tmp.IFindFirst("color3")!=B_ERROR)
myText->SetColors(2,r,g,b);
else if(tmp.IFindFirst("color4")!=B_ERROR)
myText->SetColors(3,r,g,b);
else if(tmp.IFindFirst("char-color")!=B_ERROR)
myText->SetColors(4,r,g,b);
else if(tmp.IFindFirst("bgcolor")!=B_ERROR)
myText->SetColors(5,r,g,b);
else if(tmp.IFindFirst("textcolor")!=B_ERROR)
myText->SetColors(6,r,g,b);
else
ErrorGen("Unknown option");
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(title, "TEXTEDIT");
}
int YabInterface::TextGet(const char* title, const char* option, const char* option2)
{
int ret = -1;
YabView *myView = NULL;
YabText *myText = NULL;
BString tmp(option);
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(),YabWindow);
if(w)
{
w->Lock();
myText = cast_as(myView->FindView(title),YabText);
if(myText)
{
if(tmp.IFindFirst("case-sensitive-find")!=B_ERROR)
{
int32 startOffset, endOffset;
myText->GetSelection(&startOffset, &endOffset);
bool isFinished = false;
int foundOffset, l = myText->TextLength() - endOffset;
char* s;
s = new char[l+1];
myText->GetText(endOffset, l, s);
BString line(s);
foundOffset = line.FindFirst(option2);
if(foundOffset == B_ERROR)
{
delete s;
s = new char[endOffset];
myText->GetText(0, endOffset-1, s);
line = s;
foundOffset = line.FindFirst(option2);
}
else
foundOffset += endOffset;
if(foundOffset != B_ERROR)
{
delete s;
myText->Select(foundOffset, foundOffset+strlen(option2));
myText->ScrollToSelection();
ret = myText->LineAt(foundOffset)+1;
// myText->GoToLine(myText->LineAt(foundOffset));
}
}
else if(tmp.IFindFirst("find")!=B_ERROR)
{
int32 startOffset, endOffset;
myText->GetSelection(&startOffset, &endOffset);
// = myText->OffsetAt(myText->CurrentLine());
bool isFinished = false;
int foundOffset, l = myText->TextLength() - endOffset;
char* s;
s = new char[l+1];
myText->GetText(endOffset, l, s);
BString line(s);
foundOffset = line.IFindFirst(option2);
if(foundOffset == B_ERROR)
{
delete s;
s = new char[endOffset];
myText->GetText(0, endOffset-1, s);
line = s;
foundOffset = line.IFindFirst(option2);
}
else
foundOffset += endOffset;
if(foundOffset != B_ERROR)
{
delete s;
myText->Select(foundOffset, foundOffset+strlen(option2));
myText->ScrollToSelection();
ret = myText->LineAt(foundOffset)+1;
// myText->GoToLine(myText->LineAt(foundOffset));
}
}
else
ErrorGen("Unknown option");
w->Unlock();
return ret;
}
w->Unlock();
}
}
}
Error(title, "TEXTEDIT");
}
double YabInterface::TextGet(const char* title, const char* option, int line)
{
double ret = -1.0;
YabView *myView = NULL;
YabText *myText = NULL;
BString tmp(option);
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(),YabWindow);
if(w)
{
w->Lock();
myText = cast_as(myView->FindView(title),YabText);
if(myText)
{
if(tmp.IFindFirst("line-width")!=B_ERROR)
ret = myText->LineWidth(line);
else if(tmp.IFindFirst("line-height")!=B_ERROR)
ret = myText->LineHeight(line);
else
ErrorGen("Unknown option");
w->Unlock();
return ret;
}
w->Unlock();
}
}
}
Error(title, "TEXTEDIT");
}
int YabInterface::TextGet(const char* title, const char* option)
{
int ret = -1;
YabView *myView = NULL;
YabText *myText = NULL;
BString tmp(option);
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(),YabWindow);
if(w)
{
w->Lock();
myText = cast_as(myView->FindView(title),YabText);
if(myText)
{
if(tmp.IFindFirst("currentline")!=B_ERROR)
ret = myText->CurrentLine()+1;
else if(tmp.IFindFirst("vertical-scrollbar")!=B_ERROR)
{
float f = -1.0;
BScrollView *s = cast_as(myText->Parent(), BScrollView);
if(s)
{
BScrollBar *b = s->ScrollBar(B_VERTICAL);
if(b) f = b->Value();
else
ErrorGen("TEXTEDIT has no vertical scrollbar");
}
else
ErrorGen("TEXTEDIT has no vertical scrollbar");
ret = (int)f;
}
else if(tmp.IFindFirst("horizontal-scrollbar")!=B_ERROR)
{
float f = -1.0;
BScrollView *s = cast_as(myText->Parent(), BScrollView);
if(s)
{
BScrollBar *b = s->ScrollBar(B_HORIZONTAL);
if(b) f = b->Value();
else
ErrorGen("TEXTEDIT has no horizontal scrollbar");
}
else
ErrorGen("TEXTEDIT has no horizontal scrollbar");
ret = (int)f;
}
else if(tmp.IFindFirst("countlines")!=B_ERROR)
ret = myText->CountLines();
else if(tmp.IFindFirst("countphysicallines")!=B_ERROR)
ret=myText->CountPhysicalLines();
else if(tmp.IFindFirst("textlength")!=B_ERROR)
ret = myText->TextLength();
else if(tmp.IFindFirst("haschanged")!=B_ERROR)
ret = myText->HasChanged()?1:0;
else if(tmp.IFindFirst("cursor-position")!=B_ERROR)
{
int32 start, end, pos1,pos2;
myText->GetSelection(&start, &end);
ret = end;
}
else
ErrorGen("Unknown option");
w->Unlock();
return ret;
}
w->Unlock();
}
}
}
Error(title, "TEXTEDIT");
}
const char* YabInterface::TextGet(const char* title, int linenum)
{
YabView *myView = NULL;
YabText *myText = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(),YabWindow);
if(w)
{
w->Lock();
myText = cast_as(myView->FindView(title),YabText);
if(myText)
{
char* ret;
int start, num;
if(linenum-1 == 0)
start = 0;
else
start = myText->OffsetAt(linenum-1);
if(myText->CountLines()>linenum)
num = myText->OffsetAt(linenum)-start-1;
else
num = myText->TextLength()-start;
ret = new char[num+1];
myText->GetText(start, num, ret);
w->Unlock();
return (const char*)ret;
}
w->Unlock();
}
}
}
Error(title, "TEXTEDIT");
}
const char* YabInterface::TextGet6(const char* title, const char* option)
{
YabView *myView = NULL;
YabText *myText = NULL;
BString tmp(option);
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(),YabWindow);
if(w)
{
w->Lock();
myText = cast_as(myView->FindView(title),YabText);
if(myText)
{
if(tmp.IFindFirst("selection")!=B_ERROR)
{
char* ret;
int32 start, finish;
myText->GetSelection(&start, &finish);
if(finish == 0 || (finish-start)<=0)
{
ret = new char[1];
ret[0] = '\0';
}
else
{
ret = new char[finish-start+1];
myText->GetText(start, finish-start, ret);
}
w->Unlock();
return (const char*)ret;
}
else
ErrorGen("Unknown option");
}
w->Unlock();
}
}
}
Error(title, "TEXTEDIT");
}
double YabInterface::DrawGet(const char* option, const char* txt, const char* view)
{
double ret = 0;
BString tmp(option);
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
if(tmp.IFindFirst("Text-Width")!=B_ERROR)
ret = myView->StringWidth(txt);
if(tmp.IFindFirst("Max-Text-Height")!=B_ERROR)
{
font_height height;
myView->GetFontHeight(&height);
ret = height.ascent+height.descent;
}
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
{
for(int i=0; i<yabcanvas->CountItems(); i++)
{
YabBitmapView *myView = (YabBitmapView*)yabcanvas->ItemAt(i);
if(!strcmp(myView->Name(), view))
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BBitmap *b = myView->GetBitmap();
BView *bView = myView->GetBitmapView();
b->Lock();
if(tmp.IFindFirst("Text-Width")!=B_ERROR)
ret = bView->StringWidth(txt);
if(tmp.IFindFirst("Max-Text-Height")!=B_ERROR)
{
font_height height;
bView->GetFontHeight(&height);
ret = height.ascent+height.descent;
}
b->Unlock();
w->Unlock();
return ret;
}
else
ErrorGen("Unable to lock window");
}
}
Error(view, "VIEW or CANVAS");
}
return ret;
}
const char* YabInterface::DrawGet(const char* option)
{
BString t(option);
char* ret;
if(t.IFindFirst("fontfamily")!=B_ERROR)
{
int32 numFamilies = count_font_families();
ret = new char[numFamilies*(B_FONT_FAMILY_LENGTH + 1)];
BString tmp("");
for(int32 i=0; i<numFamilies; i++)
{
font_family f;
uint32 flags;
if (get_font_family(i, &f, &flags) == B_OK)
{
tmp+=f;
tmp+="|";
}
}
strcpy(ret, tmp.String());
}
else
{
uint32 flags;
int32 numStyles = count_font_styles((char*)option);
ret = new char[numStyles*(B_FONT_STYLE_LENGTH + 1)];
BString tmp("");
for(int32 i=0; i<numStyles ; i++)
{
font_style style;
uint32 flags;
if (get_font_style((char*)option, i, &style, &flags) == B_OK)
{
tmp+=style;
tmp+="|";
}
}
strcpy(ret, tmp.String());
}
return (const char*) ret;
}
int YabInterface::DrawGet(BPoint coord, const char* option, const char* view)
{
BString t(option);
return 0;
}
void YabInterface::TextClear(const char* title)
{
YabView *myView = NULL;
YabText *myText = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myText = cast_as(myView->FindView(title), YabText);
if(myText)
{
myText->SetText("", 0);
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(title, "TEXTEDIT");
}
const char* YabInterface::TextGet(const char* title)
{
const char* tmp;
YabView *myView = NULL;
YabText *myText = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myText = cast_as(myView->FindView(title), YabText);
if(myText)
{
tmp = myText->Text();
w->Unlock();
return tmp;
}
w->Unlock();
}
}
}
Error(title, "TEXTEDIT");
}
void YabInterface::TreeBox1(BRect frame, const char* id, int scrollbarType, const char* view)
{
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
uint32 resizeMode;
w->Lock();
if(scrollbarType == 3 || scrollbarType == 1) frame.right -= B_V_SCROLL_BAR_WIDTH;
if(scrollbarType>2) frame.bottom -= B_H_SCROLL_BAR_HEIGHT;
BOutlineListView *list = new BOutlineListView(frame,id);
if(w->layout == -1)
resizeMode = B_FOLLOW_ALL;
else
resizeMode = w->layout;
list->SetResizingMode(resizeMode);
list->SetFlags(B_WILL_DRAW|B_FULL_UPDATE_ON_RESIZE|B_NAVIGABLE);
list->SetSelectionMessage(new BMessage(YABTREEBOXSELECT));
list->SetInvocationMessage(new BMessage(YABTREEBOXINVOKE));
switch(scrollbarType)
{
case 3: // both
myView->AddChild(new BScrollView("scroll_list", list, resizeMode, B_WILL_DRAW|B_FULL_UPDATE_ON_RESIZE, true, true));
break;
case 2: // horizontal
myView->AddChild(new BScrollView("scroll_list", list, resizeMode, B_WILL_DRAW|B_FULL_UPDATE_ON_RESIZE, true, false));
break;
case 0: // none
myView->AddChild(list);
break;
default: // vertical is default
myView->AddChild(new BScrollView("scroll_list", list, resizeMode, B_WILL_DRAW|B_FULL_UPDATE_ON_RESIZE, false, true));
break;
}
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
Error(view, "VIEW");
}
void YabInterface::TreeBox2(const char* id, const char* item)
{
YabView *myView = NULL;
BOutlineListView *myTree = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myTree = cast_as(myView->FindView(id), BOutlineListView);
if(myTree)
{
myTree->AddItem(new BStringItem(item));
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(id, "TREEBOX");
}
//Correction of Subitem by Stephan Aßmus on BeGeistert 2018
void YabInterface::TreeBox3(const char* id, const char* head, const char* item, int isExpanded)
{
YabView *myView = NULL;
BOutlineListView *myTree = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myTree = cast_as(myView->FindView(id), BOutlineListView);
if(myTree)
{
for(int i=0; i<myTree->FullListCountItems(); i++)
{
BStringItem *stritem = (BStringItem*)myTree->FullListItemAt(i);
if(!strcmp(stritem->Text(), head))
{
int32 level = stritem->OutlineLevel() + 1;
BStringItem *tmp = new BStringItem(item, level);
//myTree->AddUnder(tmp,stritem);
int32 fullSubItemCount = myTree->CountItemsUnder(stritem, false);
//printf("found item '%s' at %ld with level %ld, number of sub-items: %ld\n",
// head, i, level - 1, fullSubItemCount);
myTree->AddItem(tmp, i + fullSubItemCount + 1);
if(isExpanded<1)
myTree->Collapse(stritem);
w->Unlock();
return;
}
}
w->Unlock();
ErrorGen("Item not found");
}
w->Unlock();
}
}
}
Error(id, "TREEBOX");
}
void YabInterface::TreeBox4(const char* id)
{
YabView *myView = NULL;
BOutlineListView *myTree = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myTree = cast_as(myView->FindView(id), BOutlineListView);
if(myTree)
{
myTree->MakeEmpty();
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(id, "TREEBOX");
}
void YabInterface::TreeBox5(const char* id, const char* item)
{
YabView *myView = NULL;
BOutlineListView *myTree = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myTree = cast_as(myView->FindView(id), BOutlineListView);
if(myTree)
{
for(int i=0; i<myTree->FullListCountItems(); i++)
{
BStringItem *stritem = (BStringItem*)myTree->FullListItemAt(i);
if(!strcmp(stritem->Text(), item))
{
myTree->RemoveItem(i);
w->Unlock();
return;
}
}
w->Unlock();
ErrorGen("Item not found");
}
w->Unlock();
}
}
}
Error(id, "TREEBOX");
}
void YabInterface::TreeBox7(const char* id, int pos)
{
pos--;
YabView *myView = NULL;
BOutlineListView *myTree = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myTree = cast_as(myView->FindView(id), BOutlineListView);
if(myTree)
{
if(pos==0)
myTree->DeselectAll();
else
{
BListItem *item = myTree->FullListItemAt(pos);
if(item)
myTree->Select(myTree->IndexOf(item));
}
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(id, "TREEBOX");
}
void YabInterface::TreeBox8(const char* id, int pos)
{
pos--;
YabView *myView = NULL;
BOutlineListView *myTree = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myTree = cast_as(myView->FindView(id), BOutlineListView);
if(myTree)
{
myTree->RemoveItem(pos);
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(id, "TREEBOX");
}
void YabInterface::TreeBox9(const char* id, const char* head, const char* item)
{
YabView *myView = NULL;
BOutlineListView *myTree = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myTree = cast_as(myView->FindView(id), BOutlineListView);
if(myTree)
{
for(int i=0; i<myTree->FullListCountItems(); i++)
{
BStringItem *stritem = (BStringItem*)myTree->FullListItemAt(i);
if(!strcmp(stritem->Text(), head))
{
for(int j=0; i<myTree->CountItemsUnder(stritem, false); j++)
{
BStringItem *subitem = (BStringItem*)myTree->FullListItemAt(i+j+1);
if(!strcmp(subitem->Text(), item))
{
myTree->RemoveItem((BListItem*)subitem);
w->Unlock();
return;
}
}
}
}
w->Unlock();
ErrorGen("Item not found");
}
w->Unlock();
}
}
}
Error(id, "TREEBOX");
}
void YabInterface::TreeBox10(const char* id, const char* head)
{
YabView *myView = NULL;
BOutlineListView *myTree = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myTree = cast_as(myView->FindView(id), BOutlineListView);
if(myTree)
{
for(int i=0; i<myTree->FullListCountItems(); i++)
{
BStringItem *stritem = (BStringItem*)myTree->FullListItemAt(i);
if(!strcmp(stritem->Text(), head))
{
myTree->Expand((BListItem*)stritem);
w->Unlock();
return;
}
}
w->Unlock();
ErrorGen("Item not found");
}
w->Unlock();
}
}
}
Error(id, "TREEBOX");
}
void YabInterface::TreeBox11(const char* id, const char* head)
{
YabView *myView = NULL;
BOutlineListView *myTree = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myTree = cast_as(myView->FindView(id), BOutlineListView);
if(myTree)
{
for(int i=0; i<myTree->FullListCountItems(); i++)
{
BStringItem *stritem = (BStringItem*)myTree->FullListItemAt(i);
if(!strcmp(stritem->Text(), head))
{
myTree->Collapse((BListItem*)stritem);
w->Unlock();
return;
}
}
w->Unlock();
ErrorGen("Item not found");
}
w->Unlock();
}
}
}
Error(id, "TREEBOX");
}
void YabInterface::TreeBox12(const char* id, const char* item, int pos)
{
if(pos<1) pos = 1;
YabView *myView = NULL;
BOutlineListView *myTree = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myTree = cast_as(myView->FindView(id),BOutlineListView);
if(myTree)
{
if(pos<=myTree->FullListCountItems())
{
uint32 outline = (myTree->FullListItemAt(pos-1))->OutlineLevel();
myTree->AddItem(new BStringItem(item, outline),pos-1);
}
else
myTree->AddItem(new BStringItem(item));
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(id, "TREEBOX");
}
const char* YabInterface::TreeboxGet(const char* treebox, int pos)
{
pos--;
YabView *myView = NULL;
BOutlineListView *myTree = NULL;
for(int i=0; i<viewList->CountItems(); i++) //CountItems()
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myTree = cast_as(myView->FindView(treebox), BOutlineListView);
if(myTree)
{
BStringItem *t = (BStringItem*)myTree->FullListItemAt(pos);
if(t)
{
const char* txt = t->Text();
//printf(txt);
w->Unlock();
return txt;
}
}
w->Unlock();
}
}
}
Error(treebox, "TREEBOX");
}
int YabInterface::TreeboxCount(const char* treebox)
{
int32 ret;
YabView *myView = NULL;
BOutlineListView *myTree = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myTree = cast_as(myView->FindView(treebox), BOutlineListView);
if(myTree)
{
ret = myTree->FullListCountItems();
w->Unlock();
return ret;
}
w->Unlock();
}
}
}
Error(treebox, "TREEBOX");
}
BBitmap* YabInterface::loadImage(const char* FileName)
{
BBitmap* LogoBitmap = NULL;
BFile ImageFile;
BPath ImagePath;
int ret = 0;
if( *FileName == '/')
ImageFile.SetTo( FileName, B_READ_ONLY);
else
// App directory.
if(!strcmp(ApplicationDirectory,""))
{
if( ImagePath.SetTo((const char*)ApplicationDirectory, FileName) == B_OK)
ImageFile.SetTo( ImagePath.Path(), B_READ_ONLY);
}
if( ImageFile.InitCheck() != B_OK)
ImageFile.SetTo( FileName, B_READ_ONLY);
if( ImageFile.InitCheck() != B_OK)
return NULL;
Roster = BTranslatorRoster::Default();
if( !Roster)
return NULL;
BBitmapStream Stream;
if( Roster->Translate( &ImageFile, NULL, NULL, &Stream, B_TRANSLATOR_BITMAP) < B_OK)
return NULL;
if( Stream.DetachBitmap( &LogoBitmap) != B_OK)
return NULL;
return LogoBitmap;
}
void YabInterface::ButtonImage(double x,double y, const char* id,const char* enabledon, const char* enabledoff, const char* disabled, const char* view)
{
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BPicture *pic1 = NULL, *pic2 = NULL, *pic3 = NULL;
BBitmap *bitmap = NULL;
BView *tmpView = new BView(BRect(0,0,1000,1000),"tmp",0, B_WILL_DRAW);
w->AddChild(tmpView);
tmpView->SetDrawingMode(B_OP_ALPHA);
bitmap = loadImage(enabledon);
tmpView->BeginPicture(new BPicture);
if(bitmap)
{
// drawing_mode mode = myView->DrawingMode();
// tmpView->SetDrawingMode(B_OP_ALPHA);
tmpView->DrawBitmap(bitmap,bitmap->Bounds());
// myView->SetDrawingMode(mode);
}
pic1 = tmpView->EndPicture();
BRect r;
r.SetLeftTop(BPoint(x,y));
if(bitmap)
r.SetRightBottom(BPoint(x,y) + bitmap->Bounds().RightBottom());
else
r.SetRightBottom(BPoint(x,y));
bitmap = loadImage(enabledoff);
tmpView->BeginPicture(new BPicture);
if(bitmap)
{
// drawing_mode mode = myView->DrawingMode();
// tmpView->SetDrawingMode(B_OP_ALPHA);
tmpView->DrawBitmap(bitmap,bitmap->Bounds());
// myView->SetDrawingMode(mode);
}
pic2 = tmpView->EndPicture();
bitmap = loadImage(disabled);
tmpView->BeginPicture(new BPicture);
if(bitmap) tmpView->DrawBitmap(bitmap,bitmap->Bounds());
pic3 = tmpView->EndPicture();
BPictureButton *myButton = new BPictureButton(r, id, pic2, pic1, new BMessage(YABBUTTON));
myButton->SetDisabledOff(pic3);
if(w->layout == -1)
myButton->SetResizingMode(B_FOLLOW_RIGHT|B_FOLLOW_BOTTOM);
else
myButton->SetResizingMode(w->layout);
myButton->SetFlags(B_WILL_DRAW|B_FULL_UPDATE_ON_RESIZE|B_NAVIGABLE);
myView->AddChild(myButton);
tmpView->RemoveSelf();
delete tmpView;
// delete Roster;
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
Error(view, "VIEW");
}
void YabInterface::CheckboxImage(double x, double y,const char* id,const char* enabledon, const char* enabledoff, const char *disabledon, const char *disabledoff, int isActivated, const char* view)
{
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BPicture *pic1 = NULL, *pic2 = NULL, *pic3 = NULL, *pic4 = NULL;
BBitmap *bitmap = NULL;
BView *tmpView = new BView(BRect(0,0,1000,1000),"tmp",0, B_WILL_DRAW);
w->AddChild(tmpView);
tmpView->SetDrawingMode(B_OP_ALPHA);
bitmap = loadImage(enabledon);
tmpView->BeginPicture(new BPicture);
if(bitmap)
{
// drawing_mode mode = myView->DrawingMode();
// myView->SetDrawingMode(B_OP_ALPHA);
tmpView->DrawBitmap(bitmap,bitmap->Bounds());
// myView->SetDrawingMode(mode);
}
pic1 = tmpView->EndPicture();
BRect r;
r.SetLeftTop(BPoint(x,y));
if(bitmap)
r.SetRightBottom(BPoint(x,y) + bitmap->Bounds().RightBottom());
else
r.SetRightBottom(BPoint(x,y));
bitmap = loadImage(enabledoff);
tmpView->BeginPicture(new BPicture);
if(bitmap)
{
// drawing_mode mode = myView->DrawingMode();
// myView->SetDrawingMode(B_OP_ALPHA);
tmpView->DrawBitmap(bitmap,bitmap->Bounds());
// myView->SetDrawingMode(mode);
}
pic2 = tmpView->EndPicture();
bitmap = loadImage(disabledon);
tmpView->BeginPicture(new BPicture);
if(bitmap)
{
// drawing_mode mode = myView->DrawingMode();
// myView->SetDrawingMode(B_OP_ALPHA);
tmpView->DrawBitmap(bitmap,bitmap->Bounds());
// myView->SetDrawingMode(mode);
}
pic3 = tmpView->EndPicture();
bitmap = loadImage(disabledoff);
tmpView->BeginPicture(new BPicture);
if(bitmap)
{
// drawing_mode mode = myView->DrawingMode();
// myView->SetDrawingMode(B_OP_ALPHA);
tmpView->DrawBitmap(bitmap,bitmap->Bounds());
// myView->SetDrawingMode(mode);
}
pic4 = tmpView->EndPicture();
BPictureButton *myButton = new BPictureButton(r, id, pic2, pic1, new BMessage(YABCHECKBOX),B_TWO_STATE_BUTTON);
myButton->SetDisabledOn(pic3);
myButton->SetDisabledOff(pic4);
if(w->layout == -1)
myButton->SetResizingMode(B_FOLLOW_RIGHT|B_FOLLOW_BOTTOM);
else
myButton->SetResizingMode(w->layout);
myButton->SetValue(isActivated);
myButton->SetFlags(B_WILL_DRAW|B_FULL_UPDATE_ON_RESIZE|B_NAVIGABLE);
myView->AddChild(myButton);
tmpView->RemoveSelf();
delete tmpView;
// delete Roster;
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
Error(view, "VIEW");
}
void YabInterface::CheckboxSet(const char* id, int isActivated)
{
YabView *myView = NULL;
BCheckBox *myCheckBox = NULL;
BPictureButton *myPicButton = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myCheckBox = cast_as(myView->FindView(id), BCheckBox);
if(myCheckBox)
{
myCheckBox->SetValue(isActivated);
w->Unlock();
return;
}
else
{
myPicButton = cast_as(myView->FindView(id), BPictureButton);
if(myPicButton)
{
if(myPicButton->Behavior() == B_TWO_STATE_BUTTON)
{
myPicButton->SetValue(isActivated);
w->Unlock();
return;
}
}
}
w->Unlock();
}
}
}
Error(id, "CHECKBOX");
}
void YabInterface::RadioSet(const char* id, int isActivated)
{
YabView *myView = NULL;
BRadioButton *myRadioButton= NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myRadioButton = cast_as(myView->FindView(id), BRadioButton);
if(myRadioButton)
{
myRadioButton->SetValue(isActivated);
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(id, "RADIOBUTTON");
}
const char* YabInterface::TextControlGet(const char* id)
{
const char* tmp = NULL;
YabView *myView = NULL;
BTextControl *myTControl = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myTControl = cast_as(myView->FindView(id), BTextControl);
if(myTControl)
{
tmp = myTControl->Text();
w->Unlock();
return tmp;
}
w->Unlock();
}
}
}
Error(id, "TEXTCONTROL");
}
void YabInterface::ToolTips(const char* view, const char* text)
{
YabView *myView = NULL;
BView *theView = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
theView = w->FindView(view);
if(theView)
{
if(theView->Name())
{
if(!strcmp(theView->Name(), view))
{
if(text[0] == '\0')
// tooltip->SetHelp(theView, NULL);
;
else
theView->SetToolTip(text);
w->Unlock();
return;
}
}
}
w->Unlock();
}
}
}
Error(view, "VIEW");
}
void YabInterface::ToolTipsColor(const char* color, int r, int g, int b)
{
/*
BString tmp(color);
rgb_color rgb = {r,g,b};
if(tmp.IFindFirst("BGColor")!=B_ERROR)
tooltip->SetColor(rgb);
else if(tmp.IFindFirst("TextColor")!=B_ERROR)
tooltip->SetTextColor(rgb);
*/
}
void YabInterface::TreeSort(const char* view)
{
ErrorGen("Sorry, this command is not working yet");
YabView *myView = NULL;
BOutlineListView *myList = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myList = cast_as(myView->FindView(view), BOutlineListView);
if(myList)
{
myList->FullListSortItems((int(*)(const BListItem *, const BListItem *))YabInterface::compare);
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(view, "TREEBOX");
}
void YabInterface::ListSort(const char* view)
{
YabView *myView = NULL;
BListView *myList = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myList = cast_as(myView->FindView(view), BListView);
if(myList)
{
myList->SortItems((int(*)(const void*, const void*))YabInterface::compare);
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(view, "LISTBOX");
}
int YabInterface::compare(BListItem **firstArg, BListItem **secondArg)
{
if(firstArg != NULL && secondArg != NULL)
{
BString item1(((BStringItem*)*firstArg)->Text());
BString item2(((BStringItem*)*secondArg)->Text());
if(((BListItem*)*firstArg)->OutlineLevel()!=((BListItem*)*secondArg)->OutlineLevel())
return 0;
return item1.ICompare(item2);
}
return 0;
}
void YabInterface::FileBox(BRect frame, const char* id, bool hasHScrollbar, const char* option, const char* view)
{
BString tmp(option);
border_style plain = B_PLAIN_BORDER;
if(tmp.IFindFirst("no-border")!=B_ERROR)
plain = B_NO_BORDER;
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BColumnListView* myColumnList;
myColumnList = new BColumnListView(frame, id, B_FOLLOW_ALL_SIDES, B_WILL_DRAW|B_FRAME_EVENTS|B_NAVIGABLE,plain, hasHScrollbar);
BMessage *msg1, *msg2;
msg1 = new BMessage(YABFILEBOXINVOKE);
msg1->AddPointer("source", myColumnList);
msg2 = new BMessage(YABFILEBOXSELECT);
msg2->AddPointer("source", myColumnList);
myColumnList->SetInvocationMessage(msg1);
myColumnList->SetSelectionMessage(msg2);
myColumnList->SetSortingEnabled(true);
myColumnList->SetSelectionMode(B_SINGLE_SELECTION_LIST);
rgb_color rgb = {195,195,195,255};
myColumnList->SetColor(B_COLOR_SELECTION, rgb);
int flags = B_ALLOW_COLUMN_NONE;
if(tmp.IFindFirst("movable")!=B_ERROR)
flags += B_ALLOW_COLUMN_MOVE;
if(tmp.IFindFirst("resizable")!=B_ERROR)
flags += B_ALLOW_COLUMN_RESIZE;
if(tmp.IFindFirst("popup")!=B_ERROR)
flags += B_ALLOW_COLUMN_POPUP;
if(tmp.IFindFirst("removable")!=B_ERROR)
flags += B_ALLOW_COLUMN_REMOVE;
myColumnList->SetColumnFlags((column_flags) flags);
myColumnList->SetLatchWidth(0.0);
myView->AddChild(myColumnList);
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
Error(view, "VIEW");
}
void YabInterface::ColumnBoxAdd(const char* id, int column, int position, int height, const char* text)
{
YabView *myView = NULL;
BColumnListView *myColumnList = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myColumnList = cast_as(myView->FindView(id), BColumnListView);
if(myColumnList)
{
BRow *myRow = myColumnList->RowAt(position-1);
if(!myRow)
{
myRow = new BRow(height);
myColumnList->AddRow(myRow, position);
for(int j=0; j<myColumnList->CountColumns(); j++)
{
BYabField *myField = new BYabField("");
myRow->SetField(myField, j);
}
}
BYabField *myField = (BYabField*)myRow->GetField(column-1);
myField->SetString(text, height);
myColumnList->Refresh();
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(id, "COLUMNBOX");
}
void YabInterface::FileBoxAdd(const char* columnbox, const char* name, int32 pos, double minWidth, double maxWidth, double width, const char* option)
{
BString tmp(option);
alignment align = B_ALIGN_LEFT;
if(tmp.IFindFirst("align-left")!=B_ERROR)
align = B_ALIGN_LEFT;
if(tmp.IFindFirst("align-center")!=B_ERROR)
align = B_ALIGN_CENTER;
if(tmp.IFindFirst("align-right")!=B_ERROR)
align = B_ALIGN_RIGHT;
YabView *myView = NULL;
BColumnListView *myColumnList = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myColumnList = cast_as(myView->FindView(columnbox), BColumnListView);
if(myColumnList)
{
BYabColumn *myColumn = new BYabColumn(name,width,maxWidth, minWidth,width, align);
myColumnList->AddColumn(myColumn, pos-1);
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(columnbox, "COLUMNBOX");
}
void YabInterface::FileBoxClear(const char* columnbox)
{
YabView *myView = NULL;
BColumnListView *myColumnList = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myColumnList = cast_as(myView->FindView(columnbox), BColumnListView);
if(myColumnList)
{
myColumnList->Clear();
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(columnbox, "COLUMNBOX");
}
void YabInterface::ColumnBoxRemove(const char* columnbox, int position)
{
YabView *myView = NULL;
BColumnListView *myColumnList = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myColumnList = cast_as(myView->FindView(columnbox), BColumnListView);
if(myColumnList)
{
BRow *myRow;
myRow = myColumnList->RowAt(position-1);
if(myRow)
{
myColumnList->RemoveRow(myRow);
delete myRow;
}
else
{
w->Unlock();
ErrorGen("Row not found");
}
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(columnbox, "COLUMNBOX");
}
void YabInterface::ColumnBoxColor(const char* columnbox, const char* option, int r, int g, int b)
{
YabView *myView = NULL;
BColumnListView *myColumnList = NULL;
BString tmp(option);
ColumnListViewColor col;
if(tmp.IFindFirst("selection-text")!=B_ERROR)
col = B_COLOR_SELECTION_TEXT;
else if(tmp.IFindFirst("non-focus-selection")!=B_ERROR)
col = B_COLOR_NON_FOCUS_SELECTION;
else if(tmp.IFindFirst("selection")!=B_ERROR)
col = B_COLOR_SELECTION;
else if(tmp.IFindFirst("text")!=B_ERROR)
col = B_COLOR_TEXT;
else if(tmp.IFindFirst("row-divider")!=B_ERROR)
col = B_COLOR_ROW_DIVIDER;
else if(tmp.IFindFirst("background")!=B_ERROR)
col = B_COLOR_BACKGROUND;
else
ErrorGen("Invalid option");
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myColumnList = cast_as(myView->FindView(columnbox), BColumnListView);
if(myColumnList)
{
rgb_color rgb = {r,g,b,255};
myColumnList->SetColor(col, rgb);
myColumnList->Refresh();
myColumnList->Invalidate();
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(columnbox, "COLUMNBOX");
}
void YabInterface::ColumnBoxSelect(const char* columnbox, int position)
{
YabView *myView = NULL;
BColumnListView *myColumnList = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myColumnList = cast_as(myView->FindView(columnbox), BColumnListView);
if(myColumnList)
{
if(position == 0)
myColumnList->DeselectAll();
else
{
myColumnList->AddToSelection(myColumnList->RowAt(position-1));
myColumnList->ScrollTo(myColumnList->RowAt(position-1));
}
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(columnbox, "COLUMNBOX");
}
const char* YabInterface::ColumnBoxGet(const char* columnbox, int column, int position)
{
YabView *myView = NULL;
BColumnListView *myColumnList = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myColumnList = cast_as(myView->FindView(columnbox), BColumnListView);
if(myColumnList)
{
BRow* myRow = myColumnList->RowAt(position-1);
if(myRow)
{
BYabField *myField = cast_as(myRow->GetField(column-1), BYabField);
if(myField)
{
const char* t = myField->String();
w->Unlock();
return t;
}
w->Unlock();
ErrorGen("Column not found");
}
w->Unlock();
ErrorGen("Row not found");
}
w->Unlock();
}
}
}
Error(columnbox, "COLUMNBOX");
}
int YabInterface::ColumnBoxCount(const char* columnbox)
{
YabView *myView = NULL;
BColumnListView *myColumnList = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myColumnList = cast_as(myView->FindView(columnbox), BColumnListView);
if(myColumnList)
{
int32 ret = myColumnList->CountRows();
w->Unlock();
return ret;
}
w->Unlock();
}
}
}
Error(columnbox, "COLUMNBOX");
}
void YabInterface::ListboxAdd(const char* listbox, const char* item)
{
YabView *myView = NULL;
BListView *myList = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myList = cast_as(myView->FindView(listbox), BListView);
// myList = (BListView*)myView->FindView(listbox);
if(myList)
{
myList->AddItem(new BStringItem(item));
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(listbox, "LISTBOX");
}
void YabInterface::ListboxAdd(const char* listbox, int pos, const char* item)
{
YabView *myView = NULL;
BListView *myList = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myList = cast_as(myView->FindView(listbox), BListView);
if(myList)
{
myList->AddItem(new BStringItem(item), pos-1);
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(listbox, "LISTBOX");
}
void YabInterface::ListboxSelect(const char* listbox, int pos)
{
YabView *myView = NULL;
BListView *myList = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myList = cast_as(myView->FindView(listbox), BListView);
if(myList)
{
if(pos == 0)
myList->DeselectAll();
else
{
myList->Select(pos-1);
myList->ScrollToSelection();
}
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(listbox, "LISTBOX");
}
void YabInterface::ListboxRemove(const char* listbox, int pos)
{
YabView *myView = NULL;
BListView *myList = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myList = cast_as(myView->FindView(listbox), BListView);
if(myList)
{
myList->RemoveItem(pos-1);
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(listbox, "LISTBOX");
}
const char* YabInterface::ListboxGet(const char* listbox, int pos)
{
YabView *myView = NULL;
BListView *myList = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
columntext[0] = '\0';
myList = cast_as(myView->FindView(listbox), BListView);
if(myList)
{
BStringItem *t = cast_as(myList->ItemAt(pos-1), BStringItem);
if(t)
{
const char* txt = t->Text();
w->Unlock();
return txt;
}
else
{
w->Unlock();
ErrorGen("Item not found");
}
}
w->Unlock();
}
}
}
Error(listbox, "LISTBOX");
}
int YabInterface::ListboxCount(const char* listbox)
{
int ret = 0;
YabView *myView = NULL;
BListView *myList = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myList = cast_as(myView->FindView(listbox), BListView);
if(myList)
{
ret = myList->CountItems();
w->Unlock();
return ret;
}
w->Unlock();
}
}
}
Error(listbox, "LISTBOX");
}
void YabInterface::DrawSet1(const char* option, const char* window)
{
BString tmp(option);
BFont myFont;
BString opt;
// Font family
int pos1 = 0;
int pos2 = tmp.FindFirst(',');
if(pos2 != B_ERROR)
{
tmp.CopyInto(opt, pos1, pos2-pos1);
while(opt[0] == ' ') opt.RemoveFirst(" ");
while(opt[opt.Length()-1] == ' ') opt.RemoveLast(" ");
font_family fam;
sprintf((char*)fam, "%s" , opt.String());
if(myFont.SetFamilyAndFace(fam, B_REGULAR_FACE) == B_OK)
{
// myView->SetFont(&myFont, B_FONT_FAMILY_AND_STYLE);
// Font style
pos1 = pos2+1;
pos2 = tmp.FindFirst(',', pos2+1);
if(pos2 != B_ERROR)
{
tmp.CopyInto(opt, pos1, pos2-pos1);
while(opt[0] == ' ') opt.RemoveFirst(" ");
while(opt[opt.Length()-1] == ' ') opt.RemoveLast(" ");
font_style style;
sprintf((char*)style, "%s" , opt.String());
if(myFont.SetFamilyAndStyle(fam,style) == B_OK)
{
// myView->SetFont(&myFont, B_FONT_FAMILY_AND_STYLE);
// Font size
pos1 = pos2+1;
pos2 = tmp.FindFirst(',', pos2+1);
if(pos2 == B_ERROR) pos2 = tmp.Length();
tmp.CopyInto(opt, pos1, pos2-pos1);
while(opt[0] == ' ') opt.RemoveFirst(" ");
while(opt[opt.Length()-1] == ' ') opt.RemoveLast(" ");
double size = atof(opt.String());
myFont.SetSize(size);
// myView->SetFont(&myFont, B_FONT_SIZE);
if(pos2 != tmp.Length())
{
pos1 = pos2+1;
pos2 = tmp.FindFirst(',', pos2+1);
if(pos2 == B_ERROR) pos2 = tmp.Length();
tmp.CopyInto(opt, pos1, pos2-pos1);
while(opt[0] == ' ') opt.RemoveFirst(" ");
while(opt[opt.Length()-1] == ' ') opt.RemoveLast(" ");
if(opt.IFindFirst("bold") != B_ERROR)
myFont.SetFace(B_BOLD_FACE);
else if(opt.IFindFirst("italic") != B_ERROR)
myFont.SetFace(B_ITALIC_FACE);
else if(opt.IFindFirst("regular") != B_ERROR)
myFont.SetFace(B_REGULAR_FACE);
else if(opt.IFindFirst("outlined") != B_ERROR)
myFont.SetFace(B_OUTLINED_FACE);
else if(opt.IFindFirst("strikeout") != B_ERROR)
myFont.SetFace(B_STRIKEOUT_FACE);
else if(opt.IFindFirst("underscore") != B_ERROR)
myFont.SetFace(B_UNDERSCORE_FACE);
if(pos2 != tmp.Length())
{
pos1 = pos2 + 1;
pos2 = tmp.FindFirst(',', pos2+1);
if(pos2 == B_ERROR) pos2 = tmp.Length();
tmp.CopyInto(opt, pos1, pos2-pos1);
while(opt[0] == ' ') opt.RemoveFirst(" ");
while(opt[opt.Length()-1] == ' ') opt.RemoveLast(" ");
float rotation = atof(opt.String());
myFont.SetRotation(rotation);
if(pos2 != tmp.Length())
{
pos1 = pos2 + 1;
pos2 = tmp.FindFirst(',', pos2+1);
if(pos2 == B_ERROR) pos2 = tmp.Length();
tmp.CopyInto(opt, pos1, pos2-pos1);
while(opt[0] == ' ') opt.RemoveFirst(" ");
while(opt[opt.Length()-1] == ' ') opt.RemoveLast(" ");
float shear = atof(opt.String());
myFont.SetShear(shear);
}
}
}
// Font flags
/*bool looping = true;
while(looping)
{
pos1 = pos2+1;
pos2 = tmp.FindFirst(',', pos2+1);
if(pos2 == B_ERROR)
{
looping = false;
pos2 = tmp.Length();
}
tmp.CopyInto(opt, pos1, pos2-pos1);
while(opt[0] == ' ') opt.RemoveFirst(" ");
while(opt[opt.Length()-1] == ' ') opt.RemoveLast(" ");
}*/
}
}
}
}
else if(tmp.IFindFirst("system-plain")!=B_ERROR)
{
myFont = be_plain_font;
// myView->SetFont(&myFont);
}
else if(tmp.IFindFirst("system-fixed")!=B_ERROR)
{
myFont = be_fixed_font;
// myView->SetFont(&myFont);
}
else if(tmp.IFindFirst("system-bold")!=B_ERROR)
{
myFont = be_bold_font;
// myView->SetFont(&myFont);
}
YabView *myView = cast_as((BView*)viewList->GetView(window), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myView->SetFont(&myFont);
YabDrawing *t = new YabDrawing();
t->command = 12;
t->font = myFont;
myView->drawList->AddItem(t);
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
{
for(int i=0; i<yabbitmaps->CountItems(); i++)
{
BBitmap *b = (BBitmap*)yabbitmaps->ItemAt(i);
BView *bview = b->FindView(window);
if(bview)
{
b->Lock();
bview->SetFont(&myFont);
bview->Sync();
b->Unlock();
return;
}
}
for(int i=0; i<yabcanvas->CountItems(); i++)
{
YabBitmapView *myView = (YabBitmapView*)yabcanvas->ItemAt(i);
if(!strcmp(myView->Name(), window))
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BBitmap *b = myView->GetBitmap();
BView *bView = myView->GetBitmapView();
b->Lock();
bView->SetFont(&myFont);
bView->Sync();
b->Unlock();
// myView->Draw(myView->Bounds());
w->Unlock();
return;
}
else
ErrorGen("Unable to lock window");
}
}
Error(window, "VIEW, BITMAP or CANVAS");
}
}
void YabInterface::DrawSet2(int fillorstroke, const char* mypattern)
{
BString tmp(mypattern);
if(fillorstroke) drawStroking = true; else drawStroking = false;
if(tmp.IFindFirst("HighSolidFill")!=B_ERROR)
yabPattern = B_SOLID_HIGH;
else if(tmp.IFindFirst("LowSolidFill")!=B_ERROR)
yabPattern = B_SOLID_LOW;
else if(tmp.IFindFirst("CheckeredFill")!=B_ERROR)
yabPattern = B_MIXED_COLORS;
else
{
for(int i = 0; i<8; i++)
if(i<tmp.Length()+3)
{
int t = 0;
t = 100*(tmp[i*3]-48) + 10*(tmp[i*3+1]-48) + (tmp[i*3+2]-48);
yabPattern.data[i] = t;
}
else
yabPattern.data[i] = 0;
}
}
int YabInterface::DeskbarParam(const char* option)
{
int ret;
BString opt(option);
BDeskbar(deskbar);
if( opt.IFindFirst("position") != B_ERROR )
{
deskbar_location pos = deskbar.Location();
switch (pos)
{
case B_DESKBAR_LEFT_TOP:ret=1;
break;
case B_DESKBAR_TOP:ret=2;
break;
case B_DESKBAR_RIGHT_TOP:ret=3;
break;
case B_DESKBAR_RIGHT_BOTTOM:ret=4;
break;
case B_DESKBAR_BOTTOM:ret=5;
break;
case B_DESKBAR_LEFT_BOTTOM:ret=6;
break;
}
}
else if( opt.IFindFirst("expanded") != B_ERROR )
{
ret = (int)deskbar.IsExpanded();
}
else if( opt.IFindFirst("width") != B_ERROR )
{
ret = (int)deskbar.Frame().Width()+1;
}
else if( opt.IFindFirst("height") != B_ERROR )
{
ret = (int)deskbar.Frame().Height()+1;
}
else if( opt.IFindFirst("x") != B_ERROR )
{
ret = (int)deskbar.Frame().left;
}
else if( opt.IFindFirst("y") != B_ERROR )
{
ret = (int)deskbar.Frame().top;
}
return ret;
}
int YabInterface::DesktopParam(bool isWidth)
{
BScreen myScreen(B_MAIN_SCREEN_ID);
display_mode t;
myScreen.GetMode(&t);
if(isWidth) return t.virtual_width;
return t.virtual_height;
}
/*int YabInterface::WorkspaceGet(bool isID)
{
}*/
int YabInterface::WindowGet(const char* view, const char* option)
{
int opt = 0;
int ret = -1;
BString t(option);
if(t.IFindFirst("position-x")!=B_ERROR) opt = 1;
else if(t.IFindFirst("position-y")!=B_ERROR) opt = 2;
else if(t.IFindFirst("minimum-width")!=B_ERROR) opt = 5;
else if(t.IFindFirst("minimum-height")!=B_ERROR) opt = 6;
else if(t.IFindFirst("maximum-width")!=B_ERROR) opt = 7;
else if(t.IFindFirst("maximum-height")!=B_ERROR) opt = 8;
else if(t.IFindFirst("width")!=B_ERROR) opt = 3;
else if(t.IFindFirst("height")!=B_ERROR) opt = 4;
else if(t.IFindFirst("exists")!=B_ERROR) opt = 9;
else if(t.IFindFirst("minimized-to-deskbar")!=B_ERROR) opt = 10;
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
if(opt>0 && opt<5)
{
BRect r = w->Frame();
switch(opt)
{
case 1: ret = (int)r.LeftTop().x;
break;
case 2: ret = (int)r.LeftTop().y;
break;
case 3: ret = r.IntegerWidth();
break;
case 4: ret = r.IntegerHeight();
break;
}
}
if(opt>4)
{
float x1,y1,x2,y2;
w->GetSizeLimits(&x1,&x2,&y1,&y2);
switch(opt)
{
case 5: ret = (int)x1;
break;
case 6: ret = (int)y1;
break;
case 7: ret = (int)x2;
break;
case 8: ret = (int)y2;
break;
case 10: ret = w->IsMinimized();
break;
}
}
if (opt==9)
{
return true;
}
}
else
{
if (opt==9)
{
return false;
}
else
ErrorGen("Unable to lock window");
}
}
else
{
if (opt==9)
{
return false;
}
else
Error(view, "VIEW");
}
return ret;
}
int YabInterface::ViewGet(const char* view, const char* option)
{
int opt = 0;
int ret = -1;
BString t(option);
YabView *myView = NULL;
if(t.IFindFirst("position-x")!=B_ERROR) opt = 1;
else if(t.IFindFirst("position-y")!=B_ERROR) opt = 2;
else if(t.IFindFirst("width")!=B_ERROR) opt = 3;
else if(t.IFindFirst("height")!=B_ERROR) opt = 4;
else if(t.IFindFirst("exists")!=B_ERROR) opt = 5;
else if(t.IFindFirst("focused")!=B_ERROR) opt = 6;
else
ErrorGen("Invalid option");
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BView *theView = cast_as(myView->FindView(view), BView);
if(theView)
{
BRect r = theView->Frame();
switch(opt)
{
case 1: ret = (int)r.LeftTop().x;
break;
case 2: ret = (int)r.LeftTop().y;
break;
case 3: ret = r.IntegerWidth();
break;
case 4: ret = r.IntegerHeight();
break;
case 5: ret = true;
break;
case 6: ret = theView->IsFocus();
break;
}
w->Unlock();
return ret;
}
w->Unlock();
}
}
}
if( opt == 5 )
ret=false;
else
Error(view, "VIEW");
return ret;
}
void YabInterface::ClipboardCopy(const char* text)
{
BMessage *clip = (BMessage *)NULL;
if (be_clipboard->Lock())
{
be_clipboard->Clear();
if (clip = be_clipboard->Data())
{
clip->AddData("text/plain", B_MIME_TYPE, text, strlen(text));
be_clipboard->Commit();
}
be_clipboard->Unlock();
}
}
int YabInterface::Printer(const char* docname, const char *config, const char* view)
{
BPrintJob job(docname);
BMessage *setup;
BFile myFile(config, B_READ_ONLY);
if(myFile.InitCheck()!=B_OK)
{
if(job.ConfigPage()==B_OK)
setup = job.Settings();
else
{
// (new BAlert(_L("Printer Error!"),_L("Could not setup the printer!"), "Ok"))->Go();
return 1;
}
}
else
{
setup = new BMessage();
if(setup->Unflatten(&myFile)!=B_OK)
{
if(job.ConfigPage()==B_OK)
setup = job.Settings();
else
{
// (new BAlert(_L("Printer Error!"),_L("Could not setup the printer!"), "Ok"))->Go();
return 1;
}
}
else
if(job.IsSettingsMessageValid(setup))
job.SetSettings(setup);
else
{
// (new BAlert(_L("Printer Error!"),_L("Could not setup the printer!"), "Ok"))->Go();
return 2;
}
}
int32 firstPage, lastPage, nbPages;
BRect printableRect = job.PrintableRect();
firstPage =0 ;//= job.FirstPage(); Since we aren't calling the set-up print pages, firstpage is always 0
lastPage = job.LastPage();
// printf("PRINTER DEBUG Printable BRect %f %f %f %f\n", printableRect.left,printableRect.top, printableRect.right, printableRect.bottom);
YabView *myView = NULL;
BView *newView = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
newView = myView->FindView(view);
w->Unlock();
if(newView)
break;
}
}
}
if(!newView)
{
// (new BAlert(_L("Printer Error!"),_L("Could not setup the printer!"), "Ok"))->Go();
return 3;
}
BWindow *w = newView->Window();
w->Lock();
int32 viewHeight = newView->Bounds().IntegerHeight();
float viewWidth = newView->Bounds().Width();
if(is_kind_of(newView, YabText))
viewHeight = (int32)((YabText*)newView)->TextHeight(0, ((YabText*)newView)->CountLines());
if(is_kind_of(newView, BScrollView))
{
float a,b;
if(((BScrollView*)newView)->ScrollBar(B_VERTICAL))
{
((BScrollView*)newView)->ScrollBar(B_VERTICAL)->GetRange(&a, &b);
viewHeight = viewHeight + (int32)b;
if(((BScrollView*)newView)->ScrollBar(B_HORIZONTAL))
viewHeight -= (int32)B_H_SCROLL_BAR_HEIGHT;
}
if(((BScrollView*)newView)->ScrollBar(B_HORIZONTAL))
{
((BScrollView*)newView)->ScrollBar(B_HORIZONTAL)->GetRange(&a, &b);
viewWidth = viewWidth + b;
if(((BScrollView*)newView)->ScrollBar(B_VERTICAL))
viewWidth -= B_V_SCROLL_BAR_WIDTH;
}
if(((BScrollView*)newView)->ScrollBar(B_VERTICAL))
newView = ((BScrollView*)newView)->ScrollBar(B_VERTICAL)->Target();
else
newView = ((BScrollView*)newView)->ScrollBar(B_HORIZONTAL)->Target();
}
// printf(" %d %f \n", viewHeight, viewWidth);
int32 printableHeight = printableRect.IntegerHeight();
float printableWidth = printableRect.Width();
w->Unlock();
int32 maxPages = viewHeight / printableHeight + 1;
if(lastPage>maxPages)
lastPage = maxPages;
nbPages = lastPage - firstPage + 1;
//printf("PRINTER DEBUG First Page %d Last Page %d \n", firstPage, lastPage);
// printf("PRINTER DEBUG View Height %d Printable Height %d \n", viewHeight, printableHeight);
if(nbPages<=0)
{
// (new BAlert(_L("Printer Error!"),_L("Could not setup the printer!"), "Ok"))->Go();
return 4;
}
job.BeginJob();
bool can_continue = job.CanContinue();
w->Lock();
bool hasWordWrap;
float textWidth, textHeight;
if(is_kind_of(newView, YabText))
{
int lineheight;
hasWordWrap = ((YabText*)newView)->DoesWordWrap();
if(!hasWordWrap) ((YabText*)newView)->SetWordWrap(true);
lineheight = (int)((YabText*)newView)->LineHeight();
textWidth = ((YabText*)newView)->TextRect().Width();
textHeight = ((YabText*)newView)->TextRect().Height();
((YabText*)newView)->SetTextRect(BRect(0,0,printableWidth, viewHeight));
printableHeight -= printableHeight%lineheight;
}
int32 newHeight;
if(printableHeight<viewHeight)
newHeight = printableHeight;
else
newHeight = viewHeight;
if(viewWidth<printableWidth)
printableWidth = viewWidth;
BRect currentRect;
currentRect.SetLeftTop(BPoint(0,0));
currentRect.SetRightBottom(BPoint(printableWidth, newHeight));
for(int i=1; i<firstPage; i++)
{
currentRect.SetLeftTop(BPoint(0,newHeight+1));
if(printableHeight<viewHeight-newHeight)
newHeight = newHeight + printableHeight;
else
newHeight = viewHeight;
currentRect.SetRightBottom(BPoint(printableWidth, newHeight));
// printf("PRINTER DEBUG Skipping current BRect: %f %f %f %f\n", currentRect.left,currentRect.top, currentRect.right, currentRect.bottom);
}
// printf("PRINTER DEBUG Spooling current BRect %f %f %f %f\n", currentRect.left,currentRect.top, currentRect.right, currentRect.bottom);
for(int i=firstPage; i<=lastPage; i++)
{
job.DrawView(newView, currentRect, printableRect.LeftTop());
job.SpoolPage();
can_continue = job.CanContinue();
if(!can_continue)
break;
currentRect.SetLeftTop(BPoint(0,newHeight+1));
if(printableHeight<viewHeight-newHeight)
newHeight = newHeight + printableHeight;
else
newHeight = viewHeight;
currentRect.SetRightBottom(BPoint(printableWidth, newHeight));
if(currentRect.bottom<currentRect.top)
break;
// printf("PRINTER DEBUG Spooling current BRect: %f %f %f %f\n", currentRect.left,currentRect.top, currentRect.right, currentRect.bottom);
}
if(is_kind_of(newView, YabText))
{
((YabText*)newView)->SetWordWrap(hasWordWrap);
((YabText*)newView)->SetTextRect(BRect(0,0,textWidth, textHeight));
}
w->Unlock();
if(can_continue)
job.CommitJob();
else
// (new BAlert(_L("Printer Error!"),_L("Could not setup the printer!"), "Ok"))->Go();
return 5;
return 0;
}
void YabInterface::PrinterConfig(const char* config)
{
BPrintJob job("");
if(job.ConfigPage()==B_OK)
{
BMessage *setup = job.Settings();
BFile myFile(config, B_WRITE_ONLY|B_CREATE_FILE|B_ERASE_FILE);
if(myFile.InitCheck()==B_OK)
setup->Flatten(&myFile);
}
}
const char* YabInterface::ClipboardPaste()
{
const char *text;
ssize_t textlen;
BString returnstring;
BMessage *clip = (BMessage *)NULL;
if (be_clipboard->Lock())
{
BMessage *clip = be_clipboard->Data();
clip->FindData("text/plain", B_MIME_TYPE, (const void **)&text, &textlen);
be_clipboard->Unlock();
if (text != NULL) {
returnstring.SetTo(text, textlen);
}
}
return returnstring;
}
int YabInterface::NewAlert(const char* text, const char* button1, const char* button2, const char* button3, const char* option)
{
alert_type tmp;
BString typ(option);
tmp = B_EMPTY_ALERT;
if(typ.IFindFirst("info")!=B_ERROR) tmp = B_INFO_ALERT;
else if(typ.IFindFirst("idea")!=B_ERROR) tmp = B_IDEA_ALERT;
else if(typ.IFindFirst("warning")!=B_ERROR) tmp = B_WARNING_ALERT;
else if(typ.IFindFirst("stop")!=B_ERROR) tmp = B_STOP_ALERT;
if(!strcmp(button2,"")) button2 = NULL;
if(!strcmp(button3,"")) button3 = NULL;
return (new BAlert("Alert!",text,button1,button2,button3,B_WIDTH_AS_USUAL,tmp))->Go() + 1;
}
void YabInterface::Calendar(double x, double y, const char* id, const char* format, const char* date, const char* view)
{
int day, month, year, look, myformat;
BString tYear, tMonth, tDay;
BString tDate(date);
tDate.MoveInto(tYear, 6,4);
tDate.MoveInto(tMonth, 3,2);
tDate.MoveInto(tDay, 0,2);
BString tFormat(format);
look = CC_DOT_DIVIDER;
myformat = CC_DD_MM_YYYY_FORMAT;
if(tFormat.FindFirst("/")!=B_ERROR)
look = CC_SLASH_DIVIDER;
else if(tFormat.FindFirst("-")!=B_ERROR)
look = CC_MINUS_DIVIDER;
if(tFormat.IFindFirst("MD")!=B_ERROR)
myformat = CC_MM_DD_YYYY_FORMAT;
year = atoi(tYear.String());
if(myformat == CC_MM_DD_YYYY_FORMAT)
{
month = atoi(tDay.String());
day = atoi(tMonth.String());
}
else
{
month = atoi(tMonth.String());
day = atoi(tDay.String());
}
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
CalendarControl* myCalendar = new CalendarControl(BPoint(x,y),id,day, month, year, myformat, look);
if(w->layout == -1)
myCalendar->SetResizingMode(B_FOLLOW_RIGHT|B_FOLLOW_BOTTOM);
else
myCalendar->SetResizingMode(w->layout);
myView->AddChild(myCalendar);
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
Error(view, "VIEW");
}
const char* YabInterface::Calendar(const char* id)
{
const char* txt;
YabView *myView = NULL;
CalendarControl *myCalendar = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myCalendar = cast_as(myView->FindView(id), CalendarControl);
if(myCalendar)
{
txt = myCalendar->Text();
w->Unlock();
return txt;
}
w->Unlock();
}
}
}
Error(id, "CALENDAR");
}
void YabInterface::Calendar(const char* id, const char* date)
{
int day, month, year, look, myformat;
BString tYear, tMonth, tDay;
BString tDate(date);
tDate.MoveInto(tYear, 6,4);
tDate.MoveInto(tMonth, 3,2);
tDate.MoveInto(tDay, 0,2);
YabView *myView = NULL;
CalendarControl *myCalendar = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myCalendar = cast_as(myView->FindView(id), CalendarControl);
if(myCalendar)
{
myformat = myCalendar->GetFlags();
year = atoi(tYear.String());
if(myformat == CC_MM_DD_YYYY_FORMAT)
{
month = atoi(tDay.String());
day = atoi(tMonth.String());
}
else
{
month = atoi(tMonth.String());
day = atoi(tDay.String());
}
myCalendar->SetDate(day,month,year);
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(id, "CALENDAR");
}
void YabInterface::Scrollbar(const char* id, int format, const char* view)
{
YabView *myView = NULL;
BView *myBView = NULL;
if(format != 0)
{
bool hasHor = false, hasVer = false;
if(format>1) hasHor = true;
if(format == 1 || format == 3) hasVer = true;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myBView = myView->FindView(view);
if(myBView)
{
if(myView->RemoveChild(myBView))
{
BScrollView *myScrollView = new BScrollView(id, myBView, B_FOLLOW_LEFT|B_FOLLOW_TOP, 0, hasHor, hasVer);
if(w->layout == -1)
myScrollView->SetResizingMode(B_FOLLOW_RIGHT|B_FOLLOW_BOTTOM);
else
myScrollView->SetResizingMode(w->layout);
myScrollView->SetFlags(B_WILL_DRAW|B_FULL_UPDATE_ON_RESIZE|B_NAVIGABLE);
myView->AddChild(myScrollView);
myScrollView->SetViewColor(myBView->ViewColor());
w->Unlock();
return;
}
}
w->Unlock();
}
}
}
Error(view, "VIEW");
}
ErrorGen("Unknown option");
}
void YabInterface::ScrollbarSet(const char* scrollview, const char* option, double position)
{
BString tOption(option);
orientation isHorizontal;
if(tOption.IFindFirst("Vertical Position")!=B_ERROR) isHorizontal = B_VERTICAL;
if(tOption.IFindFirst("Horizontal Position")!=B_ERROR) isHorizontal = B_HORIZONTAL;
if(isHorizontal == B_VERTICAL || isHorizontal == B_HORIZONTAL)
{
YabView *myView = NULL;
BScrollView *myScrollView = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myScrollView = cast_as((BView*)myView->FindView(scrollview),BScrollView);
if(myScrollView)
{
BScrollBar *myScrollbar = myScrollView->ScrollBar(isHorizontal);
if(myScrollbar)
myScrollbar->SetValue(position);
else
ErrorGen("SCROLLBAR is not valid!");
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(scrollview, "SCROLLBAR");
}
ErrorGen("Unknown option");
}
void YabInterface::ScrollbarSet(const char* scrollview, const char* option)
{
BString tOption(option);
border_style border;
if(tOption.IFindFirst("no-border")!=B_ERROR)
border = B_NO_BORDER;
else if(tOption.IFindFirst("plain-border")!=B_ERROR)
border = B_PLAIN_BORDER;
else if(tOption.IFindFirst("fancy-border")!=B_ERROR)
border = B_FANCY_BORDER;
else
ErrorGen("Invalid option");
YabView *myView = NULL;
BScrollView *myScrollView = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myScrollView = cast_as((BView*)myView->FindView(scrollview),BScrollView);
if(myScrollView)
{
myScrollView->SetBorder(border);
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(scrollview, "SCROLLBAR");
}
void YabInterface::ScrollbarSet(const char* scrollview, const char* option, double opt1, double opt2)
{
BString tOption(option);
orientation isHorizontal;
int isRange = -1;
if(tOption.IFindFirst("Vertical")!=B_ERROR) isHorizontal = B_VERTICAL;
if(tOption.IFindFirst("Horizontal")!=B_ERROR) isHorizontal = B_HORIZONTAL;
if(tOption.IFindFirst("Range")!=B_ERROR) isRange = 1;
if(tOption.IFindFirst("Steps")!=B_ERROR) isRange = 0;
if((isHorizontal == B_VERTICAL || isHorizontal == B_HORIZONTAL) && isRange != -1)
{
YabView *myView = NULL;
BScrollView *myScrollView = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myScrollView = cast_as((BView*)myView->FindView(scrollview),BScrollView);
if(myScrollView)
{
/*
if(isRange)
{
BRect f(myView->Bounds());
// printf("%f %f\n", opt1, opt2);
if(isHorizontal == B_HORIZONTAL)
{
f.left = opt1;
f.right = opt2;
}
else
{
f.top = opt1;
f.bottom = opt2;
}
myScrollView->SetDataRect(f);
}
else
{
BScrollBar *myScrollbar = myScrollView->ScrollBar(isHorizontal);
if(myScrollbar) myScrollbar->SetSteps(opt1,opt2);
}*/
BScrollBar *myScrollbar = myScrollView->ScrollBar(isHorizontal);
if(isRange == 1)
{
if(myScrollbar)
myScrollbar->SetRange(opt1,opt2);
else
ErrorGen("SCROLLBAR is not valid!");
}
else
{
if(myScrollbar)
myScrollbar->SetSteps(opt1,opt2);
else
ErrorGen("SCROLLBAR is not valid!");
}
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(scrollview, "SCROLLBAR");
}
ErrorGen("Unknown option");
}
double YabInterface::ScrollbarGet(const char* scrollview, const char* option)
{
BString tOption(option);
orientation isHorizontal;
double res = 0;
if(tOption.IFindFirst("Vertical")!=B_ERROR) isHorizontal = B_VERTICAL;
if(tOption.IFindFirst("Horizontal")!=B_ERROR) isHorizontal = B_HORIZONTAL;
if(isHorizontal == B_VERTICAL || isHorizontal == B_HORIZONTAL)
{
YabView *myView = NULL;
BScrollView *myScrollView = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myScrollView = (BScrollView*)myView->FindView(scrollview);
if(myScrollView)
{
BScrollBar *myScrollbar = myScrollView->ScrollBar(isHorizontal);
if(myScrollbar)
res = myScrollbar->Value();
else
ErrorGen("SCROLLBAR is not valid!");
w->Unlock();
return res;
}
w->Unlock();
}
}
}
Error(scrollview, "SCROLLBAR");
}
ErrorGen("Unknown option");
}
void YabInterface::SplitView(BRect frame, const char* id, int isVertical, int style, const char* view)
{
orientation posture = isVertical>0?B_VERTICAL:B_HORIZONTAL;
double pos;
if(posture==B_VERTICAL)
pos = (frame.right-frame.left)/2;
else
pos = (frame.bottom-frame.top)/2;
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BRect frame1(frame);
BRect frame2(frame);
if(posture==B_VERTICAL)
{
frame1.Set(0,0,pos,frame.bottom-frame.top);
frame2.Set(pos+10,0,frame.right-frame.left, frame.bottom-frame.top);
}
else
{
frame1.Set(0,0,frame.right-frame.left, pos-10);
frame2.Set(0,pos,frame.right-frame.left,frame.bottom-frame.top);
}
BString t1(id); t1 += "1";
BString t2(id); t2 += "2";
YabView *newView1 = new YabView(frame1, t1.String(), B_FOLLOW_ALL_SIDES,B_WILL_DRAW|B_NAVIGABLE_JUMP);
viewList->AddView(t1.String(), newView1, TYPE_YABVIEW);
YabView *newView2 = new YabView(frame2, t2.String(), B_FOLLOW_ALL_SIDES, B_WILL_DRAW|B_NAVIGABLE_JUMP);
viewList->AddView(t2.String(), newView2, TYPE_YABVIEW);
SplitPane *mySplit = new SplitPane(frame, id, (BView*)newView1, (BView*)newView2, 0);
if(style)
mySplit->SetBarThickness(10);
else
mySplit->SetBarThickness(5);
mySplit->SetAlignment(posture);
if(w->layout == -1)
mySplit->SetResizingMode(B_FOLLOW_ALL_SIDES);
else
mySplit->SetResizingMode(w->layout);
myView->AddChild(mySplit);
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
Error(view, "VIEW");
}
void YabInterface::SplitView(const char* splitView, const char* option, double position)
{
YabView *myView = NULL;
SplitPane *mySplit = NULL;
BString t(option);
if(t.IFindFirst("Divider")==B_ERROR)
ErrorGen("Unknown option");
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
mySplit = cast_as(myView->FindView(splitView), SplitPane);
if(mySplit)
{
mySplit->SetBarPosition((int)position);
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(splitView, "SPLITVIEW");
}
void YabInterface::SplitView(const char* splitView, const char* option, double left, double right)
{
YabView *myView = NULL;
SplitPane *mySplit = NULL;
BString t(option);
if(t.IFindFirst("MinimumSizes")==B_ERROR)
ErrorGen("Unknown option");
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
mySplit = cast_as(myView->FindView(splitView), SplitPane);
if(mySplit)
{
mySplit->SetMinSizeOne((int)left);
mySplit->SetMinSizeTwo((int)right);
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(splitView, "SPLITVIEW");
}
double YabInterface::SplitViewGet(const char* splitView, const char* option)
{
double ret = -1;
YabView *myView = NULL;
SplitPane *mySplit = NULL;
BString t(option);
if(t.IFindFirst("Divider")==B_ERROR)
ErrorGen("Unknown option");
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
mySplit = cast_as(myView->FindView(splitView), SplitPane);
if(mySplit)
{
ret = (double)mySplit->GetBarPosition();
w->Unlock();
return ret;
}
w->Unlock();
}
}
}
Error(splitView, "SPLITVIEW");
}
void YabInterface::StackViews(BRect frame, const char* id, int number, const char* view)
{
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView && number<1000)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
YabStackView *myStackView = new YabStackView(frame, id, number);
if(w->layout == -1)
myStackView->SetResizingMode(B_FOLLOW_ALL);
else
myStackView->SetResizingMode(w->layout);
// myTabView->SetFlags(B_WILL_DRAW|B_FULL_UPDATE_ON_RESIZE);
YabView *newViews[number];
for(int i=0; i<number; i++)
{
BString t(id);
t << i+1;
newViews[i] = new YabView(myStackView->Bounds(), t.String(), B_FOLLOW_ALL_SIDES,B_WILL_DRAW|B_NAVIGABLE_JUMP);
viewList->AddView(t.String(), newViews[i], TYPE_YABVIEW);
}
myStackView->AddViews((BView**)newViews);
myView->AddChild(myStackView);
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
if(number<1000) Error(view, "VIEW");
else ErrorGen("Too many views!");
}
void YabInterface::StackViews(const char* id, int num)
{
YabView *myView = NULL;
YabStackView *myStackView = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myStackView = cast_as(myView->FindView(id), YabStackView);
if(myStackView)
{
myStackView->SelectView(num-1);
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(id, "STACKVIEW");
}
int YabInterface::StackViewGet(const char* id)
{
int ret;
YabView *myView = NULL;
YabStackView *myStackView = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myStackView = cast_as(myView->FindView(id), YabStackView);
if(myStackView)
{
ret = myStackView->CurrentView();
w->Unlock();
return ret+1;
}
w->Unlock();
}
}
}
Error(id, "STACKVIEW");
}
void YabInterface::DrawSet3(const char* option, int transparency)
{
BString t(option);
if(t.IFindFirst("alpha") != B_ERROR)
{
yabAlpha = transparency;
if(yabAlpha<0) yabAlpha = 0;
if(yabAlpha>255) yabAlpha = 255;
}
}
//Texturl modified by Lorenz Glaser (aka lorglas) 03.10.2019
void YabInterface::TextURL(double x, double y, const char* id, const char* text, const char* url, const char* view)
{
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
double h,b;
b = be_plain_font->StringWidth(text)+1;
h = be_plain_font->Size();
URLView *s = new URLView(BRect(x,y,x+b,y+h+3), id, text, url); //Correction of Height +3 added,because text wasn't fully displayed. Lorglas
s->SetHoverEnabled(true);
if(w->layout == -1)
s->SetResizingMode(B_FOLLOW_RIGHT|B_FOLLOW_BOTTOM);
else
s->SetResizingMode(w->layout);
s->SetFlags(B_WILL_DRAW);
myView->AddChild(s);
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
Error(view, "VIEW");
}
void YabInterface::TextURL(const char* id, const char* option, int r, int g, int b)
{
int opt = 0;
BString t(option);
if(t.IFindFirst("label") != B_ERROR) opt = 1;
if(t.IFindFirst("click") != B_ERROR) opt = 2;
if(t.IFindFirst("mouse-over") != B_ERROR) opt = 3;
YabView *myView = NULL;
URLView *myURLView = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myURLView = cast_as(myView->FindView(id), URLView);
if(myURLView)
{
rgb_color col = {r,g,b,255};
switch(opt)
{
case 1: myURLView->SetColor(col);
break;
case 2: myURLView->SetClickColor(col);
break;
case 3: myURLView->SetHoverColor(col);
break;
default: break;
}
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(id, "TEXTURL");
}
void YabInterface::Menu(const char* menuHead, int isRadio, const char* view)
{
bool radio = isRadio?true:false;
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
BMenuBar *menubar;
BMenu *menu = NULL;
BMenuItem *item = NULL;
w->Lock();
menubar = cast_as(myView->FindView("menubar"), BMenuBar);
if(menubar != NULL)
{
for(int i=0; i<menubar->CountItems(); i++)
if(!strcmp( menubar->ItemAt(i)->Label(), menuHead))
{
menu = menubar->SubmenuAt(i);
menu->SetRadioMode(radio);
break;
}
}
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
Error(view, "VIEW");
}
void YabInterface::SubMenu(const char* menuHead, const char* menuItem, const char* subMenuItem, const char* shortcut, const char* view)
{
char myShortcut;
int32 modifiers = 0;
BString t(shortcut);
if(t.Length()>1)
{
myShortcut = shortcut[t.Length()-1];
if(t.IFindFirst("s")!=B_ERROR && t.IFindFirst("s")<t.Length()-1)
modifiers = modifiers|B_SHIFT_KEY;
if(t.IFindFirst("c")!=B_ERROR && t.IFindFirst("c")<t.Length()-1)
modifiers = modifiers|B_CONTROL_KEY;
if(t.IFindFirst("o")!=B_ERROR && t.IFindFirst("o")<t.Length()-1)
modifiers = modifiers|B_OPTION_KEY;
}
else
myShortcut = shortcut[0];
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(!strcmp(menuItem, "--"))
return;
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
BMenuBar *menubar;
YabMenu *menu = NULL;
YabMenu *submenu = NULL;
BMenuItem *item = NULL;
w->Lock();
menubar = cast_as(myView->FindView("menubar"), BMenuBar);
if(menubar == NULL)
{
menubar = new BMenuBar(myView->Bounds(),"menubar");
myView->AddChild(menubar);
}
for(int i=0; i<menubar->CountItems(); i++)
if(!strcmp( menubar->ItemAt(i)->Label(), menuHead))
menu = (YabMenu*)menubar->SubmenuAt(i);
if(menu == NULL)
{
menu = new YabMenu(menuHead);
menubar->AddItem(menu);
}
int isInMenu = -1;
for(int i=0; i<menu->CountItems(); i++)
if(!strcmp(menu->ItemAt(i)->Label(), menuItem))
{
isInMenu = i;
break;
}
if(isInMenu == -1)
{
submenu = new YabMenu(menuItem);
menu->AddItem(submenu);
}
else
{
submenu = cast_as(menu->SubmenuAt(isInMenu),YabMenu);
if(submenu == NULL)
{
BMenuItem *myItem = menu->RemoveItem(isInMenu);
delete myItem;
submenu = new YabMenu(menuItem);
menu->AddItem(submenu, isInMenu);
}
}
if(!strcmp(subMenuItem,"--"))
submenu->AddItem(new BSeparatorItem());
else
submenu->AddItem(new BMenuItem(subMenuItem, new BMessage(YABSUBMENU), myShortcut, modifiers));
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
Error(view, "VIEW");
}
void YabInterface::SubMenu(const char* menuHead, const char* menuItem, int isRadio, const char* view)
{
bool radio = isRadio?true:false;
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
BMenuBar *menubar;
BMenu *menu = NULL;
BMenu *submenu = NULL;
BMenuItem *item = NULL;
w->Lock();
menubar = cast_as(myView->FindView("menubar"), BMenuBar);
if(menubar != NULL)
{
for(int i=0; i<menubar->CountItems(); i++)
if(!strcmp( menubar->ItemAt(i)->Label(), menuHead))
{
menu = menubar->SubmenuAt(i);
for(int j=0; j<menu->CountItems(); j++)
if(!strcmp( menu->ItemAt(j)->Label(), menuItem))
{
submenu = menu->SubmenuAt(j);
if(submenu)
{
submenu->SetRadioMode(radio);
break;
}
}
if(submenu) break;
}
}
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
Error(view, "VIEW");
}
int YabInterface::ColorControlGet(const char* colorcontrol, const char* option)
{
int ret = -1;
int myOption = -1;
BString myString(option);
if(myString.IFindFirst("Red") != B_ERROR) myOption = 0;
if(myString.IFindFirst("Green") != B_ERROR) myOption = 1;
if(myString.IFindFirst("Blue") != B_ERROR) myOption = 2;
if(myOption<0) ErrorGen("Unknown option");
YabView *myView = NULL;
BColorControl *myCControl = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView && myOption>-1)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myCControl = cast_as(myView->FindView(colorcontrol), BColorControl);
if(myCControl)
{
rgb_color t = myCControl->ValueAsColor();
switch(myOption)
{
case 0: ret = t.red;
break;
case 1: ret = t.green;
break;
case 2: ret = t.blue;
break;
}
w->Unlock();
return ret;
}
w->Unlock();
}
}
}
Error(colorcontrol, "COLORCONTROL");
}
int YabInterface::SliderGet(const char* slider)
{
int ret = -1;
YabView *myView = NULL;
BSlider *mySlider = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
mySlider = cast_as(myView->FindView(slider), BSlider);
if(mySlider)
{
ret = mySlider->Value();
w->Unlock();
return ret;
}
w->Unlock();
}
}
}
Error(slider, "SLIDER");
}
void YabInterface::SubMenu3(const char* menuHead, const char* menuItem, const char* subMenuItem, const char* option, const char* view)
{
int myOption = -1;
BString t(option);
if(t.IFindFirst("disable")!=B_ERROR) myOption = 0;
if(t.IFindFirst("enable")!=B_ERROR) myOption = 1;
if(t.IFindFirst("mark")!=B_ERROR) myOption = 2;
if(t.IFindFirst("plain")!=B_ERROR) myOption = 3;
if(t.IFindFirst("remove")!=B_ERROR) myOption = 4;
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView && myOption>-1)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
BMenuBar *menubar;
BMenu *menu = NULL;
BMenu *submenu = NULL;
BMenuItem *item = NULL;
w->Lock();
menubar = cast_as(myView->FindView("menubar"), BMenuBar);
if(menubar)
{
for(int i=0; i<menubar->CountItems(); i++)
{
if(!strcmp( menubar->ItemAt(i)->Label(), menuHead))
{
menu = menubar->SubmenuAt(i);
for(int j=0; j<menu->CountItems(); j++)
{
if(!strcmp( menu->ItemAt(j)->Label(), menuItem))
{
submenu = menu->SubmenuAt(j);
if(submenu)
{
for(int k=0; k<submenu->CountItems(); k++)
{
if(!strcmp( submenu->ItemAt(k)->Label(), subMenuItem))
{
switch(myOption)
{
case 0:
submenu->ItemAt(k)->SetEnabled(false);
break;
case 1:
submenu->ItemAt(k)->SetEnabled(true);
break;
case 2:
submenu->ItemAt(k)->SetMarked(true);
break;
case 3:
submenu->ItemAt(k)->SetMarked(false);
break;
case 4:
submenu->RemoveItem( submenu->ItemAt(k) );
if(submenu->CountItems() == 0) {
if(menu->RemoveItem(submenu))
menu->AddItem(new BMenuItem(menuItem, new BMessage(YABMENU)), j);
}
break;
}
break;
}
}
}
}
}
}
}
}
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
if(myOption>-1) Error(view, "VIEW");
else ErrorGen("Unknown option");
}
void YabInterface::Menu3(const char* menuHead, const char* menuItem, const char* option,const char* view)
{
int myOption = -1;
BString t(option);
if(t.IFindFirst("disable")!=B_ERROR) myOption = 0;
if(t.IFindFirst("enable")!=B_ERROR) myOption = 1;
if(t.IFindFirst("mark")!=B_ERROR) myOption = 2;
if(t.IFindFirst("plain")!=B_ERROR) myOption = 3;
if(t.IFindFirst("remove")!=B_ERROR) myOption = 4;
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView && myOption>-1)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
BMenuBar *menubar;
BMenu *menu = NULL;
// BMenuItem *item = NULL;
w->Lock();
menubar = cast_as(myView->FindView("menubar"), BMenuBar);
if(menubar != NULL)
{
for(int i=0; i<menubar->CountItems(); i++)
if(!strcmp( menubar->ItemAt(i)->Label(), menuHead))
{
menu = menubar->SubmenuAt(i);
for(int j=0; j<menu->CountItems(); j++)
if(!strcmp( menu->ItemAt(j)->Label(), menuItem))
{
switch(myOption)
{
case 0:
menu->ItemAt(j)->SetEnabled(false);
break;
case 1:
menu->ItemAt(j)->SetEnabled(true);
break;
case 2:
menu->ItemAt(j)->SetMarked(true);
break;
case 3:
menu->ItemAt(j)->SetMarked(false);
break;
case 4:
menu->RemoveItem( menu->ItemAt(j) );
}
break;
}
}
}
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
if(myOption>-1) Error(view, "VIEW");
else ErrorGen("Unknown option");
}
void YabInterface::SpinControl(double x, double y, const char* id, const char* label, int min, int max, int step, const char* view)
{
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
Spinner *mySpin = new Spinner(BRect(x,y,x+10,y+10), id, label, min, max, step, NULL);
if(w->layout == -1)
mySpin->SetResizingMode(B_FOLLOW_RIGHT|B_FOLLOW_BOTTOM);
else
mySpin->SetResizingMode(w->layout);
myView->AddChild(mySpin);
mySpin->SetViewColor(myView->ViewColor());
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
Error(view, "VIEW");
}
void YabInterface::SpinControl(const char* spinControl, int value)
{
YabView *myView = NULL;
Spinner *mySpin = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
mySpin = cast_as(myView->FindView(spinControl),Spinner);
if(mySpin)
{
mySpin->SetValue(value);
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(spinControl, "SPINCONTROL");
}
int YabInterface::SpinControlGet(const char *spinControl)
{
int ret = 0;
YabView *myView = NULL;
Spinner *mySpin = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
mySpin = cast_as(myView->FindView(spinControl),Spinner);
if(mySpin)
{
ret = mySpin->Value();
w->Unlock();
return ret;
}
w->Unlock();
}
}
}
Error(spinControl, "SPINCONTROL");
}
const char* YabInterface::PopUpMenu(double x, double y, const char* menuItems, const char* view)
{
BString t(menuItems);
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
const char* res;
w->Lock();
BPopUpMenu *returnMe = new BPopUpMenu( "YabPopup", false, false );
returnMe->SetAsyncAutoDestruct(true);
int oldi = 0;
for(int i=0; i<t.Length(); i++)
if(t[i]=='|')
{
BString j;
t.CopyInto(j,oldi, i-oldi);
if(j == "--")
returnMe->AddItem(new BSeparatorItem());
else
returnMe->AddItem(new BMenuItem(_L(j.String()), NULL));
oldi=i+1;
}
BString j;
t.CopyInto(j,oldi, t.Length()-oldi);
returnMe->AddItem(new BMenuItem(j.String(), NULL));
BMenuItem *result = returnMe->Go(myView->ConvertToScreen(BPoint(x,y)), false, true);
if(result)
{
res = result->Label();
w->Unlock();
return res;
}
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
Error(view, "VIEW");
return "";
}
void YabInterface::DropBoxSelect(const char* dropbox, int position)
{
YabView *myView = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BMenuField *myMenuField = cast_as(myView->FindView(dropbox), BMenuField);
if(myMenuField)
{
BMenu *myMenu = (BMenu*)myMenuField->Menu();
if(myMenu)
{
if(position<1) position = 1;
if(position>=myMenu->CountItems())
position = myMenu->CountItems();
if(myMenu->CountItems()!=0)
(myMenu->ItemAt(position-1))->SetMarked(true);
w->Unlock();
return;
}
}
w->Unlock();
}
}
}
Error(dropbox, "DROPBOX");
}
void YabInterface::DropBoxClear(const char* dropbox)
{
YabView *myView = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BMenuField *myMenuField = cast_as(myView->FindView(dropbox), BMenuField);
if(myMenuField)
{
BMenu *myMenu = (BMenu*)myMenuField->Menu();
if(myMenu)
{
while(myMenu->CountItems()>0)
{
BMenuItem *myItem = myMenu->RemoveItem(myMenu->CountItems()-1);
delete myItem;
}
// bad workaround! Add an empty MenuItem and delete it again
// so that the menu changes
BMenuItem *myItem = new BMenuItem("", NULL);
myMenu->AddItem(myItem);
myItem->SetMarked(true);
myMenu->RemoveItem(myItem);
delete myItem;
w->Unlock();
return;
}
}
w->Unlock();
}
}
}
Error(dropbox, "DROPBOX");
}
void YabInterface::DropBoxRemove(const char* dropbox, int position)
{
YabView *myView = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BMenuField *myMenuField = cast_as(myView->FindView(dropbox), BMenuField);
if(myMenuField)
{
BMenu *myMenu = (BMenu*)myMenuField->Menu();
if(myMenu)
{
position --;
if(position<0) position = 0;
if(position>=myMenu->CountItems())
position = myMenu->CountItems()-1;
if(myMenu->CountItems()!=0)
{
BMenuItem *myItem = myMenu->ItemAt(position);
if(myItem->IsMarked())
{
if(myMenu->CountItems()>1 && position>0)
(myMenu->ItemAt(position-1))->SetMarked(true);
else if(myMenu->CountItems()>1 && position == 0)
(myMenu->ItemAt(position+1))->SetMarked(true);
else
{
BMenuItem *myItem = new BMenuItem("", NULL);
myMenu->AddItem(myItem);
myItem->SetMarked(true);
myMenu->RemoveItem(myItem);
delete myItem;
}
}
myMenu->RemoveItem(myItem);
delete myItem;
}
w->Unlock();
return;
}
}
w->Unlock();
}
}
}
Error(dropbox, "DROPBOX");
}
int YabInterface::DropBoxCount(const char* dropbox)
{
int ret = -1;
YabView *myView = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BMenuField *myMenuField = cast_as(myView->FindView(dropbox), BMenuField);
if(myMenuField)
{
BMenu *myMenu = (BMenu*)myMenuField->Menu();
if(myMenu)
{
ret = myMenu->CountItems();
w->Unlock();
return ret;
}
}
w->Unlock();
}
}
}
Error(dropbox, "DROPBOX");
}
const char* YabInterface::DropBoxGet(const char* dropbox, int position)
{
YabView *myView = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BMenuField *myMenuField = cast_as(myView->FindView(dropbox), BMenuField);
if(myMenuField)
{
BMenu *myMenu = (BMenu*)myMenuField->Menu();
if(myMenu)
{
const char *ret;
position --;
if(position<0) position = 0;
if(position>=myMenu->CountItems())
position = myMenu->CountItems()-1;
if(myMenu->CountItems()!=0)
{
ret = (myMenu->ItemAt(position))->Label();
w->Unlock();
return ret;
}
else
{
w->Unlock();
return "";
}
}
}
w->Unlock();
}
}
}
Error(dropbox, "DROPBOX");
}
double YabInterface::MenuHeight()
{
double ret = -1;
for(int i=0; i<CountWindows(); i++)
{
YabWindow *w = cast_as(WindowAt(i), YabWindow);
if(w)
{
BMenuBar *menubar;
w->Lock();
menubar = cast_as(w->FindView("menubar"), BMenuBar);
if(menubar)
{
ret = menubar->Bounds().bottom - menubar->Bounds().top;
w->Unlock();
break;
}
w->Unlock();
}
}
return ret;
}
double YabInterface::TabHeight()
{
BFont f = be_plain_font;
font_height fh;
f.GetHeight(&fh);
return fh.ascent + fh.descent + fh.leading + 10.0f;
}
double YabInterface::ScrollbarWidth()
{
return B_H_SCROLL_BAR_HEIGHT;
}
const int YabInterface::IsMouseIn(const char* view)
{
int t = 2;
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
t = myView->mouseMovedInfo;
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
Error(view, "VIEW");
return 1-t;
}
const char* YabInterface::GetMouseIn()
{
snooze(20000);
BString ts;
mousemessagebuffer[0] = '\0';
int handled = -1;
YabView *myView = NULL;
for(int i=0; i<CountWindows(); i++)
{
YabWindow *w = cast_as(WindowAt(i), YabWindow);
if(w && w->IsActive())
{
w->Lock();
BView *view = w->LastMouseMovedView();
if(!view)
{
w->Unlock();
break;
}
if(is_kind_of(view->Parent(), BTextControl))
view = view->Parent();
if(is_kind_of(view->Parent(), Spinner))
view = view->Parent();
if(is_kind_of(view->Parent(), CalendarControl))
view = view->Parent();
if(is_kind_of(view->Parent(), BColorControl))
view = view->Parent();
if(is_kind_of(view->Parent(), YabText))
view = view->Parent();
if(is_kind_of(view->Parent(), BColumnListView))
view = view->Parent();
if(is_kind_of(view, BBox))
view = view->Parent();
if(is_kind_of(view, BMenuBar))
view = view->Parent();
BString name = view->Name();
BPoint coordinates;
uint32 buttons;
view->GetMouse(&coordinates, &buttons);
ts << name << ":" << (int)coordinates.x << ":" << (int)coordinates.y << ":";
if(buttons & B_PRIMARY_MOUSE_BUTTON)
ts << 1 << ":";
else
ts << 0 << ":";
if(buttons & B_TERTIARY_MOUSE_BUTTON)
ts << 1 << ":";
else
ts << 0 << ":";
if(buttons & B_SECONDARY_MOUSE_BUTTON)
ts << 1;
else
ts << 0;
w->Unlock();
}
}
strcpy(mousemessagebuffer, ts.String());
return (char*)mousemessagebuffer;
}
const char* YabInterface::KeyboardMessages(const char* view)
{
snooze(20000);
keyboardbuffer[0] = '\0';
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
BString t("");
w->Lock();
// if(!myView->IsFocus()) myView->MakeFocus(true);
if(myView->IsFocus())
t << myView->pressedKeys;
w->Unlock();
strcpy(keyboardbuffer, t.String());
}
else
ErrorGen("Unable to lock window");
}
else
Error(view, "VIEW");
return (char*)keyboardbuffer;
}
const char* YabInterface::GetMouseMessages(const char* view)
{
snooze(20000);
mousemessagebuffer[0] = '\0';
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
BString t("");
w->Lock();
t << myView->mouseX; t += ":";
t << myView->mouseY; t += ":";
t << myView->mouseLButton; t += ":";
t << myView->mouseMButton; t += ":";
t << myView->mouseRButton;
w->Unlock();
strcpy(mousemessagebuffer, t.String());
}
else
ErrorGen("Unable to lock window");
}
else
{
for(int i=0; i<yabcanvas->CountItems(); i++)
{
YabBitmapView *myView = (YabBitmapView*)yabcanvas->ItemAt(i);
if(!strcmp(myView->Name(), view))
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
BString t("");
w->Lock();
t << myView->mouseX; t += ":";
t << myView->mouseY; t += ":";
t << myView->mouseLButton; t += ":";
t << myView->mouseMButton; t += ":";
t << myView->mouseRButton;
w->Unlock();
strcpy(mousemessagebuffer, t.String());
return (char*)mousemessagebuffer;
}
else
ErrorGen("Unable to lock window");
}
}
Error(view, "VIEW");
}
return (char*)mousemessagebuffer;
}
int YabInterface::ThreadKill(const char* option, int id)
{
int isTeam = -1;
int ret = 0;
BString t(option);
if(t.IFindFirst("teamid")!=B_ERROR) isTeam = 1;
if(t.IFindFirst("threadid")!=B_ERROR) isTeam = 0;
if(isTeam==1)
{
if(kill_team(id)==B_OK) ret = 1;
}
else if(isTeam==0)
{
if(kill_thread(id)==B_OK) ret = 1;
}
else
ErrorGen("Unknown Option");
return ret;
}
int YabInterface::ThreadGet(const char* option, const char* appname)
{
int isTeam = -1;
int ret = -1;
BString t(option);
if(t.IFindFirst("teamid")!=B_ERROR) isTeam = 1;
if(t.IFindFirst("threadid")!=B_ERROR) isTeam = 0;
if(isTeam==0)
{
ret = find_thread(appname);
if(ret == B_NAME_NOT_FOUND) ret = -1;
}
else if(isTeam==1)
{
int32 cookie=0;
team_info info;
BString t(appname);
while (get_next_team_info(&cookie, &info) == B_OK)
{
if(t.FindFirst(info.args)==B_OK)
{
ret = info.team;
break;
}
}
}
else
ErrorGen("Unknown Option");
return ret;
}
//Correction of Subitem by Stephan Aßmus on BeGeistert 2018
void YabInterface::Bitmap(double w, double h, const char* id)
{
char *t;
BBitmap *b = new BBitmap(BRect(0,0,w-1,h-1), B_RGBA32, true);
BView *bview = new BView(BRect(0,0,w-1,h-1), id, B_FOLLOW_NONE, 0);
//bview->SetDrawingMode(B_OP_ALPHA);
//bview->SetViewColor(255,255,255,255);
b->AddChild(bview);
memset(b->Bits(), 0, b->BitsLength());
// t = (char*)b->Bits();
// for(int i=0; i<w*h*4; i = i + 4)
// {
// t[i] = t[i+1] = t[i+2] = 255;
// t[i+3] = 0;
// }
yabbitmaps->AddItem(b);
}
int YabInterface::BitmapColor(double x, double y, const char* bitmap, const char* option)
{
int rgb = 0;
BString tmp(option);
if(tmp.IFindFirst("red")!=B_ERROR) rgb = 1;
else if(tmp.IFindFirst("green")!=B_ERROR) rgb = 2;
else if(tmp.IFindFirst("blue")!=B_ERROR) rgb = 3;
else
ErrorGen("Unknown Option");
for(int i=0; i<yabbitmaps->CountItems(); i++)
{
BBitmap *b = (BBitmap*)yabbitmaps->ItemAt(i);
BView *bview = b->FindView(bitmap);
if(bview)
{
int t = b->BytesPerRow()*(int)y + (int)x*4;
unsigned char* bits = (unsigned char*)b->Bits();
if(t <= b->BitsLength())
if(rgb == 1)
return (int)bits[t];
else if(rgb == 2)
return (int)bits[t+1];
else if(rgb == 3)
return (int)bits[t+2];
return 0;
}
}
Error(bitmap, "BITMAP");
}
void YabInterface::BitmapDraw(double x, double y, const char* bitmap, const char* mode, const char* view)
{
drawing_mode myMode;
BString tmp(mode);
if(tmp.IFindFirst("copy")!=B_ERROR)
myMode = B_OP_COPY;
else if(tmp.IFindFirst("alpha")!=B_ERROR)
myMode = B_OP_ALPHA;
else
ErrorGen("Unknown option");
for(int i=0; i<yabbitmaps->CountItems(); i++)
{
BBitmap *b = (BBitmap*)yabbitmaps->ItemAt(i);
BView *bview = b->FindView(bitmap);
if(bview)
{
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
BBitmap *newb = new BBitmap(b->Bounds(), B_RGBA32);
char* newbits = (char*)newb->Bits();
char* oldbits = (char*)b->Bits();
for(int j=0; j<b->BitsLength(); j++)
newbits[j] = oldbits[j];
w->Lock();
YabDrawing *t = new YabDrawing();
t->command = 10;
t->x1 = x; t->y1 = y;
t->bitmap = newb;
myView->drawList->AddItem(t);
myView->Invalidate();
w->Unlock();
return;
}
else
ErrorGen("Unable to lock window");
}
else
{
for(int i=0; i<yabbitmaps->CountItems(); i++)
{
BBitmap *bb = (BBitmap*)yabbitmaps->ItemAt(i);
BView *bbview = bb->FindView(view);
if(bbview)
{
bb->Lock();
drawing_mode t = bbview->DrawingMode();
bbview->SetDrawingMode(myMode);
bbview->DrawBitmap(b, BPoint(x,y));
bbview->SetDrawingMode(t);
bbview->Sync();
bb->Unlock();
return;
}
}
for(int i=0; i<yabcanvas->CountItems(); i++)
{
YabBitmapView *myView = (YabBitmapView*)yabcanvas->ItemAt(i);
if(!strcmp(myView->Name(), view))
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BBitmap *bb = myView->GetBitmap();
BView *bView = myView->GetBitmapView();
bb->Lock();
drawing_mode t = bView->DrawingMode();
bView->SetDrawingMode(myMode);
bView->DrawBitmap(b, BPoint(x,y));
bView->Sync();
bView->SetDrawingMode(t);
bb->Unlock();
myView->Draw(BRect(x,y,x+b->Bounds().Width(),y+b->Bounds().Height()));
w->Unlock();
return;
}
else
ErrorGen("Unable to lock window");
}
}
Error(view, "VIEW, BITMAP or CANVAS");
}
}
}
Error(bitmap, "BITMAP");
}
void YabInterface::BitmapDraw(BRect frame, const char* bitmap, const char* mode, const char* view)
{
int scaling = 0;
if(frame.right == -1) scaling = 1;
if(frame.bottom == -1) scaling = 2;
if(frame.right == -1 && frame.bottom == -1) scaling = 3;
drawing_mode myMode;
BString tmp(mode);
if(tmp.IFindFirst("copy")!=B_ERROR)
myMode = B_OP_COPY;
else if(tmp.IFindFirst("alpha")!=B_ERROR)
myMode = B_OP_ALPHA;
else
ErrorGen("Unknown option");
for(int i=0; i<yabbitmaps->CountItems(); i++)
{
BBitmap *b = (BBitmap*)yabbitmaps->ItemAt(i);
BView *bview = b->FindView(bitmap);
if(bview)
{
BRect newframe;
switch(scaling)
{
case 1:
{
BRect t(b->Bounds());
double width;
newframe = frame;
width = (t.right-t.left)*((frame.bottom-frame.top)/(t.bottom-t.top));
newframe.right = newframe.left+width;
}
break;
case 2:
{
BRect t(b->Bounds());
double height;
newframe = frame;
height = (t.bottom-t.top)*((frame.right-frame.left)/(t.right-t.left));
newframe.bottom = newframe.top+height;
}
break;
case 3: newframe = b->Bounds();
break;
default: newframe = frame;
}
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
BBitmap *newb = new BBitmap(b->Bounds(), B_RGBA32);
char* newbits = (char*)newb->Bits();
char* oldbits = (char*)b->Bits();
for(int j=0; j<b->BitsLength(); j++)
newbits[j] = oldbits[j];
w->Lock();
YabDrawing *t = new YabDrawing();
t->command = 11;
t->x1 = newframe.left; t->y1 = newframe.top;
t->x2 = newframe.right; t->y2 = newframe.bottom;
t->bitmap = newb;
myView->drawList->AddItem(t);
myView->Invalidate();
w->Unlock();
return;
}
else
ErrorGen("Unable to lock window");
}
else
{
for(int i=0; i<yabbitmaps->CountItems(); i++)
{
BBitmap *bb = (BBitmap*)yabbitmaps->ItemAt(i);
BView *bbview = bb->FindView(view);
if(bbview)
{
bb->Lock();
drawing_mode t = bbview->DrawingMode();
bbview->SetDrawingMode(myMode);
bbview->DrawBitmap(b, newframe);
bbview->SetDrawingMode(t);
bbview->Sync();
bb->Unlock();
return;
}
}
for(int i=0; i<yabcanvas->CountItems(); i++)
{
YabBitmapView *myView = (YabBitmapView*)yabcanvas->ItemAt(i);
if(!strcmp(myView->Name(), view))
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BBitmap *bb = myView->GetBitmap();
BView *bView = myView->GetBitmapView();
bb->Lock();
drawing_mode t = bView->DrawingMode();
bView->SetDrawingMode(myMode);
bView->DrawBitmap(b, frame);
bView->Sync();
bView->SetDrawingMode(t);
bb->Unlock();
myView->Draw(newframe);
w->Unlock();
return;
}
else
ErrorGen("Unable to lock window");
}
}
Error(view, "VIEW, BITMAP or CANVAS");
}
}
}
Error(bitmap, "BITMAP");
}
//Correction added of Width and Height and transparency Pixel of the right and bottom side
void YabInterface::BitmapGet(BRect frame, const char* id, const char* bitmap)
{
for(int i=0; i<yabbitmaps->CountItems(); i++)
{
BBitmap *b = (BBitmap*)yabbitmaps->ItemAt(i);
BView *bview = b->FindView(bitmap);
if(bview)
{
char *oldbits, *newbits;
BBitmap *newbmp = new BBitmap(BRect(0,0, frame.Width()-1, frame.Height()-1), B_RGBA32, true); //-1 Added, because correction of right and height limit
BView *newbview = new BView(BRect(0,0, frame.Width()-1, frame.Height()-1), id, B_FOLLOW_NONE, 0);//-1 Added, because correction of right and height limit
newbmp->AddChild(newbview);
newbits = (char*)newbmp->Bits();
for(int i=0; i<(frame.Width()-1)*(frame.Height()-1)*4; i = i + 4) //-1 Added, because correction of right and height limit
{
newbits[i] = newbits[i+1] = newbits[i+2] = 255;
newbits[i+3] = 0;
}
oldbits = (char*)b->Bits();
b->Lock();
BRect tframe = bview->Bounds();
b->Unlock();
if(frame.top>tframe.bottom || frame.left>tframe.right || (frame.bottom-1)>tframe.bottom || (frame.right-1)>tframe.right || frame.top<0 || frame.left<0 || frame.right<0 || frame.bottom<0)
ErrorGen("Out of bounds");
for(int32 j = 0; j<frame.IntegerHeight(); j++)
for(int32 k = 0; k<frame.IntegerWidth(); k++)
for(int32 l = 0; l<4; l++)
newbits[j*newbmp->BytesPerRow()+k*4+l] = oldbits[(int32)((j+frame.top)*b->BytesPerRow()+(k+frame.left)*4+l)];
yabbitmaps->AddItem(newbmp);
return;
}
}
for(int i=0; i<yabcanvas->CountItems(); i++)
{
YabBitmapView *myView = (YabBitmapView*)yabcanvas->ItemAt(i);
if(!strcmp(myView->Name(), bitmap))
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BBitmap *b = myView->GetBitmap();
char *oldbits, *newbits;
BBitmap *newbmp = new BBitmap(BRect(0,0, frame.Width()-1, frame.Height()-1), B_RGBA32, true);//-1 Added, because correction of right and height limit
BView *newbview = new BView(BRect(0,0, frame.Width()-1, frame.Height()-1), id, B_FOLLOW_NONE, 0);//-1 Added, because correction of right and height limit
newbmp->AddChild(newbview);
newbits = (char*)newbmp->Bits();
for(int i=0; i<(frame.Width()-1)*(frame.Height()-1)*4; i = i + 4) //-1 Added, because correction of right and height limit
{
newbits[i] = newbits[i+1] = newbits[i+2] = 255;
newbits[i+3] = 0;
}
oldbits = (char*)b->Bits();
BRect tframe = myView->Bounds();
if(frame.top>tframe.bottom || frame.left>tframe.right || (frame.bottom-1)>tframe.bottom || (frame.right-1)>tframe.right || frame.top<0 || frame.left<0 || frame.right<0 || frame.bottom<0)
ErrorGen("Out of bounds");
for(int32 j = 0; j<frame.IntegerHeight(); j++)
for(int32 k = 0; k<frame.IntegerWidth(); k++)
for(int32 l = 0; l<4; l++)
newbits[j*newbmp->BytesPerRow()+k*4+l] = oldbits[(int32)((j+frame.top)*b->BytesPerRow()+(k+frame.left)*4+l)];
yabbitmaps->AddItem(newbmp);
w->Unlock();
return;
}
}
}
Error(bitmap, "BITMAP or CANVAS");
}
void YabInterface::BitmapGet(double w, const char* id, const char* path)
{
double h = w;
BRect iFrame = BRect(0, 0, w-1, h-1);
BBitmap *iBitmap = new BBitmap(iFrame, B_CMAP8, true);
BBitmap *fBitmap = new BBitmap(iFrame, B_RGBA32, true);
BView *bview = new BView(iFrame, id, B_FOLLOW_NONE, 0);
fBitmap->AddChild(bview);
//memset(fBitmap->Bits(), 0, fBitmap->BitsLength());
char *b;
b = (char*)fBitmap->Bits();
for(int i=0; i<w*h*4; i = i + 4)
{
b[i] = b[i+1] = b[i+2] = 255;
b[i+3] = 0;
}
BNode *fNode = new BNode(path);
BNodeInfo fInfo(fNode);
int i;
i=int(w);
icon_size ics;
ics=(icon_size)i;
fInfo.GetTrackerIcon( iBitmap, ics );
fBitmap->Lock();
bview->DrawBitmap( iBitmap, iFrame );
fBitmap->Unlock();
delete fNode;
delete iBitmap;
yabbitmaps->AddItem(fBitmap);
}
void YabInterface::BitmapGetIcon(const char* id, const char* option, const char* path)
{
BString fString(option);
if( fString.IFindFirst("Path") != B_ERROR )
{
int w;
int h = w = 32;
BRect iFrame = BRect(0, 0, w-1, h-1);
BBitmap *iBitmap = new BBitmap(iFrame, B_CMAP8, true);
BBitmap *fBitmap = new BBitmap(iFrame, B_RGBA32, true);
BView *bview = new BView(iFrame, id, B_FOLLOW_NONE, 0);
fBitmap->AddChild(bview);
char *b;
//memset(fBitmap->Bits(), 0, fBitmap->BitsLength());
b = (char*)fBitmap->Bits();
for(int i=0; i<w*h*4; i = i + 4)
{
b[i] = b[i+1] = b[i+2] = 255;
b[i+3] = 0;
}
BNode *fNode = new BNode(path);
BNodeInfo fInfo(fNode);
fInfo.GetTrackerIcon( iBitmap, B_LARGE_ICON );
fBitmap->Lock();
bview->DrawBitmap( iBitmap, iFrame );
fBitmap->Unlock();
delete fNode;
delete iBitmap;
yabbitmaps->AddItem(fBitmap);
}
else if( fString.IFindFirst("Mime") != B_ERROR )
{
int w;
int h = w = 16;
icon_size iType = B_MINI_ICON;
if( fString.IFindFirst("Mime32") != B_ERROR )
{
h = w = 32;
iType = B_LARGE_ICON;
}
BRect iFrame = BRect(0, 0, w-1, h-1);
BBitmap *iBitmap = new BBitmap(iFrame, B_CMAP8, true);
BBitmap *fBitmap = new BBitmap(iFrame, B_RGBA32, true);
BView *bview = new BView(iFrame, id, B_FOLLOW_NONE, 0);
fBitmap->AddChild(bview);
char *b;
memset(fBitmap->Bits(), 0, fBitmap->BitsLength());
b = (char*)fBitmap->Bits();
for(int i=0; i<w*h*4; i = i + 4)
{
b[i] = b[i+1] = b[i+2] = 255;
b[i+3] = 0;
}
BMimeType mime(path);
mime.GetIcon(iBitmap, iType);
fBitmap->Lock();
bview->DrawBitmap(iBitmap, iFrame);
bview->Sync();
fBitmap->Unlock();
delete iBitmap;
yabbitmaps->AddItem(fBitmap);
}
else
ErrorGen("Unknown option");
}
void YabInterface::BitmapDrag(const char* bitmap)
{
}
void YabInterface::BitmapRemove(const char* bitmap)
{
for(int i=0; i<yabbitmaps->CountItems(); i++)
{
BBitmap *b = (BBitmap*)yabbitmaps->ItemAt(i);
BView *bview = b->FindView(bitmap);
if(bview)
{
yabbitmaps->RemoveItem(i);
delete b;
return;
}
}
Error(bitmap, "BITMAP");
}
void YabInterface::Screenshot(BRect frame, const char* bitmap)
{
char *t;
int w = (int)frame.Width()-1;
int h = (int)frame.Height()-1;
BRect area = BRect(0,0,w,h);
BBitmap *fBitmap = new BBitmap(area, B_RGBA32, true);
BView *bview = new BView(area, bitmap, B_FOLLOW_NONE, 0);
BScreen screen(B_MAIN_SCREEN_ID);
fBitmap->AddChild(bview);
//memset(fBitmap->Bits(), 0, fBitmap->BitsLength());
t = (char*)fBitmap->Bits();
for(int i=0; i<w*h*4; i = i + 4)
{
t[i] = t[i+1] = t[i+2] = 255;
t[i+3] = 0;
}
screen.WaitForRetrace();
screen.ReadBitmap(fBitmap, false, &frame);
yabbitmaps->AddItem(fBitmap);
}
int YabInterface::BitmapLoad(const char* FileName, const char* id)
{
BBitmap* myBitmap = NULL;
BFile imageFile;
BPath imagePath;
int ret = 0;
if(*FileName=='/')
imageFile.SetTo(FileName, B_READ_ONLY);
else
if(!strcmp(ApplicationDirectory,""))
{
if(imagePath.SetTo((const char*)ApplicationDirectory, FileName)==B_OK)
imageFile.SetTo(imagePath.Path(), B_READ_ONLY);
}
if(imageFile.InitCheck()!=B_OK)
imageFile.SetTo(FileName, B_READ_ONLY);
if(imageFile.InitCheck()!=B_OK)
return 1;
Roster = BTranslatorRoster::Default();
if(!Roster)
return 2;
BBitmapStream Stream;
if(Roster->Translate(&imageFile, NULL, NULL, &Stream, B_TRANSLATOR_BITMAP)<B_OK)
return 3;
if(Stream.DetachBitmap(&myBitmap)!=B_OK)
return 4;
char *t;
BBitmap *b = new BBitmap(myBitmap->Bounds(), B_RGBA32, true);
BView *bview = new BView(myBitmap->Bounds(), id, B_FOLLOW_NONE, 0);
b->AddChild(bview);
/*
t = (char*)b->Bits();
for(int i=0; i<w*h*4; i = i + 4)
{
t[i] = t[i+1] = t[i+2] = 255;
t[i+3] = 0;
}
*/
b->Lock();
drawing_mode mode = bview->DrawingMode();
bview->SetDrawingMode(B_OP_ALPHA);
bview->DrawBitmap(myBitmap, myBitmap->Bounds());
bview->SetDrawingMode(mode);
bview->Sync();
b->Unlock();
delete Roster;
delete myBitmap;
yabbitmaps->AddItem(b);
return 0;
}
int YabInterface::BitmapGet(const char* id, const char* option)
{
BString t(option);
bool isWidth = false;
if(t.IFindFirst("height") != B_ERROR)
isWidth = false;
else if(t.IFindFirst("width") != B_ERROR)
isWidth = true;
else
ErrorGen("Unknown option");
for(int i=0; i<yabbitmaps->CountItems(); i++)
{
BBitmap *b = (BBitmap*)yabbitmaps->ItemAt(i);
BView *bview = b->FindView(id);
if(bview)
{
BRect r = b->Bounds();
if(isWidth)
return r.IntegerWidth(); //+1;
else
return r.IntegerHeight(); //+1;
}
}
Error(id, "BITMAP");
}
int YabInterface::BitmapSave(const char* id, const char* filename, const char* type)
{
uint32 btype;
BString t(type);
if(t.IFindFirst("png") != B_ERROR)
btype = B_PNG_FORMAT;
else if(t.IFindFirst("jpg") != B_ERROR)
btype = B_JPEG_FORMAT;
else if(t.IFindFirst("tga") != B_ERROR)
btype = B_TGA_FORMAT;
else if(t.IFindFirst("tiff") != B_ERROR)
btype = B_TIFF_FORMAT;
else if(t.IFindFirst("ppm") != B_ERROR)
btype = B_PPM_FORMAT;
else if(t.IFindFirst("bmp") != B_ERROR)
btype = B_BMP_FORMAT;
else
ErrorGen("Unknown type");
for(int i=0; i<yabbitmaps->CountItems(); i++)
{
BBitmap *b = (BBitmap*)yabbitmaps->ItemAt(i);
BView *bview = b->FindView(id);
if(bview)
{
BTranslatorRoster *roster = BTranslatorRoster::Default();
BBitmapStream stream(b); // init with contents of bitmap
BFile file(filename, B_CREATE_FILE | B_WRITE_ONLY | B_ERASE_FILE);
if(roster->Translate(&stream, NULL, NULL, &file, btype) != B_OK)
return 1;
else
return 0;
}
}
Error(id, "BITMAP");
}
void YabInterface::Canvas(BRect frame, const char* id, const char* view)
{
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
YabBitmapView *bmpView = new YabBitmapView(frame, id, B_FOLLOW_NONE, B_WILL_DRAW);
if(w->layout == -1)
bmpView->SetResizingMode(B_FOLLOW_RIGHT|B_FOLLOW_BOTTOM);
else
bmpView->SetResizingMode(w->layout);
myView->AddChild(bmpView);
yabcanvas->AddItem(bmpView);
myView->Invalidate(frame);
w->Unlock();
return;
}
}
Error(view, "VIEW");
}
int YabInterface::Sound(const char* filename, int status) //Reactivate Sound Lorglas 2020.01.02
{
BMediaFile* fplayer;
BEntry entry(filename,true);
entry_ref ref;
//entry.GetRef(&ref) ;
// printf("> %s\n", filename);
//Check, if filename is ok
if (entry.InitCheck() == B_OK)
if (entry.GetRef(&ref) == B_OK)
//delete playing fplayer, because we get no ID back from fplayer. So if we didn't deleting fplayer, a second sound will be played and the first one can't be stopped
delete fPlayer;
finished = create_sem(255255255, "yab");
fPlayer = new BFileGameSound(filename, status);
fPlayer->StartPlaying();
printf("%s is playing\n", filename);
acquire_sem(finished);
return 1;
}
void YabInterface::SoundStop(int32) //Reactivate Sound Lorglas 2020.01.02
{
//Check, if fplayer is NULL, then do nothing
if (fPlayer == NULL) {
}
//Check, if fplayer is Playing, then stop playing and delete fplayer
if (fPlayer->IsPlaying()) {
fPlayer->StopPlaying();
// interrupt = true;
kill_thread(reader);
delete fPlayer;
fPlayer = NULL;
}
}
void YabInterface::SoundWait(int32) //Reactivate Sound Lorglas 2020.01.03
{
//Check, if fplayer is in Paused modus, if so Setpaused to false, so play again, if true fplayer paused
if (fPlayer->IsPaused())
{
fPlayer->SetPaused(false, 0);
}
else
{
fPlayer->SetPaused(true, 0);
}
}
void play_buffer(void *cookie, void * buffer, size_t size, const media_raw_audio_format & format)
{
int64 frames = 0;
playTrack->ReadFrames(buffer, &frames);
if (frames <=0) {
player->SetHasData(false);
release_sem(finished);
}
}
int YabInterface::MediaSound(const char* filename) //Implementation MediaSound Lorglas 2020.01.02 code used and modified from media_client
{
BUrl url;
entry_ref ref;
BMediaFile* playFile;
int finished;
BString tempstr;
if (get_ref_for_path(filename, &ref) != B_OK) {
url.SetUrlString(filename);
if (url.IsValid()) {
playFile = new BMediaFile(url);
} else
return 2;
} else
playFile = new BMediaFile(&ref);
if (playFile->InitCheck() != B_OK) {
delete playFile;
return 2;
}
//printf(" %s is playing %sd \n",filename,playFile);
for (int i = 0; i < playFile->CountTracks(); i++)
{
BMediaTrack* track = playFile->TrackAt(i);
if (track != NULL)
{
playFormat.type = B_MEDIA_RAW_AUDIO;
if ((track->DecodedFormat(&playFormat) == B_OK) && (playFormat.type == B_MEDIA_RAW_AUDIO))
{
playTrack = track;
break;
}
playFile->ReleaseTrack(track);
}
}
player = new BSoundPlayer(&playFormat.u.raw_audio, "Yab-Mediaoutput", play_buffer);
//player->SetVolume(1.0f);
player->SetHasData(true);
player->Start();
finished=1;
printf(" %s is playing \n",filename);
return finished;
}
void YabInterface::MediaSoundStop(int32 finished) //New Version Sound Lorglas 2020.01.02
{
//Check, if player is NULL, then do nothing
if (player == NULL) {
}
//Check, if player is Playing, then stop playing and delete player
player->Stop();
delete player;
//finished=0;
}
void YabInterface::SetOption(const char* id, const char* option, double x, double y)
{
BString tmp(option);
YabView *myView = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BView *theView = cast_as(myView->FindView(id), BView);
if(theView)
{
if(tmp.IFindFirst("ResizeTo")!=B_ERROR)
theView->ResizeTo(x,y);
else if(tmp.IFindFirst("ResizeBy")!=B_ERROR)
theView->ResizeBy(x,y);
else if(tmp.IFindFirst("MoveTo")!=B_ERROR)
theView->MoveTo(x,y);
else if(tmp.IFindFirst("MoveBy")!=B_ERROR)
theView->MoveBy(x,y);
else
ErrorGen("Unknown option");
theView->Invalidate();
w->Unlock();
return;
}
w->Unlock();
}
}
}
Error(id, "VIEW");
}
void YabInterface::DrawSet(const char* option, const char* color,const char* view)
{
BString tmp(option);
BString colstr(color);
rgb_color col;
if(colstr.IFindFirst("Panel-Background-Color")!=B_ERROR)
col = ui_color(B_PANEL_BACKGROUND_COLOR);
else if(colstr.IFindFirst("Panel-Text-Color")!=B_ERROR)
{
col = ui_color(B_PANEL_TEXT_COLOR);
}
else if(colstr.IFindFirst("Panel-Link-Color")!=B_ERROR)
{
col.red = 0; col.green = 0; col.blue = 255;
}
else if(colstr.IFindFirst("Menu-Background-Color")!=B_ERROR)
col = ui_color(B_MENU_BACKGROUND_COLOR);
else if(colstr.IFindFirst("Menu-Selection-Background-Color")!=B_ERROR)
col = ui_color(B_MENU_SELECTION_BACKGROUND_COLOR);
else if(colstr.IFindFirst("Menu-Item-Text-Color")!=B_ERROR)
col = ui_color(B_MENU_ITEM_TEXT_COLOR);
else if(colstr.IFindFirst("Menu-Selected-Item-Text-Color")!=B_ERROR)
col = ui_color(B_MENU_SELECTED_ITEM_TEXT_COLOR);
else if(colstr.IFindFirst("Keyboard-Navigation-Color")!=B_ERROR)
col = ui_color(B_KEYBOARD_NAVIGATION_COLOR);
else if(colstr.IFindFirst("Jan-Favorite-Color")!=B_ERROR)
{
col.red = 220; col.green = 220; col.blue = 250;
}
else
ErrorGen("Invalid color");
if(colstr.IFindFirst("Lighten-1-Tint")!=B_ERROR)
col = tint_color(col, B_LIGHTEN_1_TINT);
else if(colstr.IFindFirst("Lighten-2-Tint")!=B_ERROR)
col = tint_color(col, B_LIGHTEN_2_TINT);
else if(colstr.IFindFirst("Lighten-Max-Tint")!=B_ERROR)
col = tint_color(col, B_LIGHTEN_MAX_TINT);
else if(colstr.IFindFirst("Darken-1-Tint")!=B_ERROR)
col = tint_color(col, B_DARKEN_1_TINT);
else if(colstr.IFindFirst("Darken-2-Tint")!=B_ERROR)
col = tint_color(col, B_DARKEN_2_TINT);
else if(colstr.IFindFirst("Darken-3-Tint")!=B_ERROR)
col = tint_color(col, B_DARKEN_3_TINT);
else if(colstr.IFindFirst("Darken-4-Tint")!=B_ERROR)
col = tint_color(col, B_DARKEN_4_TINT);
else if(colstr.IFindFirst("Darken-Max-Tint")!=B_ERROR)
col = tint_color(col, B_DARKEN_MAX_TINT);
else if(colstr.IFindFirst("Disabled-Label-Tint")!=B_ERROR)
col = tint_color(col, B_DISABLED_LABEL_TINT);
else if(colstr.IFindFirst("Disabled-Mark-Tint")!=B_ERROR)
col = tint_color(col, B_DISABLED_MARK_TINT);
else if(colstr.IFindFirst("Highlight-Background-Tint")!=B_ERROR)
col = tint_color(col, B_HIGHLIGHT_BACKGROUND_TINT);
col.alpha = yabAlpha;
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
if(tmp.IFindFirst("BGColor")!=B_ERROR)
{
myView->SetViewColor(col);
myView->Invalidate();
}
else if(tmp.IFindFirst("HighColor")!=B_ERROR)
{
if(yabAlpha == 255)
myView->SetDrawingMode(B_OP_COPY);
else
myView->SetDrawingMode(B_OP_ALPHA);
myView->SetHighColor(col);
YabDrawing *t = new YabDrawing();
t->command = 6;
t->r = col.red; t->g = col.green;
t->b = col.blue; t->alpha = yabAlpha;
myView->drawList->AddItem(t);
}
else if(tmp.IFindFirst("LowColor")!=B_ERROR)
{
if(yabAlpha == 255)
myView->SetDrawingMode(B_OP_COPY);
else
myView->SetDrawingMode(B_OP_ALPHA);
myView->SetLowColor(col);
YabDrawing *t = new YabDrawing();
t->command = 7;
t->r = col.red; t->g = col.green;
t->b = col.blue; t->alpha = yabAlpha;
myView->drawList->AddItem(t);
}
else
ErrorGen("Unknown option");
w->Unlock();
}
else
ErrorGen("Unable to lock window");
}
else
{
for(int i=0; i<yabbitmaps->CountItems(); i++)
{
BBitmap *bmp = (BBitmap*)yabbitmaps->ItemAt(i);
BView *bView = bmp->FindView(view);
if(bView)
{
if(tmp.IFindFirst("HighColor")!=B_ERROR)
{
bmp->Lock();
if(yabAlpha == 255)
bView->SetDrawingMode(B_OP_COPY);
else
bView->SetDrawingMode(B_OP_ALPHA);
bView->SetHighColor(col);
bView->Sync();
bmp->Unlock();
return;
}
else if(tmp.IFindFirst("LowColor")!=B_ERROR)
{
bmp->Lock();
if(yabAlpha == 255)
bView->SetDrawingMode(B_OP_COPY);
else
bView->SetDrawingMode(B_OP_ALPHA);
bView->SetLowColor(col);
bView->Sync();
bmp->Unlock();
return;
}
else
ErrorGen("Unknown option");
}
}
for(int i=0; i<yabcanvas->CountItems(); i++)
{
YabBitmapView *myView = (YabBitmapView*)yabcanvas->ItemAt(i);
if(!strcmp(myView->Name(), view))
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BBitmap *bmp = myView->GetBitmap();
BView *bView = myView->GetBitmapView();
if(tmp.IFindFirst("HighColor")!=B_ERROR)
{
bmp->Lock();
if(yabAlpha == 255)
bView->SetDrawingMode(B_OP_COPY);
else
bView->SetDrawingMode(B_OP_ALPHA);
bView->SetHighColor(col);
bView->Sync();
bmp->Unlock();
w->Unlock();
return;
}
else if(tmp.IFindFirst("LowColor")!=B_ERROR)
{
bmp->Lock();
if(yabAlpha == 255)
bView->SetDrawingMode(B_OP_COPY);
else
bView->SetDrawingMode(B_OP_ALPHA);
bView->SetLowColor(col);
bView->Sync();
bmp->Unlock();
w->Unlock();
return;
}
else
ErrorGen("Unknown option");
}
else
ErrorGen("Unable to lock window");
}
}
Error(view, "VIEW, BITMAP or CANVAS");
}
}
void YabInterface::Treebox13(const char* id,const char* option, int pos)
{
}
int YabInterface::TreeboxGetOpt(const char* id, const char* option, int pos)
{
}
int YabInterface::ListboxGetNum(const char* id)
{
YabView *myView = NULL;
BListView *myList = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myList = cast_as(myView->FindView(id), BListView);
if(myList)
{
int32 t = myList->CurrentSelection();
w->Unlock();
return t+1;
}
w->Unlock();
}
}
}
Error(id, "LISTBOX");
}
int YabInterface::DropboxGetNum(const char* id)
{
YabView *myView = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BMenuField *myMenuField = cast_as(myView->FindView(id), BMenuField);
if(myMenuField)
{
BMenu *myMenu = (BMenu*)myMenuField->Menu();
if(myMenu)
{
int32 ret;
ret = myMenu->IndexOf(myMenu->FindMarked());
w->Unlock();
return ret;
}
}
w->Unlock();
}
}
}
Error(id, "DROPBOX");
}
int YabInterface::TreeboxGetNum(const char* id)
{
YabView *myView = NULL;
BOutlineListView *myList = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myList = cast_as(myView->FindView(id), BOutlineListView);
if(myList)
{
int32 t = myList->FullListCurrentSelection();
w->Unlock();
return t+1;
}
w->Unlock();
}
}
}
Error(id, "TREEBOX");
}
int YabInterface::ColumnboxGetNum(const char* id)
{
YabView *myView = NULL;
BColumnListView *myList = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
myList = cast_as(myView->FindView(id), BColumnListView);
if(myList)
{
int32 t = myList->IndexOf(myList->CurrentSelection());
w->Unlock();
return t+1;
}
w->Unlock();
}
}
}
Error(id, "COLUMNBOX");
}
void YabInterface::Attribute1(const char* type, const char* name, const char* value, const char* filename)
{
// fix to work properly with string and bool types.
BNode node(filename);
if(node.InitCheck() != B_OK)
ErrorGen("Attribute file not found!");
BString tempvalue(value);
type_code typecode;
BString typeStr(type);
if(typeStr.IFindFirst("string")!=B_ERROR)
{
int32 x = tempvalue.Length();
typecode = B_STRING_TYPE;
x++;
node.WriteAttr(name, typecode, 0, value, x);
}
else if(typeStr.IFindFirst("mime")!=B_ERROR)
{
int32 x = tempvalue.Length();
typecode = B_MIME_STRING_TYPE;
x++;
node.WriteAttr(name, typecode, 0, value, x);
}
else if(typeStr.IFindFirst("bool")!=B_ERROR)
{
typecode = B_BOOL_TYPE;
int32 x=1;
char str[1];
str[0]=1;
const char* tf = str;
if (tempvalue.IFindFirst("false") !=B_ERROR)
tf="";
node.WriteAttr(name, typecode, 0, tf, x);
}
else if(typeStr.IFindFirst("int")!=B_ERROR)
{
int32 x = tempvalue.Length();
typecode = B_INT32_TYPE;
node.WriteAttr(name, typecode, 0, value, x);
}
else if(typeStr.IFindFirst("double")!=B_ERROR)
{
int32 x = tempvalue.Length();
typecode = B_DOUBLE_TYPE;
node.WriteAttr(name, typecode, 0, value, x);
}
else if(typeStr.IFindFirst("float")!=B_ERROR)
{
int32 x = tempvalue.Length();
typecode = B_FLOAT_TYPE;
node.WriteAttr(name, typecode, 0, value, x);
}
else if(typeStr.IFindFirst("long")!=B_ERROR)
{
int32 x = tempvalue.Length();
typecode = B_INT64_TYPE;
node.WriteAttr(name, typecode, 0, value, x);
}
else
ErrorGen("Unknown attribute type!");
}
void YabInterface::AttributeClear(const char* name, const char* filename)
{
BNode node(filename);
if(node.InitCheck() != B_OK)
ErrorGen("Attribute file not found!");
node.RemoveAttr(name);
}
const char* YabInterface::AttributeGet1(const char* name, const char* filename)
{
BString tempname(name);
BNode node(filename);
if(node.InitCheck() != B_OK){
if (tempname.Length() >0)
ErrorGen("Attribute file not found!");
BString appdir = mainFileName;
int32 i = appdir.FindLast("/");
appdir.Truncate(i);
return appdir;
}
if (tempname.Length() >0)
{
attr_info attr;
if(node.GetAttrInfo(name, &attr) != B_OK)
ErrorGen("Attribute not found!");
int size = attr.size;
if(size>32568)
size = 32568;
if(node.ReadAttr(name,attr.type, 0, attrbuffer, size) == 0)
return "";
if (attr.type == B_BOOL_TYPE)
{
int x = 0;
if (attrbuffer[0] == x)
{
return "false";
}
else
{
return "true";
}
}
return (char*)attrbuffer;
}
else
{
BString List="";
BString sp=" | ";
BString Attrtype;
char buf[B_ATTR_NAME_LENGTH];
while (node.GetNextAttrName(buf) == B_OK)
{
attr_info attr;
if(node.GetAttrInfo(buf, &attr) != B_OK)
ErrorGen("Attribute not found!");
uint32 attrtype;
attrtype=attr.type;
switch(attrtype)
{
case B_BOOL_TYPE:
Attrtype="Bool";
break;
case B_STRING_TYPE:
Attrtype = "String";
break;
case B_MIME_STRING_TYPE:
Attrtype = "Mime";
break;
case B_INT32_TYPE:
Attrtype = "Int";
break;
case B_DOUBLE_TYPE:
Attrtype = "Double";
break;
case B_FLOAT_TYPE:
Attrtype = "Float";
break;
case B_INT64_TYPE:
Attrtype = "Long";
break;
default:
Attrtype = "Unsupported";
break;
}
List << buf << sp << Attrtype << sp;
}
return List.String();
}
}
double YabInterface::AttributeGet2(const char* name, const char* filename)
{
BNode node(filename);
if(node.InitCheck() != B_OK)
ErrorGen("Attribute file not found!");
attr_info attr;
if(node.GetAttrInfo(name, &attr) != B_OK)
ErrorGen("Attribute not found!");
int size = attr.size;
if(size>32568)
size = 32568;
if(node.ReadAttr(name,attr.type, 0, attrbuffer, size) == 0)
return 0.0;
if (attr.type == B_BOOL_TYPE)
{
int x = 0;
if (attrbuffer[0] == x)
{
return 0.0;
}
else
{
return 1.0;
}
}
if(node.ReadAttr(name, 0, 0, attrbuffer, size) == 0)
return 0.0;
return atof((char*)attrbuffer);
}
void YabInterface::ShortCut(const char* view, const char* key, const char* msg)
{
char myShortcut;
int32 modifiers = 0;
BString t(key);
if(t.Length()>1)
{
myShortcut = key[t.Length()-1];
if(t.IFindFirst("s")!=B_ERROR && t.IFindFirst("s")<t.Length()-1)
modifiers = modifiers|B_SHIFT_KEY;
if(t.IFindFirst("c")!=B_ERROR && t.IFindFirst("c")<t.Length()-1)
modifiers = modifiers|B_CONTROL_KEY;
if(t.IFindFirst("o")!=B_ERROR && t.IFindFirst("o")<t.Length()-1)
modifiers = modifiers|B_OPTION_KEY;
}
else
myShortcut = key[0];
YabView *myView = cast_as((BView*)viewList->GetView(view), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
BMessage *mesg = new BMessage(YABSHORTCUT);
mesg->AddString("shortcut", msg);
w->AddShortcut(myShortcut, modifiers, mesg);
w->Unlock();
return;
}
}
Error(view,"VIEW");
}
int YabInterface::IsComputerOn()
{
return is_computer_on();
}
void YabInterface::MouseSet(const char* opt)
{
BString t(opt);
if(t.IFindFirst("Hide")!=B_ERROR)
HideCursor();
else if(t.IFindFirst("Show")!=B_ERROR)
ShowCursor();
else if(t.IFindFirst("Obscure")!=B_ERROR)
ObscureCursor();
else ErrorGen("Unknown option");
}
const char* YabInterface::GetMessageString()
{
snooze(20000);
BString tmp("");
if(exiting)
{
tmp += "_QuitRequested|";
exiting = false;
}
tmp += localMessage;
localMessage = "";
for(int i=0; i<CountWindows(); i++)
{
// if(strcmp(WindowAt(i)->Title(), "_TOOLTIPWINDOW") && strcmp(WindowAt(i)->Title(), "_CALENDARWINDOW"))
YabWindow *w = cast_as(WindowAt(i), YabWindow);
if(w)
{
w->Sync();
if(w->Lock())
{
tmp += w->getMessages();
if (w->WActivated==1)
{
tmp+=w->idString;
tmp+=":_Activated|";
w->WActivated=-1;
}
if (w->WActivated==0)
{
tmp+=w->idString;
tmp+=":_Deactivated|";
w->WActivated=-1;
}
// if (w->WFrameMoved==1)
// {
// w->WFrameMoved=-1;
// tmp+=w->Name();
// tmp+=":_FrameMoved:";
// tmp << w->Wpx;
// tmp+=":";
// tmp << w->Wpy;
// tmp+="|";
// }
// if (w->WFrameResized==1)
// {
// w->WFrameResized=-1;
// tmp+=w->Name();
// tmp+=":_FrameResized:";
// tmp << w->Wpw;
// tmp+=":";
// tmp << w->Wph;
// tmp+="|";
// }
w->Unlock();
}
}
}
YabView *myView = NULL;
for(int i=0; i<viewList->CountItems(); i++)
{
myView = cast_as((BView*)viewList->ItemAt(i), YabView);
if(myView)
{
YabWindow *w = cast_as(myView->Window(), YabWindow);
if(w)
{
w->Lock();
if (myView->CountChildren())
{
for (int o=0; o<myView->CountChildren(); o++)
{
if (dynamic_cast<YabTabView*>(myView->ChildAt(o)))
{
YabTabView *target = dynamic_cast<YabTabView*>(myView->ChildAt(o));
if (target)
{
if (target->FocusChanged!=target->OldTabView)
{
tmp+=target->Name();
tmp+=":_TabChanged:";
tmp+=target->Name();
tmp << target->FocusChanged;
tmp+="|";
target->OldTabView=target->FocusChanged;
}
}
}
}
}
w->Unlock();
}
}
}
if(tmp.Length()>32766)
tmp.Remove(32767, tmp.Length()-32766);
strcpy(messagebuffer, tmp.String());
return (char*)messagebuffer;
}
int YabInterface::MessageSend(const char* app, const char* msg)
{
BMessage message, reply;
status_t result;
// set the command constant
message.what = B_SET_PROPERTY;
// construct the specifier stack
message.AddSpecifier("YabSendString", msg); // B_NAME_SPECIFIER
// send the message and fetch the result
result = BMessenger(app).SendMessage(&message, &reply);
if(result == B_OK) return 0;
if(result == B_BAD_PORT_ID) return 1;
if(result == B_WOULD_BLOCK) return 2;
if(result == B_TIMED_OUT) return 3;
return 4;
}
void YabInterface::SetLocalize(const char* path)
{
if(yabCatalog)
delete yabCatalog;
//yabCatalog = new BCatalog(path);
}
const int YabInterface::GetErrorCode()
{
return errorCode;
}
void YabInterface::KillThread(int code)
{
errorCode = code;
quitting = true;
ExitRequested();
// BMessenger(be_app).SendMessage(new BMessage(B_QUIT_REQUESTED));
// while(1){}
}
void YabInterface::Error(const char* id, const char* type)
{
fprintf(stderr, "---Error in %s, line %d: \"%s\" is not of type %s\n", currentLib.String(), currentLineNumber, id, type);
fprintf(stderr,"---Error: Program stopped due to an error \n");
KillThread(-1);
// while(1){}
}
void YabInterface::ErrorGen(const char* msg)
{
fprintf(stderr, "---Error in %s, line %d: %s\n", currentLib.String(), currentLineNumber, msg);
fprintf(stderr,"---Error: Program stopped due to an error \n");
KillThread(-1);
// while(1){}
}
void YabInterface::SetCurrentLineNumber(int line, const char* libname)
{
currentLineNumber = line;
if(!strcmp(libname, "main"))
currentLib = mainFileName;
else
currentLib = libname;
}
void YabInterface::SetMainFileName(const char* name)
{
mainFileName = strdup(name);
}
/**
* C interface functions
*/
const char* yi_GetApplicationDirectory(YabInterface *yab)
{
return yab->GetApplicationDirectory();
}
void yi_OpenWindow(double x1,double y1,double x2,double y2, const char* id, const char* title, YabInterface* yab)
{
yab->OpenWindow(BRect(x1,y1,x2,y2), id, _L(title));
}
int yi_CloseWindow(const char* view, YabInterface* yab)
{
return yab->CloseWindow(view);
}
void yi_CreateButton(double x1,double y1,double x2,double y2, const char* id, const char* title, const char* view, YabInterface* yab)
{
yab->CreateButton(BRect(x1,y1,x2,y2), id, _L(title), view);
}
int yi_CreateImage(double x,double y,const char* imagefile, const char* window, YabInterface* yab)
{
return yab->CreateImage(BPoint(x,y),imagefile,window);
}
int yi_CreateImage2(double x1,double y1,double x2,double y2,const char* imagefile, const char* window, YabInterface* yab)
{
return yab->CreateImage(BRect(x1,y1,x2,y2),imagefile,window);
}
int yi_CreateSVG(double x1,double y1,double x2,double y2,const char* imagefile, const char* window, YabInterface* yab)
{
return yab->CreateSVG(BRect(x1,y1,x2,y2),imagefile,window);
}
void yi_CreateMenu(const char* menuhead, const char* menuitem, const char *shortcut, const char* window, YabInterface* yab)
{
yab->CreateMenu(_L(menuhead),_L(menuitem),shortcut,window);
}
void yi_CreateTextControl(double x1, double y1, double x2, double y2, const char* id, const char* label, const char* text, const char* window, YabInterface *yab)
{
yab->CreateTextControl(BRect(x1,y1,x2,y2),id,_L(label),_L(text),window);
}
void yi_CreateCheckBox(double x, double y, const char* id, const char* label, int isActivated, const char* window, YabInterface *yab)
{
yab->CreateCheckBox(x,y,id,_L(label),isActivated,window);
}
void yi_CreateRadioButton(double x, double y, const char* groupID, const char* label, int isActivated, const char* window, YabInterface *yab)
{
yab->CreateRadioButton(x,y,groupID,_L(label),isActivated,window);
}
void yi_CreateListBox(double x1, double y1, double x2, double y2, const char* title, int scrollbar, const char* window, YabInterface *yab)
{
yab->CreateListBox(BRect(x1,y1,x2,y2),title,scrollbar,window);
}
void yi_CreateDropBox(double x1, double y1, double x2, double y2, const char* title, const char* label, const char* window, YabInterface *yab)
{
yab->CreateDropBox(BRect(x1,y1,x2,y2),title,_L(label), window);
}
void yi_CreateItem(const char* id,const char* item, YabInterface *yab)
{
yab->CreateItem(id,_L(item));
}
void yi_RemoveItem(const char* title,const char* item, YabInterface *yab)
{
yab->RemoveItem(title,_L(item));
}
void yi_ClearItems(const char* title, YabInterface *yab)
{
yab->ClearItems(title);
}
void yi_DrawText(double x, double y, const char* text, const char* window, YabInterface* yab)
{
yab->DrawText(BPoint(x,y), _L(text), window);
}
void yi_DrawRect(double x1, double y1, double x2, double y2, const char* window, YabInterface* yab)
{
yab->DrawRect(BRect(x1,y1,x2,y2),window);
}
void yi_DrawClear(const char* window, YabInterface* yab)
{
yab->DrawClear(window, false);
}
void yi_CreateAlert(const char* text, const char* button1, const char* type, YabInterface* yab)
{
yab->CreateAlert(_L(text),_L(button1),type);
}
void yi_CreateText(double x, double y, const char* id, const char* text, const char* window, YabInterface* yab)
{
yab->CreateText(x,y,id,_L(text),window);
}
void yi_Text2(double x1, double y1, double x2, double y2, const char* id, const char* text, const char* window, YabInterface* yab)
{
yab->Text2(BRect(x1,y1,x2,y2),id,_L(text),window);
}
void yi_TextAlign(const char* txt, const char *option, YabInterface *yab)
{
yab->TextAlign(txt, option);
}
void yi_Translate(char* text, char result[])
{
if(yabCatalog)
{
result[0] = '\0';
strcpy(result,yabCatalog->GetString(text, NULL));
}
else
strcpy(result,text);
}
void yi_MenuTranslate(char* text, char result[])
{
if(yabCatalog)
{
result[0] = '\0';
const char* token;
const char delimiters[] = ":";
token = strtok(text, delimiters);
while(token!=NULL)
{
strcat(result,yabCatalog->GetString(token, NULL)); //B_TRANSLATE_CONTEXT));
token = strtok(NULL, delimiters);
if(token!=NULL) strcat(result,":");
}
}
else
strcpy(result,text);
}
void yi_SetLocalize()
{
localize = true;
}
void yi_StopLocalize()
{
localize = false;
}
void yi_SetLocalize2(const char* , YabInterface *yab)
{
localize = true;
//yab->SetLocalize(path);
}
const char* yi_LoadFilePanel(const char* mode, const char* title, const char* directory, YabInterface *yab)
{
return yab->LoadFilePanel(mode, _L(title), directory);
}
const char* yi_SaveFilePanel(const char* mode, const char* title, const char* directory, const char*filename, YabInterface *yab)
{
return yab->SaveFilePanel(mode, _L(title), directory, filename);
}
void yi_SetLayout(const char* layout, const char* window, YabInterface *yab)
{
yab->SetLayout(layout, window);
}
void yi_WindowSet1(const char* option, const char* value, const char* window, YabInterface *yab)
{
yab->WindowSet(option, value, window);
}
void yi_WindowSet2(const char* option, int r, int g, int b, const char* window, YabInterface *yab)
{
yab->WindowSet(option, r, g, b, window);
}
void yi_WindowSet3(const char* option, double x, double y, const char* window, YabInterface *yab)
{
yab->WindowSet(option,x,y, window);
}
void yi_WindowSet4(const char* option, const char* window, YabInterface *yab)
{
yab->WindowSet(option, window);
}
void yi_WindowClear(const char* window, YabInterface *yab)
{
yab->WindowClear(window);
}
void yi_TextEdit(double x1, double y1, double x2, double y2, const char* title, int scrollbar, const char* window, YabInterface *yab)
{
yab->TextEdit(BRect(x1,y1,x2,y2), title, scrollbar, window);
}
void yi_TextAdd(const char* title, const char* text, YabInterface *yab)
{
yab->TextAdd(title,text);
}
void yi_TextSet(const char* title, const char* option, YabInterface *yab)
{
yab->TextSet(title,option);
}
void yi_TextSet2(const char* title, const char* option, int value, YabInterface *yab)
{
yab->TextSet(title,option,value);
}
void yi_TextSet3(const char* title, const char* option, const char* value, YabInterface *yab)
{
yab->TextSet(title,option,value);
}
void yi_TextColor1(const char* title, const char* option, const char* command, YabInterface *yab)
{
yab->TextColor(title,option,command);
}
void yi_TextColor2(const char* title, const char* option, int r, int g, int b, YabInterface *yab)
{
yab->TextColor(title,option,r,g,b);
}
int yi_TextGet2(const char* title, const char* option, YabInterface *yab)
{
return yab->TextGet(title,option);
}
const char* yi_TextGet3(const char* title, int linenum, YabInterface *yab)
{
return yab->TextGet(title,linenum);
}
double yi_TextGet4(const char* title, const char* option, int linenum, YabInterface *yab)
{
return yab->TextGet(title,option,linenum);
}
int yi_TextGet5(const char* title, const char* option, const char* option2, YabInterface *yab)
{
return yab->TextGet(title,option,option2);
}
const char* yi_TextGet6(const char* title, const char* option, YabInterface *yab)
{
return yab->TextGet6(title, option);
}
void yi_TextClear(const char* title, YabInterface *yab)
{
yab->TextClear(title);
}
const char* yi_TextGet(const char* title, YabInterface *yab)
{
return yab->TextGet(title);
}
void yi_DrawSet1(const char* option, const char* window, YabInterface *yab)
{
return yab->DrawSet1(option, window);
}
void yi_DrawSet2(int fillorstroke, const char* mypattern, YabInterface *yab)
{
return yab->DrawSet2(fillorstroke, mypattern);
}
void yi_View(double x1, double y1, double x2, double y2, const char* id, const char* view, YabInterface *yab)
{
yab->View(BRect(x1,y1,x2,y2), id, view);
}
void yi_BoxView(double x1, double y1, double x2, double y2, const char* id, const char* text, int lineType, const char* view, YabInterface *yab)
{
yab->BoxView(BRect(x1,y1,x2,y2), id, _L(text), lineType, view);
}
void yi_BoxViewSet(const char* id, const char* option,const char* value, YabInterface *yab)
{
yab->BoxViewSet(id, option,value);
}
void yi_Tab(double x1, double y1, double x2, double y2, const char* id, const char* names, const char* view, YabInterface *yab)
{
yab->Tab(BRect(x1,y1,x2,y2), id, names, view);
}
void yi_TabSet(const char* id, int num, YabInterface *yab)
{
yab->TabSet(id, num);
}
void yi_TabAdd(const char* id, const char* tabname, YabInterface *yab)
{
yab->TabAdd(id, _L(tabname));
}
void yi_TabDel(const char* id, int num, YabInterface *yab)
{
yab->TabDel(id, num);
}
int yi_TabViewGet(const char* id, YabInterface *yab)
{
return yab->TabViewGet(id);
}
void yi_DrawDot(double x, double y, const char* window, YabInterface *yab)
{
yab->DrawDot(x,y, window);
}
void yi_DrawLine(double x1, double y1, double x2, double y2, const char* window, YabInterface *yab)
{
yab->DrawLine(x1,y1,x2,y2, window);
}
void yi_DrawCircle(double x, double y, double r, const char* window, YabInterface *yab)
{
yab->DrawCircle(x,y,r, window);
}
void yi_DrawEllipse(double x, double y, double r1, double r2, const char* window, YabInterface *yab)
{
yab->DrawEllipse(x,y,r1,r2, window);
}
void yi_DrawCurve(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4, const char* window, YabInterface *yab)
{
yab->DrawCurve(x1,y1,x2,y2,x3,y3,x4,y4, window);
}
void yi_Slider1(double x1, double y1, double x2, double y2, const char* id, const char* title, int min, int max, const char* view, YabInterface *yab)
{
yab->Slider(BRect(x1,y1,x2,y2), id, _L(title), min, max, view);
}
void yi_Slider2(double x1, double y1, double x2, double y2, const char* id, const char* title, int min, int max, const char* option, const char* view, YabInterface *yab)
{
yab->Slider(BRect(x1,y1,x2,y2), id, _L(title), min, max, option, view);
}
void yi_SetSlider1(const char* id, const char* label1, const char* label2, YabInterface *yab)
{
yab->SetSlider(id, _L(label1), _L(label2));
}
void yi_SetSlider2(const char* id, const char* bottomtop, int count, YabInterface *yab)
{
yab->SetSlider(id, bottomtop, count);
}
void yi_SetSlider3(const char* id, const char* part, int r, int g, int b, YabInterface *yab)
{
yab->SetSlider(id, part, r,g,b);
}
void yi_SetSlider4(const char* id, int value, YabInterface *yab)
{
yab->SetSlider(id, value);
}
void yi_SetOption1(const char* id, const char* option, const char* value, YabInterface *yab)
{
yab->SetOption(id,option,value);
}
void yi_SetOption2(const char* id, const char* option, int r, int g, int b, YabInterface *yab)
{
yab->SetOption(id,option,r,g,b);
}
void yi_SetOption3(const char* id, const char* option, double x, double y, YabInterface *yab)
{
yab->SetOption(id,option,x,y);
}
void yi_SetOption4(const char* id, const char* option, YabInterface *yab)
{
yab->SetOption(id,option);
}
void yi_SetOption5(const char* id, const char* option, int value, YabInterface *yab)
{
yab->SetOption(id,option,value);
}
void yi_DropZone(const char* view, YabInterface *yab)
{
yab->DropZone(view);
}
void yi_ColorControl1(double x, double y, const char* id, const char* view, YabInterface* yab)
{
yab->ColorControl(x,y,id,view);
}
void yi_ColorControl2(const char* id, int r, int g, int b, YabInterface* yab)
{
yab->ColorControl(id,r,g,b);
}
void yi_TextControl2(const char* id, const char* text, YabInterface* yab)
{
yab->TextControl(id,_L(text));
}
void yi_TextControl3(const char* id, int mode, YabInterface* yab)
{
yab->TextControl(id,mode);
}
void yi_TextControl5(const char* id, YabInterface* yab)
{
yab->TextControl(id);
}
void yi_TextControl4(const char* id, const char* option, const char* value, YabInterface* yab)
{
yab->TextControl(id,option,value);
}
void yi_TreeBox1(double x1, double y1, double x2, double y2, const char* id, int scrollbarType, const char* view, YabInterface* yab)
{
yab->TreeBox1(BRect(x1,y1,x2,y2), id, scrollbarType, view);
}
void yi_TreeBox2(const char* id, const char* item, YabInterface* yab)
{
yab->TreeBox2(id,_L(item));
}
void yi_TreeBox3(const char* id, const char* head, const char* item, int isExpanded, YabInterface* yab)
{
yab->TreeBox3(id,_L(head),_L(item),isExpanded);
}
void yi_TreeBox4(const char* id, YabInterface* yab)
{
yab->TreeBox4(id);
}
void yi_TreeBox5(const char* id, const char* item, YabInterface* yab)
{
yab->TreeBox5(id,_L(item));
}
void yi_TreeBox7(const char* id, int pos, YabInterface* yab)
{
yab->TreeBox7(id,pos);
}
void yi_TreeBox8(const char* id, int pos, YabInterface* yab)
{
yab->TreeBox8(id,pos);
}
void yi_TreeBox9(const char* id, const char* head, const char* item, YabInterface* yab)
{
yab->TreeBox9(id,_L(head), _L(item));
}
void yi_TreeBox10(const char* id, const char* head, YabInterface* yab)
{
yab->TreeBox10(id,_L(head));
}
void yi_TreeBox11(const char* id, const char* head, YabInterface* yab)
{
yab->TreeBox11(id,_L(head));
}
void yi_TreeBox12(const char* id, const char* item, int pos, YabInterface* yab)
{
yab->TreeBox12(id,_L(item), pos);
}
const char* yi_TreeboxGet(const char* treebox, int pos, YabInterface *yab)
{
return yab->TreeboxGet(treebox, pos);
}
int yi_TreeboxCount(const char* treebox, YabInterface *yab)
{
return yab->TreeboxCount(treebox);
}
void yi_ButtonImage(double x,double y,const char* id,const char* enabledon, const char* enabledoff, const char *disabled, const char* view, YabInterface *yab)
{
return yab->ButtonImage(x,y, id, enabledon, enabledoff, disabled, view);
}
void yi_CheckboxImage(double x,double y,const char* id,const char* enabledon, const char* enabledoff, const char *disabledon, const char *disabledoff, int isActivated, const char* view, YabInterface *yab)
{
return yab->CheckboxImage(x,y, id, enabledon, enabledoff, disabledon, disabledoff, isActivated, view);
}
void yi_CheckboxSet(const char* id, int isActivated, YabInterface* yab)
{
yab->CheckboxSet(id, isActivated);
}
void yi_RadioSet(const char* id, int isActivated, YabInterface* yab)
{
yab->RadioSet(id, isActivated);
}
void yi_ToolTip(const char* view, const char* text, YabInterface *yab)
{
yab->ToolTips(view,_L(text));
}
void yi_ToolTipColor(const char* color, int r, int g, int b, YabInterface *yab)
{
yab->ToolTipsColor(color,r,g,b);
}
void yi_TreeSort(const char* view, YabInterface *yab)
{
yab->TreeSort(view);
}
void yi_ListSort(const char* view, YabInterface *yab)
{
yab->ListSort(view);
}
void yi_FileBox(double x1, double y1, double x2, double y2, const char* id, int scrollbartype, const char *option, const char* view, YabInterface *yab)
{
yab->FileBox(BRect(x1,y1,x2,y2), id, scrollbartype, option, view);
}
void yi_FileBoxAdd2(const char* columnbox, const char* name, int pos, double maxWidth, double minWidth, double width, const char* option, YabInterface *yab)
{
yab->FileBoxAdd(columnbox, _L(name), pos, maxWidth, minWidth, width, option);
}
void yi_FileBoxClear(const char* view, YabInterface *yab)
{
yab->FileBoxClear(view);
}
void yi_ColumnBoxAdd(const char* id, int column, int position, int height, const char* item, YabInterface *yab)
{
yab->ColumnBoxAdd(id, column, position, height, _L(item));
}
void yi_ColumnBoxSelect(const char *columnbox, int position, YabInterface *yab)
{
yab->ColumnBoxSelect(columnbox, position);
}
void yi_ColumnBoxRemove(const char *columnbox, int position, YabInterface *yab)
{
yab->ColumnBoxRemove(columnbox, position);
}
void yi_ColumnBoxColor(const char *columnbox, const char* option, int r, int g, int b, YabInterface *yab)
{
yab->ColumnBoxColor(columnbox, option, r,g,b);
}
const char* yi_ColumnBoxGet(const char *columnbox, int column, int position, YabInterface *yab)
{
return yab->ColumnBoxGet(columnbox, column, position);
}
int yi_ColumnBoxCount(const char *columnbox, YabInterface *yab)
{
return yab->ColumnBoxCount(columnbox);
}
const char* yi_TextControlGet(const char* id, YabInterface* yab)
{
return yab->TextControlGet(id);
}
int yi_DeskbarPosition(YabInterface *yab)
{
return yab->DeskbarParam("position");
}
int yi_DeskbarExpanded(YabInterface *yab)
{
return yab->DeskbarParam("expanded");
}
int yi_DeskbarWidth(YabInterface *yab)
{
return yab->DeskbarParam("width");
}
int yi_DeskbarHeight(YabInterface *yab)
{
return yab->DeskbarParam("height");
}
int yi_DeskbarX(YabInterface *yab)
{
return yab->DeskbarParam("x");
}
int yi_DeskbarY(YabInterface *yab)
{
return yab->DeskbarParam("y");
}
int yi_DesktopWidth(YabInterface *yab)
{
return yab->DesktopParam(true);
}
int yi_DesktopHeight(YabInterface *yab)
{
return yab->DesktopParam(false);
}
int yi_WindowGet(const char* view, const char* option, YabInterface *yab)
{
return yab->WindowGet(view,option);
}
int yi_ViewGet(const char* view, const char* option, YabInterface *yab) //vasper
{
return yab->ViewGet(view,option);
}
void yi_ClipboardCopy(const char* text, YabInterface *yab)
{
yab->ClipboardCopy(text);
}
int yi_Printer(const char* docname, const char *view, const char* config, YabInterface *yab)
{
return yab->Printer(docname, view,config);
}
void yi_PrinterConfig(const char* config, YabInterface *yab)
{
yab->PrinterConfig(config);
}
const char* yi_ClipboardPaste(YabInterface *yab)
{
return yab->ClipboardPaste();
}
int yi_NewAlert(const char* text, const char* button1, const char* button2, const char* button3, const char* option, YabInterface *yab)
{
return yab->NewAlert(_L(text), _L(button1), _L(button2), _L(button3), option);
}
void yi_Calendar1(double x, double y, const char* id, const char* format, const char* date, const char* view, YabInterface *yab)
{
yab->Calendar(x,y, id, format, date, view);
}
const char* yi_Calendar2(const char* id, YabInterface *yab)
{
return yab->Calendar(id);
}
void yi_Calendar3(const char* id, const char* date, YabInterface *yab)
{
yab->Calendar(id, date);
}
const char* yi_ListboxGet(const char* listbox, int pos, YabInterface *yab)
{
return yab->ListboxGet(listbox, pos);
}
int yi_ListboxCount(const char* listbox, YabInterface *yab)
{
return yab->ListboxCount(listbox);
}
void yi_ListboxAdd1(const char* listbox, const char* item, YabInterface *yab)
{
yab->ListboxAdd(listbox,_L(item));
}
void yi_ListboxAdd2(const char* listbox, int pos, const char* item, YabInterface *yab)
{
yab->ListboxAdd(listbox, pos, _L(item));
}
void yi_ListboxSelect(const char* listbox, int pos, YabInterface *yab)
{
yab->ListboxSelect(listbox,pos);
}
void yi_ListboxRemove(const char* listbox, int pos, YabInterface *yab)
{
yab->ListboxRemove(listbox,pos);
}
void yi_Scrollbar(const char* id, int format, const char* view, YabInterface *yab)
{
yab->Scrollbar(id, format, view);
}
void yi_ScrollbarSet1(const char* scrollview, const char* option, double position, YabInterface *yab)
{
yab->ScrollbarSet(scrollview, option, position);
}
void yi_ScrollbarSet2(const char* scrollview, const char* option, double opt1, double opt2, YabInterface *yab)
{
yab->ScrollbarSet(scrollview, option, opt1, opt2);
}
void yi_ScrollbarSet3(const char* scrollview, const char* option, YabInterface *yab)
{
yab->ScrollbarSet(scrollview, option);
}
double yi_ScrollbarGet(const char* scrollview, const char* option, YabInterface *yab)
{
return yab->ScrollbarGet(scrollview, option);
}
void yi_SplitView1(double x1,double y1,double x2,double y2, const char* id, int isVertical, int style, const char* view, YabInterface *yab)
{
yab->SplitView(BRect(x1,y1,x2,y2), id, isVertical, style, view);
}
void yi_SplitView2(const char* splitView, const char* option, double position, YabInterface *yab)
{
yab->SplitView(splitView, option, position);
}
void yi_SplitView3(const char* splitView, const char* option, double left, double right, YabInterface *yab)
{
yab->SplitView(splitView, option, left, right);
}
double yi_SplitViewGet(const char* splitView, const char* option, YabInterface *yab)
{
return yab->SplitViewGet(splitView, option);
}
void yi_StackView1(double x1,double y1,double x2,double y2, const char* id, int number, const char* view, YabInterface *yab)
{
yab->StackViews(BRect(x1,y1,x2,y2), id, number, view);
}
void yi_StackView2(const char* stackView, int num, YabInterface *yab)
{
yab->StackViews(stackView, num);
}
int yi_StackViewGet(const char* stackView, YabInterface *yab)
{
return yab->StackViewGet(stackView);
}
void yi_DrawSet3(const char* option, int transparency, YabInterface *yab)
{
yab->DrawSet3(option, transparency);
}
extern void yi_TextURL1(double x, double y, const char* id, const char* text, const char* url, const char* view, YabInterface *yab)
{
yab->TextURL(x,y, id, _L(text), url, view);
}
void yi_TextURL2(const char* id, const char* option, int r, int g, int b, YabInterface *yab)
{
yab->TextURL(id, option, r,g,b);
}
void yi_Menu2(const char* menuHead, int isRadio, const char* view, YabInterface *yab)
{
yab->Menu(_L(menuHead), isRadio, view);
}
void yi_SubMenu1(const char* menuHead, const char* menuItem, const char* subMenuItem, const char* modifiers, const char* view, YabInterface *yab)
{
yab->SubMenu(_L(menuHead), _L(menuItem), _L(subMenuItem), modifiers, view);
}
void yi_SubMenu2(const char* menuHead, const char* menuItem, int isRadio, const char* view, YabInterface *yab)
{
yab->SubMenu(_L(menuHead), _L(menuItem), isRadio, view);
}
void yi_SpinControl1(double x, double y, const char* id, const char* label, int min, int max, int step, const char* view, YabInterface *yab)
{
yab->SpinControl(x,y, id, _L(label), min, max, step, view);
}
void yi_SpinControl2(const char* spinControl, int value, YabInterface *yab)
{
yab->SpinControl(spinControl, value);
}
int yi_SpinControlGet(const char *spinControl, YabInterface *yab)
{
return yab->SpinControlGet(spinControl);
}
const char* yi_PopUpMenu(double x, double y, const char* menuItems, const char* view, YabInterface *yab)
{
return yab->PopUpMenu(x,y,menuItems,view);
}
void yi_DropBoxSelect(const char* dropbox, int position, YabInterface *yab)
{
yab->DropBoxSelect(dropbox, position);
}
void yi_DropBoxClear(const char* dropbox, YabInterface *yab)
{
yab->DropBoxClear(dropbox);
}
void yi_DropBoxRemove(const char* dropbox, int position, YabInterface *yab)
{
yab->DropBoxRemove(dropbox,position);
}
int yi_DropBoxCount(const char* dropbox, YabInterface *yab)
{
return yab->DropBoxCount(dropbox);
}
const char* yi_DropBoxGet(const char* dropbox, int position, YabInterface *yab)
{
return yab->DropBoxGet(dropbox, position);
}
int yi_ColorControlGet(const char* colorcontrol, const char* option, YabInterface *yab)
{
return yab->ColorControlGet(colorcontrol, option);
}
int yi_SliderGet(const char* slider, YabInterface *yab)
{
return yab->SliderGet(slider);
}
double yi_DrawGet1(const char* option, const char* txt, const char* view, YabInterface *yab)
{
return yab->DrawGet(option, txt, view);
}
double yi_DrawGet2(const char* option, const char* view, YabInterface *yab)
{
return yab->DrawGet(option, "", view);
}
const char* yi_DrawGet3(const char* option, YabInterface *yab)
{
return yab->DrawGet(option);
}
void yi_SubMenu3(const char* menuHead, const char* menuItem, const char* subMenuItem, const char* option, const char* view, YabInterface *yab)
{
yab->SubMenu3(_L(menuHead), _L(menuItem), _L(subMenuItem), option, view);
}
void yi_Menu3(const char* menuHead, const char* menuItem, const char* option,const char* view, YabInterface *yab)
{
yab->Menu3(_L(menuHead), _L(menuItem), option, view);
}
double yi_MenuHeight(YabInterface *yab)
{
return yab->MenuHeight();
}
double yi_TabHeight(YabInterface *yab)
{
return yab->TabHeight();
}
double yi_ScrollbarWidth(YabInterface *yab)
{
return yab->ScrollbarWidth();
}
void yi_exit(int code, YabInterface *yab)
{
yab->KillThread(code);
}
const int yi_IsMouseIn(const char* view, YabInterface *yab)
{
return yab->IsMouseIn(view);
}
const char* yi_GetMouseIn(YabInterface *yab)
{
return yab->GetMouseIn();
}
const char* yi_KeyboardMessages(const char* view, YabInterface* yab)
{
return yab->KeyboardMessages(view);
}
const char* yi_GetMouseMessages(const char* view, YabInterface* yab)
{
return yab->GetMouseMessages(view);
}
const char* yi_CheckMessages(YabInterface* yab)
{
return yab->GetMessageString();
}
int yi_MessageSend(const char* app, const char* msg,YabInterface* yab)
{
return yab->MessageSend(app,msg);
}
int yi_ThreadKill(const char* option, int id,YabInterface* yab)
{
return yab->ThreadKill(option, id);
}
int yi_ThreadGet(const char* option, const char* appname,YabInterface* yab)
{
return yab->ThreadGet(option, appname);
}
void yi_SetCurrentLineNumber(int line, const char* libname, YabInterface* yab)
{
yab->SetCurrentLineNumber(line, libname);
}
void yi_SetMainFileName(const char* name, YabInterface* yab)
{
yab->SetMainFileName(name);
}
void yi_beep()
{
beep();
}
void yi_Bitmap(double w, double h, const char* id,YabInterface* yab)
{
yab->Bitmap(w,h,id);
}
int yi_BitmapColor(double x, double y, const char* id, const char* option, YabInterface *yab)
{
return yab->BitmapColor(x,y, id, option);
}
void yi_BitmapDraw(double x, double y, const char* bitmap, const char* mode, const char* view,YabInterface* yab)
{
yab->BitmapDraw(x,y, bitmap, mode, view);
}
void yi_BitmapDraw2(double x1, double y1, double x2, double y2, const char* bitmap, const char* mode, const char* view,YabInterface* yab)
{
yab->BitmapDraw(BRect(x1,y1,x2,y2), bitmap, mode, view);
}
void yi_BitmapGet(double x1, double y1, double x2, double y2, const char* id, const char* bitmap, YabInterface* yab)
{
yab->BitmapGet(BRect(x1,y1,x2,y2), id, bitmap);
}
void yi_BitmapGet2(double w, const char* id, const char* path, YabInterface* yab)
{
yab->BitmapGet(w, id, path);
}
int yi_BitmapGetNum(const char* id, const char* option, YabInterface* yab)
{
return yab->BitmapGet(id, option);
}
int yi_BitmapLoad(const char* filename, const char* bitmap, YabInterface* yab)
{
return yab->BitmapLoad(filename, bitmap);
}
void yi_BitmapGetIcon(const char* id, const char* option, const char* path, YabInterface* yab)
{
yab->BitmapGetIcon(id, option, path);
}
void yi_BitmapDrag(const char* bitmap,YabInterface* yab)
{
yab->BitmapDrag(bitmap);
}
void yi_BitmapRemove(const char* bitmap,YabInterface* yab)
{
yab->BitmapRemove(bitmap);
}
void yi_Screenshot(double x1, double y1, double x2, double y2, const char* bitmap, YabInterface *yab)
{
return yab->Screenshot(BRect(x1,y1,x2,y2), bitmap);
}
int yi_BitmapSave(const char* id, const char* filename, const char* type, YabInterface* yab)
{
return yab->BitmapSave(id, filename, type); //, type);
}
void yi_Canvas(double x1, double y1, double x2, double y2, const char* id, const char* view, YabInterface *yab)
{
yab->Canvas(BRect(x1,y1,x2,y2), id,view);
}
int yi_Sound(const char* filename, int status, YabInterface* yab) //Reactivate Sound Lorglas 2020.01.02
{
return yab->Sound(filename, status);
}
void yi_SoundStop(int id, YabInterface* yab) //Reactivate Sound Lorglas 2020.01.02
{
return yab->SoundStop(id);
}
void yi_SoundWait(int id, YabInterface* yab) //Reactivate Sound Lorglas 2020.01.03
{
return yab->SoundWait(id);
}
int yi_MediaSound(const char* filename, YabInterface* yab)
{
return yab->MediaSound(filename);
}
void yi_MediaSoundStop(int id,YabInterface* yab)
{
return yab->MediaSoundStop(id);
}
/*
void yi_MediaSoundWait(int id, YabInterface* yab)
{
yab->MediaSoundWait(id);
}
*/
void yi_ShortCut(const char* view, const char* key, const char* msg, YabInterface *yab)
{
yab->ShortCut(view,key,msg);
}
int yi_IsComputerOn(YabInterface *yab)
{
return yab->IsComputerOn();
}
void yi_DrawSet4(const char* option, const char* color,const char* view, YabInterface* yab)
{
yab->DrawSet(option, color, view);
}
void yi_Treebox13(const char* id,const char* option, int pos, YabInterface* yab)
{
yab->Treebox13(id, option, pos);
}
int yi_TreeboxGetOpt(const char* id, const char* option, int pos, YabInterface* yab)
{
return yab->TreeboxGetOpt(id, option, pos);
}
int yi_ListboxGetNum(const char* id, YabInterface* yab)
{
return yab->ListboxGetNum(id);
}
int yi_DropboxGetNum(const char* id, YabInterface* yab)
{
return yab->DropboxGetNum(id);
}
int yi_TreeboxGetNum(const char* id, YabInterface* yab)
{
return yab->TreeboxGetNum(id);
}
int yi_ColumnboxGetNum(const char* id, YabInterface* yab)
{
return yab->ColumnboxGetNum(id);
}
int yi_DrawGet4(double x, double y, const char* option, const char* view, YabInterface* yab)
{
return yab->DrawGet(BPoint(x,y),option,view);
}
void yi_MouseSet(const char* opt, YabInterface *yab)
{
yab->MouseSet(opt);
}
void yi_StatusBar(double x1, double y1, double x2, double y2, const char* id, const char* label1, const char* label2, const char* view, YabInterface *yab)
{
yab->StatusBar(BRect(x1, y1, x2, y2), id, label1, label2, view);
}
void yi_StatusBarSet(const char* id, const char* label1, const char* label2, double state, YabInterface *yab)
{
yab->StatusBarSet(id, label1, label2, state);
}
void yi_StatusBarSet2(double x1, double y1, double x2, double y2, const char* id, const char* view, YabInterface *yab)
{
yab->StatusBarSet(BRect(x1, y1, x2, y2), id, view);
}
void yi_StatusBarSet3(const char* id, int r, int g, int b, YabInterface *yab)
{
yab->StatusBarSet(id, r, g, b);
}
void yi_Launch(const char* strg, YabInterface *yab)
{
yab->Launch(strg);
}
void yi_Attribute1(const char* type, const char* name, const char* value, const char* filename, YabInterface* yab)
{
yab->Attribute1(type, name, value, filename);
}
void yi_AttributeClear(const char* name, const char* filename, YabInterface* yab)
{
yab->AttributeClear(name, filename);
}
const char* yi_AttributeGet1(const char* name, const char* filename, YabInterface* yab)
{
return yab->AttributeGet1(name, filename);
}
double yi_AttributeGet2(const char* name, const char* filename, YabInterface* yab)
{
return yab->AttributeGet2(name, filename);
}