727 lines
22 KiB
C++
727 lines
22 KiB
C++
/*******************************************************
|
|
* SplitPane©
|
|
*
|
|
* SplitPane is a usefull UI component. It alows the
|
|
* use to ajust two view Horizontaly or Vertacly so
|
|
* that they are a desired size. This type of Pane
|
|
* shows up most comonly in Mail/News Readers.
|
|
*
|
|
* @author YNOP (ynop@acm.org)
|
|
* @version beta
|
|
* @date Dec. 10 1999
|
|
*******************************************************/
|
|
#include <AppKit.h>
|
|
#include <InterfaceKit.h>
|
|
#include <StorageKit.h>
|
|
#include <String.h>
|
|
#include <Path.h>
|
|
#include <TranslationKit.h>
|
|
#include <TranslationUtils.h>
|
|
|
|
//#include <stdio.h>
|
|
|
|
#include "SplitPane.h"
|
|
//#include "SplitPaneConfig.h"
|
|
|
|
/*******************************************************
|
|
* Setup the main view. Add in all the niffty components
|
|
* we have made and get things rolling
|
|
*******************************************************/
|
|
SplitPane::SplitPane(BRect frame, const char* name, BView *one, BView *two,uint32 Mode):BView(frame, name, Mode,B_WILL_DRAW|B_FRAME_EVENTS){
|
|
SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR)); // This is default get from parent if exist
|
|
//SetViewColor(B_TRANSPARENT_32_BIT); // go tran so we have control over drawing
|
|
BRect b;
|
|
b = Bounds();
|
|
SetViewColor(ui_color(B_PANEL_BACKGROUND_COLOR));
|
|
PaneOne = one;
|
|
PaneTwo = two;
|
|
|
|
align = B_VERTICAL; // Most people use it this way
|
|
pos = (int)b.Width()/2; // Center is a good start place
|
|
thickness = 10;
|
|
jump = 1; // 1 makes a smother slide
|
|
VOneDetachable = false;
|
|
VTwoDetachable = false;
|
|
pad = 1;
|
|
MinSizeOne = 0; // full left
|
|
MinSizeTwo = 0; // full right
|
|
poslocked = false; // free movement
|
|
alignlocked = false; // free alignment
|
|
Draggin = false;
|
|
attached = false;
|
|
|
|
WinOne = NULL;
|
|
WinTwo = NULL;
|
|
ConfigWindow = NULL;
|
|
|
|
AddChild(one);
|
|
AddChild(two);
|
|
}
|
|
|
|
/*******************************************************
|
|
* When ready grap the parents color and refreash.
|
|
*******************************************************/
|
|
void SplitPane::AttachedToWindow(){
|
|
//SetViewColor(Parent()->ViewColor());
|
|
attached = true;
|
|
Update();
|
|
}
|
|
|
|
/*******************************************************
|
|
* If we are being resized. Fix the stuff we need to fix
|
|
*******************************************************/
|
|
void SplitPane::FrameResized(float,float){
|
|
// if bar is on the left side follow left
|
|
// else if it is on the right side follow the right
|
|
// Need to implements smart follow still
|
|
Update();
|
|
Invalidate();
|
|
}
|
|
|
|
/*******************************************************
|
|
* The main draw stuff here. basicly just the slider
|
|
*******************************************************/
|
|
void SplitPane::Draw(BRect f){
|
|
SetHighColor(160,160,160);
|
|
|
|
if(align == B_VERTICAL){
|
|
SetHighColor(185,185,185);
|
|
// SetHighColor(145,145,145);
|
|
//FillRect(BRect(pos,Bounds().top+pad+1,pos,Bounds().bottom-pad-1)); // 145
|
|
FillRect(BRect(pos,Bounds().top+pad+1,pos,Bounds().bottom-pad-1)); // 145
|
|
|
|
SetHighColor(255,255,255);
|
|
FillRect(BRect(pos+1,Bounds().top+pad+1,pos+2,Bounds().bottom-pad-1)); // 255
|
|
|
|
//SetHighColor(216,216,216);
|
|
SetHighColor(Parent()->ViewColor());
|
|
FillRect(BRect(pos+2,Bounds().top+pad+1,pos+thickness-2,Bounds().bottom-pad-1));// 216
|
|
|
|
if(thickness>9)
|
|
{
|
|
float y = (Bounds().bottom - Bounds().top)/2;
|
|
float x = pos + (thickness/2);
|
|
SetPenSize(2);
|
|
SetHighColor(255,255,255);
|
|
StrokeLine(BPoint(x-3,y-11),BPoint(x+3,y-5));
|
|
StrokeLine(BPoint(x-3,y-7),BPoint(x+3,y-1));
|
|
StrokeLine(BPoint(x-3,y-3),BPoint(x+3,y+3));
|
|
StrokeLine(BPoint(x-3,y+1),BPoint(x+3,y+7));
|
|
StrokeLine(BPoint(x-3,y+5),BPoint(x+3,y+11));
|
|
SetPenSize(1);
|
|
SetHighColor(145,145,145);
|
|
StrokeLine(BPoint(x-3,y-10),BPoint(x+3,y-4));
|
|
StrokeLine(BPoint(x-3,y-6),BPoint(x+3,y+0));
|
|
StrokeLine(BPoint(x-3,y-2),BPoint(x+3,y+4));
|
|
StrokeLine(BPoint(x-3,y+2),BPoint(x+3,y+8));
|
|
StrokeLine(BPoint(x-3,y+6),BPoint(x+3,y+12));
|
|
}
|
|
|
|
SetHighColor(185,185,185);
|
|
// SetHighColor(145,145,145);
|
|
FillRect(BRect(pos+thickness-2,Bounds().top+pad+1,pos+thickness-2,Bounds().bottom-pad-1)) ;// 145
|
|
|
|
SetHighColor(145,145,145);
|
|
FillRect(BRect(pos+thickness-1,Bounds().top+pad+1,pos+thickness-1,Bounds().bottom-pad-1)); // 96
|
|
//FillRect(BRect(pos+thickness,Bounds().top+pad+1,pos+thickness,Bounds().bottom-pad-1));
|
|
}else{
|
|
SetHighColor(185,185,185);
|
|
// SetHighColor(145,145,145);
|
|
//FillRect(BRect(Bounds().left+pad+1,pos,Bounds().right-pad-1,pos)); // 145
|
|
FillRect(BRect(Bounds().left+pad+1,pos,Bounds().right-pad-1,pos)); // 145
|
|
|
|
SetHighColor(255,255,255);
|
|
FillRect(BRect(Bounds().left+pad+1,pos+1,Bounds().right-pad-1,pos+2)); // 255
|
|
|
|
//SetHighColor(216,216,216);
|
|
SetHighColor(Parent()->ViewColor());
|
|
FillRect(BRect(Bounds().left+pad+1,pos+2,Bounds().right-pad-1,pos+thickness-2));// 216
|
|
|
|
if(thickness>9)
|
|
{
|
|
SetHighColor(255,255,255);
|
|
float x = (Bounds().right - Bounds().left)/2;
|
|
float y = pos + (thickness/2);
|
|
SetPenSize(2);
|
|
StrokeLine(BPoint(x-11,y-3),BPoint(x-5,y+3));
|
|
StrokeLine(BPoint(x-7,y-3),BPoint(x-1,y+3));
|
|
StrokeLine(BPoint(x-3,y-3),BPoint(x+3,y+3));
|
|
StrokeLine(BPoint(x+1,y-3),BPoint(x+7,y+3));
|
|
StrokeLine(BPoint(x+5,y-3),BPoint(x+11,y+3));
|
|
SetPenSize(1);
|
|
SetHighColor(145,145,145);
|
|
StrokeLine(BPoint(x-10,y-3),BPoint(x-4,y+3));
|
|
StrokeLine(BPoint(x-6,y-3),BPoint(x+0,y+3));
|
|
StrokeLine(BPoint(x-2,y-3),BPoint(x+4,y+3));
|
|
StrokeLine(BPoint(x+2,y-3),BPoint(x+8,y+3));
|
|
StrokeLine(BPoint(x+6,y-3),BPoint(x+12,y+3));
|
|
}
|
|
|
|
SetHighColor(185,185,185);
|
|
// SetHighColor(145,145,145);
|
|
FillRect(BRect(Bounds().left+pad+1,pos+thickness-2,Bounds().right-pad-1,pos+thickness-2)) ;// 145
|
|
|
|
SetHighColor(145,145,145);
|
|
// SetHighColor(96,96,96);
|
|
FillRect(BRect(Bounds().left+pad+1,pos+thickness-1,Bounds().right-pad-1,pos+thickness-1)); // 96
|
|
//FillRect(BRect(Bounds().left+pad+1,pos+thickness,Bounds().right-pad-1,pos+thickness));
|
|
}
|
|
}
|
|
|
|
/*******************************************************
|
|
* Keeps Modes for both panles uptodate and acctually
|
|
* is the func that sets the location of the slider
|
|
*******************************************************/
|
|
void SplitPane::Update(){
|
|
Window()->Lock();
|
|
if(align == B_VERTICAL){
|
|
PaneOne->SetResizingMode(B_FOLLOW_LEFT|B_FOLLOW_TOP_BOTTOM);
|
|
PaneTwo->SetResizingMode(B_FOLLOW_LEFT_RIGHT|B_FOLLOW_TOP_BOTTOM);
|
|
if(pos > (Bounds().Width()-thickness-MinSizeTwo)){
|
|
if(!poslocked){
|
|
pos = (int)Bounds().Width()-thickness-MinSizeTwo;
|
|
}
|
|
}
|
|
if(pos < MinSizeOne){
|
|
if(!poslocked){
|
|
pos = MinSizeOne;
|
|
}
|
|
}
|
|
}else{
|
|
PaneOne->SetResizingMode(B_FOLLOW_LEFT_RIGHT|B_FOLLOW_TOP);
|
|
PaneTwo->SetResizingMode(B_FOLLOW_LEFT_RIGHT|B_FOLLOW_TOP_BOTTOM);
|
|
if(pos > (Bounds().Height()-thickness-MinSizeTwo)){
|
|
if(!poslocked){
|
|
pos = (int)Bounds().Height()-thickness-MinSizeTwo;
|
|
}
|
|
}
|
|
if(pos < MinSizeOne){
|
|
if(!poslocked){
|
|
pos = MinSizeOne;
|
|
}
|
|
}
|
|
}
|
|
|
|
// this block should go in FrameResized .. think about it
|
|
if(align == B_VERTICAL){
|
|
if(pos >= (Bounds().IntegerWidth()/2)){
|
|
//pos should follow the right side
|
|
// staying the same distans from it that
|
|
// it is right now
|
|
}
|
|
}else{
|
|
if(pos >= (Bounds().IntegerHeight()/2)){
|
|
//should follow bottom and stay the
|
|
// same distance that we are way from
|
|
// it now
|
|
}
|
|
}
|
|
|
|
|
|
if(PaneOne){
|
|
if(!WinOne){
|
|
if(align == B_VERTICAL){
|
|
PaneOne->MoveTo(pad,Bounds().top+pad);
|
|
PaneOne->ResizeTo(pos-pad, Bounds().Height()-pad-pad); // widht x height
|
|
}else{
|
|
PaneOne->MoveTo(pad,Bounds().top+pad);
|
|
PaneOne->ResizeTo(Bounds().Width()-pad-pad, pos-pad-pad); // widht x height
|
|
}
|
|
}
|
|
}
|
|
if(PaneTwo){
|
|
if(!WinTwo){
|
|
if(align == B_VERTICAL){
|
|
PaneTwo->MoveTo(pos+thickness,Bounds().top+pad);
|
|
PaneTwo->ResizeTo(Bounds().Width()-(pos+thickness)-pad, Bounds().Height()-pad-pad);
|
|
}else{
|
|
PaneTwo->MoveTo(Bounds().left+pad,pos+thickness);
|
|
PaneTwo->ResizeTo(Bounds().Width()-pad-pad, Bounds().Height()-pos-pad-thickness);
|
|
}
|
|
}
|
|
}
|
|
|
|
Window()->Unlock();
|
|
}
|
|
|
|
/*******************************************************
|
|
* Hook for when we click. This takes care of all the
|
|
* little stuff - Like where is the mouse and what is
|
|
* going on.
|
|
*******************************************************/
|
|
void SplitPane::MouseDown(BPoint where){
|
|
Window()->Lock();
|
|
BMessage *currentMsg = Window()->CurrentMessage();
|
|
if (currentMsg->what == B_MOUSE_DOWN) {
|
|
uint32 buttons = 0;
|
|
currentMsg->FindInt32("buttons", (int32 *)&buttons);
|
|
uint32 modifiers = 0;
|
|
currentMsg->FindInt32("modifiers", (int32 *)&modifiers);
|
|
uint32 clicks = 0;
|
|
currentMsg->FindInt32("clicks",(int32*)&clicks);
|
|
|
|
if (buttons & B_SECONDARY_MOUSE_BUTTON){
|
|
if(!alignlocked){
|
|
switch(align){
|
|
case B_VERTICAL:
|
|
align = B_HORIZONTAL;
|
|
break;
|
|
case B_HORIZONTAL:
|
|
align = B_VERTICAL;
|
|
break;
|
|
}
|
|
Update();
|
|
Invalidate();
|
|
}
|
|
|
|
/*if(VOneDetachable){
|
|
WinOne = new BWindow(ConvertToScreen(PaneOne->Bounds()),"PanelOne",B_TITLED_WINDOW,B_ASYNCHRONOUS_CONTROLS);
|
|
RemoveChild(PaneOne);
|
|
WinOne->AddChild(PaneOne);
|
|
PaneOne->SetResizingMode(B_FOLLOW_ALL_SIDES);
|
|
// PaneOne->SetTarget(this);
|
|
WinOne->Show();
|
|
}*/
|
|
}
|
|
// if((buttons & B_PRIMARY_MOUSE_BUTTON) && (clicks >= 2)){
|
|
//Config window for split pane
|
|
// (new BAlert(NULL,"This is - or will be - a configuration panel for SplitPane.","Ok"))->Go();
|
|
//ConfigWindow = new SplitPaneConfig(this);
|
|
//ConfigWindow->Show();
|
|
//}else
|
|
if((buttons & B_PRIMARY_MOUSE_BUTTON) && !Draggin){
|
|
if(!poslocked){
|
|
Draggin= true; // this is so we can drag
|
|
here = where;
|
|
}
|
|
SetMouseEventMask(B_POINTER_EVENTS,B_LOCK_WINDOW_FOCUS);
|
|
}
|
|
}
|
|
Window()->Unlock();
|
|
}
|
|
|
|
/*******************************************************
|
|
* If we unclick then stop dragging or whatever it is
|
|
* we are doing
|
|
*******************************************************/
|
|
void SplitPane::MouseUp(BPoint where){
|
|
Draggin = false; // stop following mouse
|
|
}
|
|
|
|
/*******************************************************
|
|
* If the mouse moves while we dragg. Then follow it
|
|
* Also Invalidate so we update the views
|
|
*******************************************************/
|
|
void SplitPane::MouseMoved(BPoint where,uint32 info,const BMessage *m){
|
|
if(Draggin){
|
|
switch(align){
|
|
case B_HORIZONTAL:
|
|
pos = (int)(where.y)-(thickness/2);//- here.x
|
|
break;
|
|
case B_VERTICAL:
|
|
pos = (int)(where.x)-(thickness/2);
|
|
break;
|
|
}
|
|
|
|
/*
|
|
// This code figures out which jump we are closest
|
|
// to and if needed we "snap" to that.
|
|
int c = Bounds().IntegerWidth() / pos
|
|
Jump * c ... hmmm this is not right at all
|
|
*/
|
|
|
|
if(pos < MinSizeOne){
|
|
pos = MinSizeOne;
|
|
}
|
|
|
|
if(align == B_VERTICAL){
|
|
if(pos > (Bounds().Width() - thickness - MinSizeTwo)){
|
|
pos = (int)(Bounds().Width() - thickness - MinSizeTwo + 1);
|
|
}
|
|
}else{
|
|
if(pos > (Bounds().Height() - thickness - MinSizeTwo)){
|
|
pos = (int)(Bounds().Height() - thickness - MinSizeTwo + 1);
|
|
}
|
|
}
|
|
|
|
Update();
|
|
|
|
Invalidate();
|
|
}
|
|
}
|
|
|
|
/*******************************************************
|
|
* If you already have a view One, but want to change
|
|
* if for some odd reason. This should work.
|
|
*******************************************************/
|
|
void SplitPane::AddChildOne(BView *v){
|
|
RemoveChild(PaneOne);
|
|
PaneOne = v;
|
|
AddChild(PaneOne);
|
|
}
|
|
/*void SplitPane::MakePaneTwoFocus()
|
|
{
|
|
if(PaneTwo)
|
|
PaneTwo->MakeFocus();
|
|
|
|
}
|
|
*/
|
|
/*******************************************************
|
|
* If you already have a view Two, and want to put
|
|
* another view there, this is what to use.
|
|
*******************************************************/
|
|
void SplitPane::AddChildTwo(BView* v,bool IsAdded,bool ShowAfterHide)
|
|
{
|
|
if(!v->IsHidden())
|
|
v->Hide();
|
|
|
|
PaneTwo = v;
|
|
//WinTwo = NULL;
|
|
|
|
|
|
PaneTwo = v;
|
|
if(IsAdded)
|
|
{
|
|
Update();
|
|
if(ShowAfterHide)
|
|
{
|
|
if(v->IsHidden())
|
|
v->Show();
|
|
}
|
|
|
|
}
|
|
if(!IsAdded)
|
|
{
|
|
AddChild(PaneTwo);
|
|
}
|
|
PaneTwo = v;
|
|
|
|
}
|
|
|
|
/*******************************************************
|
|
* Sets is we are horizontal or Vertical. We use the
|
|
* standard B_HORIZONTAL and B_VERTICAL flags for this
|
|
*******************************************************/
|
|
void SplitPane::SetAlignment(uint a){
|
|
align = a;
|
|
if(attached){
|
|
Update();
|
|
}
|
|
Invalidate();
|
|
}
|
|
|
|
/*******************************************************
|
|
* Returns wheather the slider is horizontal or vertical
|
|
*******************************************************/
|
|
uint SplitPane::GetAlignment(){
|
|
return align;
|
|
}
|
|
|
|
/*******************************************************
|
|
* Sets the location of the bar. (we do no bounds
|
|
* checking for you so if its off the window thats
|
|
* your problem)
|
|
*******************************************************/
|
|
void SplitPane::SetBarPosition(int i){
|
|
pos = i;
|
|
if(attached){
|
|
Update();
|
|
}
|
|
Invalidate();
|
|
}
|
|
|
|
/*******************************************************
|
|
* Returns about where the bar is ...
|
|
*******************************************************/
|
|
int SplitPane::GetBarPosition(){
|
|
return pos;
|
|
}
|
|
|
|
/*******************************************************
|
|
* Sets how thick the bar should be.
|
|
*******************************************************/
|
|
void SplitPane::SetBarThickness(int i){
|
|
thickness = i;
|
|
if(attached){
|
|
Update();
|
|
}
|
|
Invalidate();
|
|
}
|
|
|
|
/*******************************************************
|
|
* Retuns to us the thickness of the slider bar
|
|
*******************************************************/
|
|
int SplitPane::GetBarThickness(){
|
|
return thickness;
|
|
}
|
|
|
|
/*******************************************************
|
|
* Sets the amount of jump the bar has when it is
|
|
* moved. This can also be though of as snap. The bar
|
|
* will start at 0 and jump(snap) to everry J pixels.
|
|
*******************************************************/
|
|
void SplitPane::SetJump(int i){
|
|
jump = i;
|
|
if(attached){
|
|
Update();
|
|
}
|
|
}
|
|
|
|
/*******************************************************
|
|
* Lets you know what the jump is .. see SetJump
|
|
*******************************************************/
|
|
int SplitPane::GetJump(){
|
|
return jump;
|
|
}
|
|
|
|
/*******************************************************
|
|
* Do we have a View One or is it NULL
|
|
*******************************************************/
|
|
bool SplitPane::HasViewOne(){
|
|
if(PaneOne) return true;
|
|
return false;
|
|
}
|
|
|
|
/*******************************************************
|
|
* Do we have a View Two .. or is it NULL too
|
|
*******************************************************/
|
|
bool SplitPane::HasViewTwo(){
|
|
if(PaneTwo) return true;
|
|
return false;
|
|
}
|
|
|
|
/*******************************************************
|
|
* Sets wheather View one is detachable from the
|
|
* slider view and from the app. This will creat a
|
|
* window that is detached (floating) from the app.
|
|
*******************************************************/
|
|
void SplitPane::SetViewOneDetachable(bool b){
|
|
VOneDetachable = b;
|
|
}
|
|
|
|
/*******************************************************
|
|
* Sets view tow detachable or not
|
|
*******************************************************/
|
|
void SplitPane::SetViewTwoDetachable(bool b){
|
|
VTwoDetachable = b;
|
|
}
|
|
|
|
/*******************************************************
|
|
* Returns whether the view is detachable
|
|
*******************************************************/
|
|
bool SplitPane::IsViewOneDetachable(){
|
|
return VOneDetachable;
|
|
}
|
|
|
|
/*******************************************************
|
|
* Returns if this view is detachable
|
|
*******************************************************/
|
|
bool SplitPane::IsViewTwoDetachable(){
|
|
return VTwoDetachable;
|
|
}
|
|
|
|
/*******************************************************
|
|
* Tells the view if the user is alowed to open the
|
|
* configuration window for the slider.
|
|
*******************************************************/
|
|
void SplitPane::SetEditable(bool b){
|
|
//ADD CODE HERE YNOP
|
|
}
|
|
|
|
/*******************************************************
|
|
* Tells use if the split pane is user editable
|
|
*******************************************************/
|
|
bool SplitPane::IsEditable(){
|
|
return true; //ADD SOME MORE CODE HERE
|
|
}
|
|
|
|
/*******************************************************
|
|
* Sets the inset that the view has.
|
|
*******************************************************/
|
|
void SplitPane::SetViewInsetBy(int i){
|
|
pad = i;
|
|
if(attached){
|
|
Update();
|
|
} Invalidate();
|
|
}
|
|
|
|
/*******************************************************
|
|
* Returns to use the padding around the views
|
|
*******************************************************/
|
|
int SplitPane::GetViewInsetBy(){
|
|
return pad;
|
|
}
|
|
|
|
/*******************************************************
|
|
* This sets the minimum size that View one can be.
|
|
* if the user trys to go past this .. we just stop
|
|
* By default the minimum size is set to 0 (zero) so
|
|
* the user can put the slider anywhere.
|
|
*******************************************************/
|
|
void SplitPane::SetMinSizeOne(int i){
|
|
MinSizeOne = i;
|
|
}
|
|
|
|
/*******************************************************
|
|
* Gives us the minimum size that one can be.
|
|
*******************************************************/
|
|
int SplitPane::GetMinSizeOne(){
|
|
return MinSizeOne;
|
|
}
|
|
|
|
/*******************************************************
|
|
* This sets the Minimum size that the second view
|
|
* can be.
|
|
*******************************************************/
|
|
void SplitPane::SetMinSizeTwo(int i){
|
|
MinSizeTwo = i;
|
|
}
|
|
|
|
/*******************************************************
|
|
* Lets us know what that minimum size is.
|
|
*******************************************************/
|
|
int SplitPane::GetMinSizeTwo(){
|
|
return MinSizeTwo;
|
|
}
|
|
|
|
/*******************************************************
|
|
* Locks the bar from being moved by the User. The
|
|
* system can still move the bar (via SetBarPosition)
|
|
*******************************************************/
|
|
void SplitPane::SetBarLocked(bool b){
|
|
poslocked = b;
|
|
}
|
|
|
|
/*******************************************************
|
|
* Returns to use if the bar is in a locked state or
|
|
* not.
|
|
*******************************************************/
|
|
bool SplitPane::IsBarLocked(){
|
|
return poslocked;
|
|
}
|
|
|
|
/*******************************************************
|
|
* Locks the alignment of the bar. The user can no
|
|
* longer toggle between Horizontal and Vertical
|
|
* Slider bar. Again you can still progomaticly set
|
|
* the position how ever you want.
|
|
*******************************************************/
|
|
void SplitPane::SetBarAlignmentLocked(bool b){
|
|
alignlocked = b;
|
|
}
|
|
|
|
/*******************************************************
|
|
* Lets us know about the lock state of the bar
|
|
*******************************************************/
|
|
bool SplitPane::IsBarAlignmentLocked(){
|
|
return alignlocked;
|
|
}
|
|
|
|
/*******************************************************
|
|
* Gets the Total state of the bar, alignment, size,
|
|
* position and many other things that are required
|
|
* to fully capture the state of the SplitPane.
|
|
* We pack all of this into a cute little BMessage
|
|
* so that it is esally expandable and can be saved
|
|
* off easyaly too. The SplitPane System does not
|
|
* however save the state for you. Your program must
|
|
* grab the state and save it in its config file.
|
|
*******************************************************/
|
|
BMessage* SplitPane::GetState(){
|
|
BMessage *state;
|
|
|
|
state = new BMessage(SPLITPANE_STATE);
|
|
|
|
state->AddBool("onedetachable",VOneDetachable);
|
|
state->AddBool("twodetachable",VTwoDetachable);
|
|
state->AddInt32("align",align);
|
|
state->AddInt32("pos",pos);
|
|
state->AddInt32("thick",thickness);
|
|
state->AddInt32("jump",jump);
|
|
state->AddInt32("pad",pad);
|
|
state->AddInt32("minsizeone",MinSizeOne);
|
|
state->AddInt32("minsizetwo",MinSizeTwo);
|
|
state->AddBool("poslock",poslocked);
|
|
state->AddBool("alignlock",alignlocked);
|
|
return state;
|
|
// delete state;
|
|
}
|
|
|
|
/*******************************************************
|
|
* Sets the state of the SplitPane from a BMessage
|
|
* like the one recived from GetState().
|
|
* This is one of three ways the user can rebuild the
|
|
* state of the SplitPane. The second is to simply
|
|
* send the SplitPane the state message, it is the
|
|
* same as calling SetState but it ashyncronouse.
|
|
* The third way is to use all the Get/Set methouds
|
|
* for each element of the SplitPane, this way is
|
|
* long and boarding. I suggest you just send the
|
|
* View a message :)
|
|
*******************************************************/
|
|
void SplitPane::SetState(BMessage *state){
|
|
int32 Npos,Nthickness,Njump,Npad,NMSO,NMST;
|
|
int32 Nalign;//uint
|
|
|
|
if(state->FindBool("onedetachable",&VOneDetachable) != B_OK){
|
|
VOneDetachable = false;
|
|
}
|
|
if(state->FindBool("towdetachable",&VTwoDetachable) != B_OK){
|
|
VTwoDetachable = false;
|
|
}
|
|
if(state->FindInt32("align",&Nalign) == B_OK){
|
|
align = Nalign;
|
|
}
|
|
if(state->FindInt32("pos",&Npos) == B_OK){
|
|
pos = Npos;
|
|
}
|
|
if(state->FindInt32("thick",&Nthickness) == B_OK){
|
|
thickness = Nthickness;
|
|
}
|
|
if(state->FindInt32("jump",&Njump) == B_OK){
|
|
jump = Njump;
|
|
}
|
|
if(state->FindInt32("pad",&Npad) == B_OK){
|
|
pad = Npad;
|
|
}
|
|
if(state->FindInt32("minsizeonw",&NMSO) == B_OK){
|
|
MinSizeOne = NMSO;
|
|
}
|
|
if(state->FindInt32("minsizetwo",&NMST) == B_OK){
|
|
MinSizeTwo = NMST;
|
|
}
|
|
if(state->FindBool("poslock",&poslocked) != B_OK){
|
|
poslocked = false;
|
|
}
|
|
if(state->FindBool("alignlock",&alignlocked) != B_OK){
|
|
alignlocked = false;
|
|
}
|
|
|
|
Update();
|
|
Invalidate();
|
|
}
|
|
|
|
/*******************************************************
|
|
* Ok, hmm what does this do. NOT MUCH. if we get a
|
|
* STATE message then lets set the state. This is here
|
|
* to provide a asyncronuse way of seting the state and
|
|
* also to make life easyer.
|
|
*******************************************************/
|
|
void SplitPane::MessageReceived(BMessage *msg){
|
|
switch(msg->what){
|
|
case SPLITPANE_STATE:
|
|
SetState(msg);
|
|
break;
|
|
default:
|
|
BView::MessageReceived(msg);
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|