2003-02-15 18:28:22 +03:00
|
|
|
//------------------------------------------------------------------------------
|
2004-09-21 02:50:02 +04:00
|
|
|
// Copyright (c) 2001-2002, Haiku, Inc.
|
2003-02-15 18:28:22 +03:00
|
|
|
//
|
|
|
|
// Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
|
// copy of this software and associated documentation files (the "Software"),
|
|
|
|
// to deal in the Software without restriction, including without limitation
|
|
|
|
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
|
// and/or sell copies of the Software, and to permit persons to whom the
|
|
|
|
// Software is furnished to do so, subject to the following conditions:
|
|
|
|
//
|
|
|
|
// The above copyright notice and this permission notice shall be included in
|
|
|
|
// all copies or substantial portions of the Software.
|
|
|
|
//
|
|
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
|
|
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
|
|
// DEALINGS IN THE SOFTWARE.
|
|
|
|
//
|
|
|
|
// File Name: DefaultDecorator.cpp
|
|
|
|
// Author: DarkWyrm <bpmagic@columbus.rr.com>
|
|
|
|
// Description: Fallback decorator for the app_server
|
|
|
|
//
|
|
|
|
//------------------------------------------------------------------------------
|
2005-04-19 04:42:42 +04:00
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
|
2003-07-07 23:48:38 +04:00
|
|
|
#include <Rect.h>
|
2003-02-13 05:13:55 +03:00
|
|
|
#include <View.h>
|
2005-04-19 04:42:42 +04:00
|
|
|
|
2003-02-13 05:13:55 +03:00
|
|
|
#include "ColorUtils.h"
|
2005-04-19 04:42:42 +04:00
|
|
|
#include "DisplayDriver.h"
|
|
|
|
#include "FontServer.h"
|
|
|
|
#include "LayerData.h"
|
2003-07-28 21:09:49 +04:00
|
|
|
#include "PatternHandler.h"
|
2003-02-13 05:13:55 +03:00
|
|
|
#include "RGBColor.h"
|
2003-04-05 05:51:35 +04:00
|
|
|
|
2005-04-19 04:42:42 +04:00
|
|
|
#include "DefaultDecorator.h"
|
2003-09-04 01:43:09 +04:00
|
|
|
|
2004-03-28 19:03:34 +04:00
|
|
|
//#define USE_VIEW_FILL_HACK
|
2003-03-23 23:52:37 +03:00
|
|
|
|
2003-08-31 21:38:34 +04:00
|
|
|
//#define DEBUG_DECORATOR
|
2003-03-23 23:52:37 +03:00
|
|
|
#ifdef DEBUG_DECORATOR
|
2003-09-09 01:48:35 +04:00
|
|
|
# include <stdio.h>
|
|
|
|
# define STRACE(x) printf x
|
|
|
|
#else
|
|
|
|
# define STRACE(x) ;
|
2003-03-23 23:52:37 +03:00
|
|
|
#endif
|
|
|
|
|
2003-02-13 05:13:55 +03:00
|
|
|
DefaultDecorator::DefaultDecorator(BRect rect, int32 wlook, int32 wfeel, int32 wflags)
|
|
|
|
: Decorator(rect,wlook,wfeel,wflags)
|
|
|
|
{
|
2003-07-24 23:38:24 +04:00
|
|
|
|
2003-02-13 05:13:55 +03:00
|
|
|
taboffset=0;
|
2003-06-24 17:55:18 +04:00
|
|
|
titlepixelwidth=0;
|
2005-04-19 04:42:42 +04:00
|
|
|
|
|
|
|
ServerFont font(*fontserver->GetSystemBold());
|
|
|
|
font.SetSize(font.Size() * 1.1);
|
|
|
|
font.SetFlags(B_FORCE_ANTIALIASING);
|
|
|
|
font.SetSpacing(B_STRING_SPACING);
|
|
|
|
SetFont(&font);
|
2004-06-26 06:15:48 +04:00
|
|
|
|
2004-03-28 19:03:34 +04:00
|
|
|
framecolors=new RGBColor[6];
|
|
|
|
framecolors[0].SetColor(152,152,152);
|
|
|
|
framecolors[1].SetColor(255,255,255);
|
|
|
|
framecolors[2].SetColor(216,216,216);
|
2003-07-24 23:38:24 +04:00
|
|
|
framecolors[3].SetColor(136,136,136);
|
2004-03-28 19:03:34 +04:00
|
|
|
framecolors[4].SetColor(152,152,152);
|
|
|
|
framecolors[5].SetColor(96,96,96);
|
2004-06-26 06:15:48 +04:00
|
|
|
|
|
|
|
|
|
|
|
|
2003-09-07 01:09:11 +04:00
|
|
|
// Set appropriate colors based on the current focus value. In this case, each decorator
|
|
|
|
// defaults to not having the focus.
|
2003-07-24 23:38:24 +04:00
|
|
|
_SetFocus();
|
2003-09-07 01:09:11 +04:00
|
|
|
|
|
|
|
// Do initial decorator setup
|
2003-02-13 05:13:55 +03:00
|
|
|
_DoLayout();
|
|
|
|
|
2003-09-09 01:48:35 +04:00
|
|
|
// tab_highcol=_colors->window_tab;
|
|
|
|
// tab_lowcol=_colors->window_tab;
|
|
|
|
|
2004-10-16 06:02:27 +04:00
|
|
|
STRACE(("DefaultDecorator:\n"));
|
|
|
|
STRACE(("\tFrame (%.1f,%.1f,%.1f,%.1f)\n",rect.left,rect.top,rect.right,rect.bottom));
|
2003-02-13 05:13:55 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
DefaultDecorator::~DefaultDecorator(void)
|
|
|
|
{
|
2004-10-16 06:02:27 +04:00
|
|
|
STRACE(("DefaultDecorator: ~DefaultDecorator()\n"));
|
2003-07-24 23:38:24 +04:00
|
|
|
delete [] framecolors;
|
2003-02-13 05:13:55 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
click_type DefaultDecorator::Clicked(BPoint pt, int32 buttons, int32 modifiers)
|
|
|
|
{
|
2003-09-07 01:09:11 +04:00
|
|
|
#ifdef DEBUG_DECORATOR
|
|
|
|
printf("DefaultDecorator: Clicked\n");
|
|
|
|
printf("\tPoint: (%.1f,%.1f)\n",pt.x,pt.y);
|
|
|
|
printf("\tButtons:\n");
|
|
|
|
if(buttons==0)
|
|
|
|
printf("\t\tNone\n");
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if(buttons & B_PRIMARY_MOUSE_BUTTON)
|
|
|
|
printf("\t\tPrimary\n");
|
|
|
|
if(buttons & B_SECONDARY_MOUSE_BUTTON)
|
|
|
|
printf("\t\tSecondary\n");
|
|
|
|
if(buttons & B_TERTIARY_MOUSE_BUTTON)
|
|
|
|
printf("\t\tTertiary\n");
|
|
|
|
}
|
|
|
|
printf("\tModifiers:\n");
|
|
|
|
if(modifiers==0)
|
|
|
|
printf("\t\tNone\n");
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if(modifiers & B_CAPS_LOCK)
|
|
|
|
printf("\t\tCaps Lock\n");
|
|
|
|
if(modifiers & B_NUM_LOCK)
|
|
|
|
printf("\t\tNum Lock\n");
|
|
|
|
if(modifiers & B_SCROLL_LOCK)
|
|
|
|
printf("\t\tScroll Lock\n");
|
|
|
|
if(modifiers & B_LEFT_COMMAND_KEY)
|
|
|
|
printf("\t\t Left Command\n");
|
|
|
|
if(modifiers & B_RIGHT_COMMAND_KEY)
|
|
|
|
printf("\t\t Right Command\n");
|
|
|
|
if(modifiers & B_LEFT_CONTROL_KEY)
|
|
|
|
printf("\t\tLeft Control\n");
|
|
|
|
if(modifiers & B_RIGHT_CONTROL_KEY)
|
|
|
|
printf("\t\tRight Control\n");
|
|
|
|
if(modifiers & B_LEFT_OPTION_KEY)
|
|
|
|
printf("\t\tLeft Option\n");
|
|
|
|
if(modifiers & B_RIGHT_OPTION_KEY)
|
|
|
|
printf("\t\tRight Option\n");
|
|
|
|
if(modifiers & B_LEFT_SHIFT_KEY)
|
|
|
|
printf("\t\tLeft Shift\n");
|
|
|
|
if(modifiers & B_RIGHT_SHIFT_KEY)
|
|
|
|
printf("\t\tRight Shift\n");
|
|
|
|
if(modifiers & B_MENU_KEY)
|
|
|
|
printf("\t\tMenu\n");
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// In checking for hit test stuff, we start with the smallest rectangles the user might
|
|
|
|
// be clicking on and gradually work our way out into larger rectangles.
|
2003-02-13 05:13:55 +03:00
|
|
|
if(_closerect.Contains(pt))
|
2003-11-15 03:27:26 +03:00
|
|
|
return DEC_CLOSE;
|
2003-02-13 05:13:55 +03:00
|
|
|
|
|
|
|
if(_zoomrect.Contains(pt))
|
2003-11-15 03:27:26 +03:00
|
|
|
return DEC_ZOOM;
|
2003-02-13 05:13:55 +03:00
|
|
|
|
|
|
|
if(_resizerect.Contains(pt) && _look==B_DOCUMENT_WINDOW_LOOK)
|
2003-11-15 03:27:26 +03:00
|
|
|
return DEC_RESIZE;
|
2003-02-13 05:13:55 +03:00
|
|
|
|
|
|
|
// Clicking in the tab?
|
|
|
|
if(_tabrect.Contains(pt))
|
|
|
|
{
|
|
|
|
// Here's part of our window management stuff
|
|
|
|
if(buttons==B_SECONDARY_MOUSE_BUTTON)
|
2003-11-15 03:27:26 +03:00
|
|
|
return DEC_MOVETOBACK;
|
|
|
|
return DEC_DRAG;
|
2003-02-13 05:13:55 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// We got this far, so user is clicking on the border?
|
2004-03-28 19:03:34 +04:00
|
|
|
if (leftborder.Contains(pt) || rightborder.Contains(pt)
|
|
|
|
|| topborder.Contains(pt) || bottomborder.Contains(pt))
|
2003-02-13 05:13:55 +03:00
|
|
|
{
|
2004-03-28 19:03:34 +04:00
|
|
|
if (_look == B_TITLED_WINDOW_LOOK || _look == B_FLOATING_WINDOW_LOOK){
|
|
|
|
BRect temp(BPoint(bottomborder.right-18, bottomborder.bottom-18), bottomborder.RightBottom());
|
|
|
|
if (temp.Contains(pt))
|
|
|
|
return DEC_RESIZE;
|
|
|
|
}
|
2003-11-15 03:27:26 +03:00
|
|
|
return DEC_DRAG;
|
2003-02-13 05:13:55 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
// Guess user didn't click anything
|
2003-11-15 03:27:26 +03:00
|
|
|
return DEC_NONE;
|
2003-02-13 05:13:55 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void DefaultDecorator::_DoLayout(void)
|
|
|
|
{
|
2004-10-16 06:02:27 +04:00
|
|
|
STRACE(("DefaultDecorator: Do Layout\n"));
|
2003-02-13 05:13:55 +03:00
|
|
|
// Here we determine the size of every rectangle that we use
|
|
|
|
// internally when we are given the size of the client rectangle.
|
2003-07-28 21:09:49 +04:00
|
|
|
|
2003-07-24 23:38:24 +04:00
|
|
|
switch(GetLook())
|
|
|
|
{
|
2003-07-28 21:09:49 +04:00
|
|
|
case B_FLOATING_WINDOW_LOOK:
|
|
|
|
case B_MODAL_WINDOW_LOOK:
|
2003-07-24 23:38:24 +04:00
|
|
|
case B_BORDERED_WINDOW_LOOK:
|
|
|
|
case B_TITLED_WINDOW_LOOK:
|
|
|
|
case B_DOCUMENT_WINDOW_LOOK:
|
2003-08-31 21:38:34 +04:00
|
|
|
borderwidth = 5;
|
2003-07-24 23:38:24 +04:00
|
|
|
break;
|
|
|
|
default:
|
2003-08-31 21:38:34 +04:00
|
|
|
borderwidth = 0;
|
2003-07-24 23:38:24 +04:00
|
|
|
}
|
2003-08-31 21:38:34 +04:00
|
|
|
|
2003-09-07 01:09:11 +04:00
|
|
|
// distance from one item of the tab bar to another. In this case the text and close/zoom rects
|
2003-08-31 21:38:34 +04:00
|
|
|
textoffset = (_look==B_FLOATING_WINDOW_LOOK) ? 7 : 10;
|
|
|
|
|
2003-09-07 01:09:11 +04:00
|
|
|
// calculate our tab rect
|
2003-08-31 21:38:34 +04:00
|
|
|
_tabrect.Set( _frame.left - borderwidth,
|
|
|
|
_frame.top - borderwidth - 19.0,
|
|
|
|
((_frame.right - _frame.left) < 35.0 ?
|
|
|
|
_frame.left + 35.0 : _frame.right) + borderwidth,
|
2004-03-28 19:03:34 +04:00
|
|
|
_frame.top - borderwidth );
|
2003-08-31 21:38:34 +04:00
|
|
|
|
2003-09-07 01:09:11 +04:00
|
|
|
// make it text width sensitive
|
2003-08-31 21:38:34 +04:00
|
|
|
if(strlen(GetTitle())>1)
|
|
|
|
{
|
|
|
|
if(_driver)
|
2004-03-28 19:03:34 +04:00
|
|
|
titlepixelwidth=_driver->StringWidth(GetTitle(), _TitleWidth(), &_drawdata);
|
2003-08-31 21:38:34 +04:00
|
|
|
else
|
|
|
|
titlepixelwidth=10;
|
|
|
|
|
2003-09-07 01:09:11 +04:00
|
|
|
int32 tabLength = int32(14 + // _closerect width
|
2003-08-31 21:38:34 +04:00
|
|
|
textoffset + titlepixelwidth + textoffset +
|
|
|
|
14 + // _zoomrect width
|
2003-09-07 01:09:11 +04:00
|
|
|
8); // margins
|
2003-08-31 21:38:34 +04:00
|
|
|
int32 tabWidth = (int32)_tabrect.Width();
|
|
|
|
if ( tabLength < tabWidth )
|
|
|
|
_tabrect.right = _tabrect.left + tabLength;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
_tabrect.right = _tabrect.left + _tabrect.Width()/2;
|
|
|
|
|
2003-09-07 01:09:11 +04:00
|
|
|
// calculate left/top/right/bottom borders
|
2003-08-31 21:38:34 +04:00
|
|
|
if ( borderwidth != 0 ){
|
2004-03-28 19:03:34 +04:00
|
|
|
leftborder.Set( _frame.left - borderwidth, _frame.top,
|
|
|
|
_frame.left - 1, _frame.bottom);
|
|
|
|
rightborder.Set(_frame.right + 1, _frame.top ,
|
|
|
|
_frame.right + borderwidth, _frame.bottom);
|
|
|
|
topborder.Set( _frame.left - borderwidth, _frame.top - borderwidth,
|
|
|
|
_frame.right + borderwidth, _frame.top - 1);
|
|
|
|
bottomborder.Set( _frame.left - borderwidth, _frame.bottom + 1,
|
|
|
|
_frame.right + borderwidth, _frame.bottom + borderwidth);
|
2003-08-31 21:38:34 +04:00
|
|
|
}
|
|
|
|
else{
|
2003-09-07 01:09:11 +04:00
|
|
|
// no border ... (?) useful when displaying windows that are just images
|
2003-08-31 21:38:34 +04:00
|
|
|
leftborder.Set( 0.0, 0.0, -1.0, -1.0 );
|
|
|
|
rightborder.Set( 0.0, 0.0, -1.0, -1.0 );
|
|
|
|
topborder.Set( 0.0, 0.0, -1.0, -1.0 );
|
|
|
|
bottomborder.Set( 0.0, 0.0, -1.0, -1.0 );
|
|
|
|
}
|
|
|
|
|
2003-09-07 01:09:11 +04:00
|
|
|
// calculate resize rect
|
2004-03-28 19:03:34 +04:00
|
|
|
_resizerect.Set( bottomborder.right - 18.0, bottomborder.bottom - 18.0,
|
|
|
|
bottomborder.right - 3, bottomborder.bottom - 3);
|
2003-08-31 21:38:34 +04:00
|
|
|
|
2003-09-07 01:09:11 +04:00
|
|
|
// format tab rect for a floating window - make the rect smaller
|
2003-08-31 21:38:34 +04:00
|
|
|
if ( _look == B_FLOATING_WINDOW_LOOK ){
|
|
|
|
_tabrect.InsetBy( 0, 2 );
|
|
|
|
_tabrect.OffsetBy( 0, 2 );
|
|
|
|
}
|
|
|
|
|
2003-09-07 01:09:11 +04:00
|
|
|
// calulate close rect based on the tab rectangle
|
2003-08-31 21:38:34 +04:00
|
|
|
_closerect.Set( _tabrect.left + 4.0, _tabrect.top + 4.0,
|
|
|
|
_tabrect.left + 4.0 + 13.0, _tabrect.top + 4.0 + 13.0 );
|
|
|
|
|
2003-09-07 01:09:11 +04:00
|
|
|
// calulate zoom rect based on the tab rectangle
|
2003-08-31 21:38:34 +04:00
|
|
|
_zoomrect.Set( _tabrect.right - 4.0 - 13.0, _tabrect.top + 4.0,
|
|
|
|
_tabrect.right - 4.0, _tabrect.top + 4.0 + 13.0 );
|
|
|
|
|
2003-09-07 01:09:11 +04:00
|
|
|
// format close and zoom rects for a floating window - make rectangles smaller
|
2003-08-31 21:38:34 +04:00
|
|
|
if ( _look == B_FLOATING_WINDOW_LOOK ){
|
|
|
|
_closerect.InsetBy( 1, 1 );
|
|
|
|
_zoomrect.InsetBy( 1, 1 );
|
|
|
|
_closerect.OffsetBy( 0, -2 );
|
|
|
|
_zoomrect.OffsetBy( 0, -2 );
|
|
|
|
}
|
2003-02-13 05:13:55 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void DefaultDecorator::MoveBy(float x, float y)
|
|
|
|
{
|
|
|
|
MoveBy(BPoint(x,y));
|
|
|
|
}
|
|
|
|
|
|
|
|
void DefaultDecorator::MoveBy(BPoint pt)
|
|
|
|
{
|
2004-01-22 05:23:08 +03:00
|
|
|
STRACE(("DefaultDecorator: Move By (%.1f, %.1f)\n",pt.x,pt.y));
|
2003-02-13 05:13:55 +03:00
|
|
|
// Move all internal rectangles the appropriate amount
|
|
|
|
_frame.OffsetBy(pt);
|
|
|
|
_closerect.OffsetBy(pt);
|
|
|
|
_tabrect.OffsetBy(pt);
|
|
|
|
_resizerect.OffsetBy(pt);
|
|
|
|
_zoomrect.OffsetBy(pt);
|
2004-03-28 19:03:34 +04:00
|
|
|
_borderrect.OffsetBy(pt);
|
2003-08-31 21:38:34 +04:00
|
|
|
|
|
|
|
leftborder.OffsetBy(pt);
|
|
|
|
rightborder.OffsetBy(pt);
|
|
|
|
topborder.OffsetBy(pt);
|
|
|
|
bottomborder.OffsetBy(pt);
|
2003-02-13 05:13:55 +03:00
|
|
|
}
|
|
|
|
|
2004-05-16 23:15:36 +04:00
|
|
|
void DefaultDecorator::ResizeBy(float x, float y)
|
|
|
|
{
|
|
|
|
ResizeBy(BPoint(x,y));
|
|
|
|
}
|
|
|
|
|
|
|
|
void DefaultDecorator::ResizeBy(BPoint pt)
|
|
|
|
{
|
|
|
|
STRACE(("DefaultDecorator: Resize By (%.1f, %.1f)\n",pt.x,pt.y));
|
|
|
|
// Move all internal rectangles the appropriate amount
|
|
|
|
_frame.right += pt.x;
|
|
|
|
_frame.bottom += pt.y;
|
|
|
|
|
2004-10-16 06:02:27 +04:00
|
|
|
// TODO: make bigger/smaller
|
|
|
|
// _tabrect.
|
2004-05-16 23:15:36 +04:00
|
|
|
|
|
|
|
_resizerect.OffsetBy(pt);
|
2004-06-18 21:16:41 +04:00
|
|
|
// _zoomrect.OffsetBy(pt);
|
2004-05-16 23:15:36 +04:00
|
|
|
_borderrect.right += pt.x;
|
|
|
|
_borderrect.bottom += pt.y;
|
|
|
|
|
|
|
|
leftborder.bottom += pt.y;
|
|
|
|
topborder.right += pt.x;
|
|
|
|
rightborder.OffsetBy(pt.x, 0.0f);
|
|
|
|
rightborder.bottom += pt.y;
|
|
|
|
|
|
|
|
bottomborder.OffsetBy(0.0, pt.y);
|
|
|
|
bottomborder.right += pt.x;
|
|
|
|
}
|
|
|
|
|
2003-09-17 21:14:22 +04:00
|
|
|
void DefaultDecorator::GetFootprint(BRegion *region)
|
2003-02-13 05:13:55 +03:00
|
|
|
{
|
2004-01-22 05:23:08 +03:00
|
|
|
STRACE(("DefaultDecorator: Get Footprint\n"));
|
2003-02-13 05:13:55 +03:00
|
|
|
// This function calculates the decorator's footprint in coordinates
|
2003-02-14 04:53:53 +03:00
|
|
|
// relative to the layer. This is most often used to set a WinBorder
|
2003-02-13 05:13:55 +03:00
|
|
|
// object's visible region.
|
2003-09-17 21:14:22 +04:00
|
|
|
if(!region)
|
|
|
|
return;
|
2004-01-14 03:26:15 +03:00
|
|
|
|
2004-03-28 19:03:34 +04:00
|
|
|
region->MakeEmpty();
|
|
|
|
|
2004-01-22 05:23:08 +03:00
|
|
|
if(_look == B_NO_BORDER_WINDOW_LOOK)
|
|
|
|
{
|
2004-01-14 03:26:15 +03:00
|
|
|
return;
|
|
|
|
}
|
2004-03-28 19:03:34 +04:00
|
|
|
|
|
|
|
region->Include(leftborder);
|
|
|
|
region->Include(rightborder);
|
|
|
|
region->Include(topborder);
|
|
|
|
region->Include(bottomborder);
|
2003-02-13 05:13:55 +03:00
|
|
|
|
2004-01-22 05:23:08 +03:00
|
|
|
if(_look == B_BORDERED_WINDOW_LOOK)
|
2004-01-14 03:26:15 +03:00
|
|
|
return;
|
|
|
|
|
2003-09-17 21:14:22 +04:00
|
|
|
region->Include(_tabrect);
|
2004-03-28 19:03:34 +04:00
|
|
|
|
|
|
|
if(_look == B_DOCUMENT_WINDOW_LOOK)
|
|
|
|
region->Include(BRect(_frame.right - 13.0f, _frame.bottom - 13.0f,
|
|
|
|
_frame.right, _frame.bottom));
|
2003-02-13 05:13:55 +03:00
|
|
|
}
|
|
|
|
|
2004-05-26 20:38:58 +04:00
|
|
|
BRect DefaultDecorator::SlideTab(float dx, float dy)
|
2004-01-22 05:23:08 +03:00
|
|
|
{
|
2003-09-04 01:43:09 +04:00
|
|
|
//return Decorator::SlideTab(dx,dy);
|
|
|
|
return _tabrect;
|
|
|
|
}
|
|
|
|
|
2003-02-13 05:13:55 +03:00
|
|
|
void DefaultDecorator::_DrawTitle(BRect r)
|
|
|
|
{
|
2004-01-22 05:23:08 +03:00
|
|
|
STRACE(("_DrawTitle(%f,%f,%f,%f)\n", r.left, r.top, r.right, r.bottom));
|
2003-02-13 05:13:55 +03:00
|
|
|
// Designed simply to redraw the title when it has changed on
|
|
|
|
// the client side.
|
2005-04-19 04:42:42 +04:00
|
|
|
_drawdata.SetHighColor(_colors->window_tab_text);
|
|
|
|
_drawdata.SetLowColor(GetFocus() ? _colors->window_tab : _colors->inactive_window_tab);
|
2003-07-07 23:48:38 +04:00
|
|
|
|
2003-08-31 21:38:34 +04:00
|
|
|
int32 titlecount=_ClipTitle((_zoomrect.left-textoffset)-(_closerect.right+textoffset));
|
|
|
|
BString titlestr( GetTitle() );
|
|
|
|
|
2003-07-07 23:48:38 +04:00
|
|
|
if(titlecount<titlestr.CountChars())
|
|
|
|
{
|
|
|
|
titlestr.Truncate(titlecount-1);
|
|
|
|
titlestr+="...";
|
|
|
|
titlecount+=2;
|
|
|
|
}
|
2004-06-26 06:15:48 +04:00
|
|
|
|
2003-09-07 01:09:11 +04:00
|
|
|
// The text position needs tweaked when working as a floating window because the closerect placement
|
|
|
|
// is a little different. If it isn't moved, title placement looks really funky
|
|
|
|
if(_look==B_FLOATING_WINDOW_LOOK)
|
|
|
|
_driver->DrawString(titlestr.String(),titlecount,
|
2004-02-15 23:27:26 +03:00
|
|
|
BPoint(_closerect.right+textoffset,_closerect.bottom+1),&_drawdata);
|
2003-09-07 01:09:11 +04:00
|
|
|
else
|
2003-07-07 23:48:38 +04:00
|
|
|
_driver->DrawString(titlestr.String(),titlecount,
|
2004-02-15 23:27:26 +03:00
|
|
|
BPoint(_closerect.right+textoffset,_closerect.bottom),&_drawdata);
|
2003-02-13 05:13:55 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void DefaultDecorator::_SetFocus(void)
|
|
|
|
{
|
|
|
|
// SetFocus() performs necessary duties for color swapping and
|
|
|
|
// other things when a window is deactivated or activated.
|
|
|
|
|
|
|
|
if(GetFocus())
|
|
|
|
{
|
2003-09-07 01:09:11 +04:00
|
|
|
button_highcol.SetColor(tint_color(_colors->window_tab.GetColor32(),B_LIGHTEN_2_TINT));
|
|
|
|
button_lowcol.SetColor(tint_color(_colors->window_tab.GetColor32(),B_DARKEN_1_TINT));
|
2003-07-07 23:48:38 +04:00
|
|
|
textcol=_colors->window_tab_text;
|
2003-02-13 05:13:55 +03:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2003-09-07 01:09:11 +04:00
|
|
|
button_highcol.SetColor(tint_color(_colors->inactive_window_tab.GetColor32(),B_LIGHTEN_2_TINT));
|
|
|
|
button_lowcol.SetColor(tint_color(_colors->inactive_window_tab.GetColor32(),B_DARKEN_1_TINT));
|
2003-07-07 23:48:38 +04:00
|
|
|
textcol=_colors->inactive_window_tab_text;
|
2003-02-13 05:13:55 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void DefaultDecorator::Draw(BRect update)
|
|
|
|
{
|
2004-01-22 05:23:08 +03:00
|
|
|
STRACE(("DefaultDecorator: Draw(%.1f,%.1f,%.1f,%.1f)\n",update.left,update.top,update.right,update.bottom));
|
|
|
|
|
2003-02-13 05:13:55 +03:00
|
|
|
// We need to draw a few things: the tab, the resize thumb, the borders,
|
|
|
|
// and the buttons
|
|
|
|
|
|
|
|
_DrawFrame(update);
|
2003-08-31 21:38:34 +04:00
|
|
|
_DrawTab(update);
|
2003-02-13 05:13:55 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void DefaultDecorator::Draw(void)
|
|
|
|
{
|
|
|
|
// Easy way to draw everything - no worries about drawing only certain
|
|
|
|
// things
|
|
|
|
|
2004-03-28 19:03:34 +04:00
|
|
|
_DrawFrame(BRect(topborder.LeftTop(), bottomborder.RightBottom()));
|
2003-09-04 01:43:09 +04:00
|
|
|
_DrawTab(_tabrect);
|
2003-02-13 05:13:55 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void DefaultDecorator::_DrawZoom(BRect r)
|
|
|
|
{
|
2004-01-22 05:23:08 +03:00
|
|
|
STRACE(("_DrawZoom(%f,%f,%f,%f)\n", r.left, r.top, r.right, r.bottom));
|
2003-02-13 05:13:55 +03:00
|
|
|
// If this has been implemented, then the decorator has a Zoom button
|
|
|
|
// which should be drawn based on the state of the member zoomstate
|
2003-08-31 21:38:34 +04:00
|
|
|
BRect zr( r );
|
|
|
|
|
|
|
|
zr.left += 3.0;
|
|
|
|
zr.top += 3.0;
|
|
|
|
DrawBlendedRect( zr, GetZoom() );
|
|
|
|
|
|
|
|
zr = r;
|
|
|
|
zr.right -= 5.0;
|
|
|
|
zr.bottom -= 5.0;
|
|
|
|
DrawBlendedRect( zr, GetZoom() );
|
2003-02-13 05:13:55 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void DefaultDecorator::_DrawClose(BRect r)
|
|
|
|
{
|
2004-01-22 05:23:08 +03:00
|
|
|
STRACE(("_DrawClose(%f,%f,%f,%f)\n", r.left, r.top, r.right, r.bottom));
|
2003-02-13 05:13:55 +03:00
|
|
|
// Just like DrawZoom, but for a close button
|
2003-08-31 21:38:34 +04:00
|
|
|
DrawBlendedRect( r, GetClose());
|
2003-02-13 05:13:55 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
void DefaultDecorator::_DrawTab(BRect r)
|
|
|
|
{
|
2004-01-22 05:23:08 +03:00
|
|
|
STRACE(("_DrawTab(%f,%f,%f,%f)\n", r.left, r.top, r.right, r.bottom));
|
2003-02-13 05:13:55 +03:00
|
|
|
// If a window has a tab, this will draw it and any buttons which are
|
|
|
|
// in it.
|
2004-01-14 03:26:15 +03:00
|
|
|
if(_look == B_NO_BORDER_WINDOW_LOOK || _look == B_BORDERED_WINDOW_LOOK)
|
2003-02-13 05:13:55 +03:00
|
|
|
return;
|
2004-03-28 19:03:34 +04:00
|
|
|
|
|
|
|
RGBColor tabColor = (GetFocus())?_colors->window_tab:_colors->inactive_window_tab;
|
|
|
|
_driver->FillRect(_tabrect, tabColor);
|
2003-02-13 05:13:55 +03:00
|
|
|
|
2004-03-28 19:03:34 +04:00
|
|
|
_driver->StrokeLine(_tabrect.LeftTop(),_tabrect.LeftBottom(),framecolors[0]);
|
|
|
|
_driver->StrokeLine(_tabrect.LeftTop(),_tabrect.RightTop(),framecolors[0]);
|
|
|
|
_driver->StrokeLine(_tabrect.RightTop(),_tabrect.RightBottom(),framecolors[5]);
|
|
|
|
_driver->StrokeLine( BPoint( _tabrect.left + 2, _tabrect.bottom+1 ),
|
|
|
|
BPoint( _tabrect.right - 2, _tabrect.bottom+1 ),
|
|
|
|
framecolors[2]);
|
2004-01-27 03:38:14 +03:00
|
|
|
|
|
|
|
|
2004-03-28 19:03:34 +04:00
|
|
|
_driver->StrokeLine( BPoint( _tabrect.left + 1, _tabrect.top + 1 ),
|
|
|
|
BPoint( _tabrect.left + 1, _tabrect.bottom ),
|
2004-01-27 03:38:14 +03:00
|
|
|
framecolors[1]);
|
2004-03-28 19:03:34 +04:00
|
|
|
_driver->StrokeLine( BPoint( _tabrect.left + 1, _tabrect.top + 1 ),
|
|
|
|
BPoint( _tabrect.right - 1, _tabrect.top + 1 ),
|
|
|
|
framecolors[1]);
|
|
|
|
|
|
|
|
_driver->StrokeLine( BPoint( _tabrect.right - 1, _tabrect.top + 2 ),
|
|
|
|
BPoint( _tabrect.right - 1, _tabrect.bottom ),
|
|
|
|
framecolors[3]);
|
|
|
|
|
2003-06-24 17:55:18 +04:00
|
|
|
_DrawTitle(_tabrect);
|
|
|
|
|
2003-02-13 05:13:55 +03:00
|
|
|
// Draw the buttons if we're supposed to
|
|
|
|
if(!(_flags & B_NOT_CLOSABLE))
|
|
|
|
_DrawClose(_closerect);
|
2004-01-14 03:26:15 +03:00
|
|
|
if(!(_flags & B_NOT_ZOOMABLE) && _look != B_MODAL_WINDOW_LOOK)
|
2003-02-13 05:13:55 +03:00
|
|
|
_DrawZoom(_zoomrect);
|
|
|
|
}
|
|
|
|
|
2003-07-07 17:09:42 +04:00
|
|
|
void DefaultDecorator::_SetColors(void)
|
|
|
|
{
|
|
|
|
_SetFocus();
|
|
|
|
}
|
|
|
|
|
2003-02-13 05:13:55 +03:00
|
|
|
void DefaultDecorator::DrawBlendedRect(BRect r, bool down)
|
|
|
|
{
|
|
|
|
// This bad boy is used to draw a rectangle with a gradient.
|
|
|
|
// Note that it is not part of the Decorator API - it's specific
|
2004-02-15 23:27:26 +03:00
|
|
|
// to just the BeDecorator. Called by DrawZoom and DrawClose
|
2003-02-13 05:13:55 +03:00
|
|
|
|
2004-02-15 23:27:26 +03:00
|
|
|
// Actually just draws a blended square
|
|
|
|
int32 w=r.IntegerWidth(), h=r.IntegerHeight();
|
|
|
|
|
|
|
|
RGBColor temprgbcol;
|
2004-01-27 03:38:14 +03:00
|
|
|
rgb_color halfcol, startcol, endcol;
|
2003-02-13 05:13:55 +03:00
|
|
|
float rstep,gstep,bstep,i;
|
|
|
|
|
|
|
|
int steps=(w<h)?w:h;
|
|
|
|
|
|
|
|
if(down)
|
|
|
|
{
|
|
|
|
startcol=button_lowcol.GetColor32();
|
|
|
|
endcol=button_highcol.GetColor32();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
startcol=button_highcol.GetColor32();
|
|
|
|
endcol=button_lowcol.GetColor32();
|
|
|
|
}
|
|
|
|
|
|
|
|
halfcol=MakeBlendColor(startcol,endcol,0.5);
|
|
|
|
|
|
|
|
rstep=float(startcol.red-halfcol.red)/steps;
|
|
|
|
gstep=float(startcol.green-halfcol.green)/steps;
|
|
|
|
bstep=float(startcol.blue-halfcol.blue)/steps;
|
|
|
|
|
|
|
|
for(i=0;i<=steps; i++)
|
|
|
|
{
|
2004-01-27 03:38:14 +03:00
|
|
|
temprgbcol.SetColor(uint8(startcol.red-(i*rstep)),
|
|
|
|
uint8(startcol.green-(i*gstep)),
|
|
|
|
uint8(startcol.blue-(i*bstep)));
|
|
|
|
|
2003-02-13 05:13:55 +03:00
|
|
|
_driver->StrokeLine(BPoint(r.left,r.top+i),
|
2004-01-27 03:38:14 +03:00
|
|
|
BPoint(r.left+i,r.top),temprgbcol);
|
2003-02-13 05:13:55 +03:00
|
|
|
|
2004-01-27 03:38:14 +03:00
|
|
|
temprgbcol.SetColor(uint8(halfcol.red-(i*rstep)),
|
|
|
|
uint8(halfcol.green-(i*gstep)),
|
|
|
|
uint8(halfcol.blue-(i*bstep)));
|
|
|
|
|
2003-02-13 05:13:55 +03:00
|
|
|
_driver->StrokeLine(BPoint(r.left+steps,r.top+i),
|
2004-01-27 03:38:14 +03:00
|
|
|
BPoint(r.left+i,r.top+steps),temprgbcol);
|
2003-02-13 05:13:55 +03:00
|
|
|
}
|
2004-02-15 23:27:26 +03:00
|
|
|
|
|
|
|
// _layerdata.highcolor=startcol;
|
|
|
|
// _driver->FillRect(r,&_layerdata,pat_solidhigh);
|
|
|
|
_driver->StrokeRect(r,framecolors[3]);
|
2003-02-13 05:13:55 +03:00
|
|
|
}
|
|
|
|
|
2003-07-24 23:38:24 +04:00
|
|
|
void DefaultDecorator::_DrawFrame(BRect invalid)
|
2003-02-13 05:13:55 +03:00
|
|
|
{
|
2003-09-09 01:48:35 +04:00
|
|
|
STRACE(("_DrawFrame(%f,%f,%f,%f)\n", invalid.left, invalid.top,
|
|
|
|
invalid.right, invalid.bottom));
|
2004-03-28 19:03:34 +04:00
|
|
|
|
2003-07-24 23:38:24 +04:00
|
|
|
#ifdef USE_VIEW_FILL_HACK
|
2005-04-19 04:42:42 +04:00
|
|
|
_drawdata.SetHighColor(RGBColor(192, 192, 192 ));
|
|
|
|
_driver->FillRect(_frame, _drawdata.HighColor());
|
2003-07-24 23:38:24 +04:00
|
|
|
#endif
|
2003-03-31 01:09:39 +04:00
|
|
|
|
2004-01-14 03:26:15 +03:00
|
|
|
if(_look == B_NO_BORDER_WINDOW_LOOK)
|
|
|
|
return;
|
|
|
|
|
2004-01-22 05:23:08 +03:00
|
|
|
if(!borderwidth)
|
2003-02-13 05:13:55 +03:00
|
|
|
return;
|
|
|
|
|
2004-03-28 19:03:34 +04:00
|
|
|
{ // a block start
|
2003-07-24 23:38:24 +04:00
|
|
|
|
2004-03-28 19:03:34 +04:00
|
|
|
BRect r = BRect(topborder.LeftTop(), bottomborder.RightBottom());
|
|
|
|
//top
|
|
|
|
for (int8 i=0; i<5; i++){
|
|
|
|
_driver->StrokeLine(BPoint(r.left+i, r.top+i), BPoint(r.right-i, r.top+i), framecolors[i]);
|
2003-07-27 04:24:07 +04:00
|
|
|
}
|
2004-03-28 19:03:34 +04:00
|
|
|
//left
|
|
|
|
for (int8 i=0; i<5; i++){
|
|
|
|
_driver->StrokeLine(BPoint(r.left+i, r.top+i), BPoint(r.left+i, r.bottom-i), framecolors[i]);
|
2003-07-27 04:24:07 +04:00
|
|
|
}
|
2004-03-28 19:03:34 +04:00
|
|
|
//bottom
|
|
|
|
for (int8 i=0; i<5; i++){
|
|
|
|
_driver->StrokeLine(BPoint(r.left+i, r.bottom-i), BPoint(r.right-i, r.bottom-i), framecolors[(4-i)==4? 5: (4-i)]);
|
2003-07-24 23:38:24 +04:00
|
|
|
}
|
2004-03-28 19:03:34 +04:00
|
|
|
//right
|
|
|
|
for (int8 i=0; i<5; i++){
|
|
|
|
_driver->StrokeLine(BPoint(r.right-i, r.top+i), BPoint(r.right-i, r.bottom-i), framecolors[(4-i)==4? 5: (4-i)]);
|
2003-07-27 04:24:07 +04:00
|
|
|
}
|
|
|
|
|
2004-03-28 19:03:34 +04:00
|
|
|
} // end of the block/
|
|
|
|
|
2003-07-28 21:09:49 +04:00
|
|
|
// Draw the resize thumb if we're supposed to
|
2003-02-13 05:13:55 +03:00
|
|
|
if(!(_flags & B_NOT_RESIZABLE))
|
|
|
|
{
|
2004-03-28 19:03:34 +04:00
|
|
|
BRect r = _resizerect;
|
2003-07-28 23:13:24 +04:00
|
|
|
|
2004-01-14 03:26:15 +03:00
|
|
|
switch(_look){
|
|
|
|
// This code is strictly for B_DOCUMENT_WINDOW looks
|
|
|
|
case B_DOCUMENT_WINDOW_LOOK:{
|
|
|
|
|
|
|
|
// Explicitly locking the driver is normally unnecessary. However, we need to do
|
|
|
|
// this because we are rapidly drawing a series of calls which would not necessarily
|
|
|
|
// draw correctly if we didn't do so.
|
2004-03-28 19:03:34 +04:00
|
|
|
float x = r.right;
|
|
|
|
float y = r.bottom;
|
2004-01-14 03:26:15 +03:00
|
|
|
_driver->Lock();
|
2004-03-28 19:03:34 +04:00
|
|
|
_driver->FillRect(BRect(x-13, y-13, x, y), framecolors[2]);
|
|
|
|
_driver->StrokeLine(BPoint(x-15, y-15), BPoint(x-15, y-2), framecolors[0]);
|
|
|
|
_driver->StrokeLine(BPoint(x-14, y-14), BPoint(x-14, y-1), framecolors[1]);
|
|
|
|
_driver->StrokeLine(BPoint(x-15, y-15), BPoint(x-2, y-15), framecolors[0]);
|
|
|
|
_driver->StrokeLine(BPoint(x-14, y-14), BPoint(x-1, y-14), framecolors[1]);
|
|
|
|
|
|
|
|
for(int8 i=1; i <= 4; i++){
|
|
|
|
for(int8 j=1; j<=i; j++){
|
|
|
|
BPoint pt1(x-(3*j)+1, y-(3*(5-i))+1);
|
|
|
|
BPoint pt2(x-(3*j)+2, y-(3*(5-i))+2);
|
|
|
|
_driver->StrokePoint(pt1, framecolors[0]);
|
|
|
|
_driver->StrokePoint(pt2, framecolors[1]);
|
|
|
|
}
|
2004-01-14 03:26:15 +03:00
|
|
|
}
|
2004-03-28 19:03:34 +04:00
|
|
|
// RGBColor c(255,128,0);
|
|
|
|
// _driver->FillRect(BRect(50,50,600,400), c);
|
2004-01-14 03:26:15 +03:00
|
|
|
_driver->Unlock();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
case B_TITLED_WINDOW_LOOK:
|
|
|
|
case B_FLOATING_WINDOW_LOOK:{
|
2004-03-28 19:03:34 +04:00
|
|
|
_driver->StrokeLine(BPoint(rightborder.left, rightborder.bottom-13),
|
|
|
|
BPoint(rightborder.right, rightborder.bottom-13),
|
|
|
|
framecolors[2]);
|
2004-07-21 20:52:55 +04:00
|
|
|
_driver->StrokeLine(BPoint(bottomborder.right-18, bottomborder.top),
|
2004-03-28 19:03:34 +04:00
|
|
|
BPoint(bottomborder.right-18, bottomborder.bottom),
|
|
|
|
framecolors[2]);
|
2004-01-14 03:26:15 +03:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
default:{
|
|
|
|
// draw no resize corner
|
|
|
|
break;
|
2003-02-13 05:13:55 +03:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|