зеркало из https://github.com/mozilla/gecko-dev.git
1141 строка
34 KiB
C++
1141 строка
34 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
|
*
|
|
* The contents of this file are subject to the Netscape Public
|
|
* License Version 1.1 (the "License"); you may not use this file
|
|
* except in compliance with the License. You may obtain a copy of
|
|
* the License at http://www.mozilla.org/NPL/
|
|
*
|
|
* Software distributed under the License is distributed on an "AS
|
|
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
* implied. See the License for the specific language governing
|
|
* rights and limitations under the License.
|
|
*
|
|
* The Original Code is mozilla.org code.
|
|
*
|
|
* The Initial Developer of the Original Code is Netscape
|
|
* Communications Corporation. Portions created by Netscape are
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All
|
|
* Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
*/
|
|
|
|
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
|
|
// author: atotic
|
|
// See UTearOffPalette.h for usage instructions and design notes
|
|
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
|
|
|
|
#include "UTearOffPalette.h"
|
|
#include "prtypes.h"
|
|
#include "CToolbarModeManager.h"
|
|
#include "CToolbarPatternBevelView.h"
|
|
#include "prefapi.h"
|
|
#include "uapp.h"
|
|
|
|
// PowerPlant
|
|
#include <LStream.h>
|
|
#include <URegions.h>
|
|
#include <LArray.h>
|
|
#include <LArrayIterator.h>
|
|
|
|
#define FLOAT_ID -19844 // Same define is in UFloatWindow.r
|
|
#define SIDE_FLOAT_ID -19845 // Same define is in UFloatWindow.r
|
|
|
|
#pragma mark CTearOffBar
|
|
#pragma mark -
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ Constructor from stream
|
|
// ---------------------------------------------------------------------------
|
|
// Read in the data
|
|
|
|
CTearOffBar::CTearOffBar(LStream* inStream) : LView(inStream)
|
|
{
|
|
*inStream >> fFloatingSubpaneID;
|
|
*inStream >> fInPlaceSubpaneID;
|
|
*inStream >> fAutoResize;
|
|
*inStream >> fVisibility;
|
|
*inStream >> fTitle;
|
|
*inStream >> fSideTitle;
|
|
*inStream >> fDisablePaletteWithWindow;
|
|
|
|
fOriginalFrameSize = mFrameSize;
|
|
fShown = false;
|
|
fTransparentPane = 0;
|
|
fAllowClickDrag = false;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ Destructor
|
|
// ---------------------------------------------------------------------------
|
|
// Unregister with the manager
|
|
|
|
CTearOffBar::~CTearOffBar()
|
|
{
|
|
CTearOffManager::GetDefaultManager()->UnregisterBar(this);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ FinishCreateSelf
|
|
// ---------------------------------------------------------------------------
|
|
// Register with the manager
|
|
|
|
void CTearOffBar::FinishCreateSelf()
|
|
{
|
|
CTearOffManager::GetDefaultManager()->RegisterBar(this);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ Click
|
|
// ---------------------------------------------------------------------------
|
|
// Slightly modified LView::Click
|
|
// We should handle clicks in the transparent pane
|
|
// We need this because the PPob view that holds the buttons that we put inside
|
|
// completely covers this view. Unless we make that view transparent, we'll never
|
|
// get any clicks
|
|
|
|
void CTearOffBar::Click( SMouseDownEvent &inMouseDown )
|
|
{
|
|
// Check if a SubPane of this View
|
|
// is hit
|
|
// Modified code
|
|
// Check if we have clicked on a 0 pane
|
|
LPane *clickedPane = FindDeepSubPaneContaining(inMouseDown.wherePort.h,
|
|
inMouseDown.wherePort.v );
|
|
if (clickedPane != nil && clickedPane->GetPaneID() == fTransparentPane)
|
|
{
|
|
LPane::Click(inMouseDown);
|
|
return;
|
|
}
|
|
|
|
// LView::Click code
|
|
clickedPane = FindSubPaneHitBy(inMouseDown.wherePort.h,
|
|
inMouseDown.wherePort.v);
|
|
|
|
if ( clickedPane != nil )
|
|
{ // SubPane is hit, let it respond to the Click
|
|
clickedPane->Click(inMouseDown);
|
|
|
|
} else { // No SubPane hit, or maybe pane 0. Inherited function
|
|
LPane::Click(inMouseDown); // will process click on this View
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ ClickSelf
|
|
// ---------------------------------------------------------------------------
|
|
// Drag the outline of the bar out of the window
|
|
// Roughly copied out of UDesktop::DragDeskWindow
|
|
|
|
void CTearOffBar::ClickSelf(const SMouseDownEvent &inMouseDown)
|
|
{
|
|
if (::WaitMouseUp()) { // Continue if mouse hasn't been
|
|
// released
|
|
|
|
GrafPtr savePort; // Use ScreenPort for dragging
|
|
GetPort(&savePort);
|
|
GrafPtr screenPort = UScreenPort::GetScreenPort();
|
|
::SetPort(screenPort);
|
|
StColorPenState::Normalize();
|
|
|
|
// Get surrounding rectangle in global port coordinates
|
|
|
|
Rect frame;
|
|
Point topLeft, botRight;
|
|
topLeft.h = mFrameLocation.h;
|
|
topLeft.v = mFrameLocation.v;
|
|
botRight.h = topLeft.h + mFrameSize.width;
|
|
botRight.v = topLeft.v + mFrameSize.height;
|
|
PortToGlobalPoint(topLeft);
|
|
PortToGlobalPoint(botRight);
|
|
|
|
::SetRect( &frame, topLeft.h, topLeft.v, botRight.h, botRight.v );
|
|
StRegion dragRgn(frame);
|
|
|
|
// Let user drag a dotted outline
|
|
// of the Window
|
|
Rect dragRect = (**(GetGrayRgn())).rgnBBox;
|
|
::InsetRect(&dragRect, 4, 4);
|
|
|
|
Int32 dragDistance = ::DragGrayRgn(dragRgn, inMouseDown.macEvent.where,
|
|
&dragRect, &dragRect,
|
|
noConstraint, nil);
|
|
::SetPort(savePort);
|
|
|
|
// Check if the Window moved to a new, valid location.
|
|
// DragGrayRgn returns the constant Drag_Aborted if the
|
|
// user dragged outside the DragRect, which cancels
|
|
// the drag operation. We also check for the case where
|
|
// the drag finished at its original location (zero distance).
|
|
|
|
Int16 horizDrag = LoWord(dragDistance);
|
|
Int16 vertDrag = HiWord(dragDistance);
|
|
|
|
if (dragDistance == 0x80008000) return;
|
|
// 0x80008000 == Drag_Aborted from UFloatingDesktop
|
|
Boolean realDrag = horizDrag != 0 || vertDrag != 0;
|
|
if (fAllowClickDrag || realDrag)
|
|
{
|
|
|
|
// A valid drag occurred. horizDrag and vertDrag are
|
|
// distances from the current location. We need to
|
|
// get the new location for the Window in global
|
|
// coordinates. The bounding box of the Window's
|
|
// content region gives the current location in
|
|
// global coordinates. Add drag distances to this
|
|
// to get the new location.
|
|
CTearOffManager::GetDefaultManager()->DragBar(this,
|
|
topLeft.h + horizDrag,
|
|
topLeft.v + vertDrag,
|
|
realDrag);
|
|
}
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ AddListener
|
|
// ---------------------------------------------------------------------------
|
|
// Tell manager that we have a listener
|
|
|
|
void CTearOffBar::AddListener(LListener *inListener)
|
|
{
|
|
LBroadcaster::AddListener(inListener);
|
|
CTearOffManager::GetDefaultManager()->RegisterListener(this, inListener);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ ListenToMessage
|
|
// ---------------------------------------------------------------------------
|
|
// Tell TearOffManager that we got the message
|
|
void CTearOffBar::ListenToMessage(MessageT inMessage, void *ioParam)
|
|
{
|
|
CTearOffManager::GetDefaultManager()->BarReceivedMessage(this, inMessage, ioParam);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ ListenToMessage
|
|
// ---------------------------------------------------------------------------
|
|
// Tell TearOffManager that we got the message
|
|
void CTearOffBar::ActivateSelf()
|
|
{
|
|
LView::ActivateSelf();
|
|
CTearOffManager::GetDefaultManager()->BarActivated(this);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ ListenToMessage
|
|
// ---------------------------------------------------------------------------
|
|
// Tell TearOffManager that we got the message
|
|
void CTearOffBar::DeactivateSelf()
|
|
{
|
|
LView::DeactivateSelf();
|
|
CTearOffManager::GetDefaultManager()->BarDeactivated(this);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ HidePalette
|
|
// ---------------------------------------------------------------------------
|
|
// Delete all the subpanes.
|
|
// Manager will broadcast a message msg_FloatPalleteRemoved to your listener
|
|
void CTearOffBar::HidePalette()
|
|
{
|
|
DeleteAllSubPanes();
|
|
if (fAutoResize)
|
|
ResizeFrameTo(0,0,TRUE);
|
|
else
|
|
Refresh();
|
|
fShown = false;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ ShowPalette
|
|
// ---------------------------------------------------------------------------
|
|
// Reads in the subview from PPob.
|
|
// Position the view properly
|
|
|
|
void CTearOffBar::ShowPalette()
|
|
{
|
|
if (fShown)
|
|
return;
|
|
// setup commander (window), superview(this), and listener(this)
|
|
|
|
SetDefaultView(this);
|
|
LWindow * commander = LWindow::FetchWindowObject(GetMacPort());
|
|
SignalIfNot_( commander );
|
|
|
|
LView * view = UReanimator::CreateView(fInPlaceSubpaneID, this, commander);
|
|
|
|
SignalIfNot_ ( view ); // We need that pane ID
|
|
|
|
view->FinishCreate();
|
|
fTransparentPane = view->GetPaneID();
|
|
UReanimator::LinkListenerToControls(this, this, fInPlaceSubpaneID);
|
|
UReanimator::LinkListenerToControls(CTearOffManager::GetDefaultManager(),
|
|
this, fInPlaceSubpaneID);
|
|
|
|
if (fAutoResize)
|
|
ResizeFrameTo(fOriginalFrameSize.width, fOriginalFrameSize.height, TRUE);
|
|
#ifdef DEBUG
|
|
if (fAutoResize)
|
|
{
|
|
SDimension16 s;
|
|
view->GetFrameSize(s);
|
|
// The container and the loaded view should be the same width/height???
|
|
SignalIf_(s.width != fOriginalFrameSize.width);
|
|
SignalIf_(s.height != fOriginalFrameSize.height);
|
|
}
|
|
#endif
|
|
fShown = true;
|
|
}
|
|
|
|
#pragma mark -
|
|
#pragma mark CTearOffWindow
|
|
#pragma mark -
|
|
/************************************************************************
|
|
* class CTearOffWindow
|
|
*
|
|
* just registers/unregisters itself with the
|
|
* You cannot subclass this class, because CTearOffManager creates all
|
|
* palettes out of a single PPob.
|
|
************************************************************************/
|
|
#define SAVE_POSITION 1
|
|
|
|
#if SAVE_POSITION
|
|
#include "CSaveWindowStatus.h"
|
|
#endif // SAVE_POSITION
|
|
|
|
//======================================
|
|
class CTearOffWindow
|
|
: public LWindow,
|
|
public CToolbarModeChangeListener
|
|
#if SAVE_POSITION
|
|
, public CSaveWindowStatus
|
|
#endif // SAVE_POSITION
|
|
//======================================
|
|
{
|
|
private:
|
|
typedef LWindow Inherited;
|
|
friend class CTearOffManager;
|
|
public:
|
|
enum { class_ID = 'DRFW' };
|
|
|
|
// Constructors
|
|
|
|
CTearOffWindow(LStream* inStream);
|
|
|
|
virtual ~CTearOffWindow();
|
|
|
|
// Events
|
|
virtual void ListenToMessage(MessageT inMessage, void *ioParam);
|
|
|
|
virtual void HandleModeChange(Int8 inNewMode);
|
|
virtual void DoSetZoom( Boolean );
|
|
virtual void AdjustWindowSizeBy( SDimension16& size_change );
|
|
|
|
#if SAVE_POSITION
|
|
private:
|
|
virtual ResIDT GetStatusResID(void) const { return FLOAT_ID; }
|
|
virtual UInt16 GetValidStatusVersion(void) const { return 0x0111; }
|
|
virtual void FinishCreateSelf();
|
|
virtual void AttemptClose();
|
|
virtual void DoClose();
|
|
#endif // SAVE_POSITION
|
|
private:
|
|
UInt8 fVisibility; // Inherited from the bar
|
|
};
|
|
|
|
//-----------------------------------
|
|
CTearOffWindow::CTearOffWindow(LStream* inStream)
|
|
//-----------------------------------
|
|
: LWindow(inStream)
|
|
, CSaveWindowStatus(this)
|
|
{
|
|
PREF_SetBoolPref("taskbar.mac.is_open", true);
|
|
}
|
|
|
|
//-----------------------------------
|
|
CTearOffWindow::~CTearOffWindow()
|
|
//-----------------------------------
|
|
{
|
|
// Notify the manager
|
|
CTearOffManager::GetDefaultManager()->UnregisterWindow(this);
|
|
|
|
// YIKES! Save this preference if the app _isn't_ quitting. What an ugly hack!
|
|
if ( CFrontApp::sApplication->GetState() == programState_ProcessingEvents )
|
|
PREF_SetBoolPref("taskbar.mac.is_open", false);
|
|
}
|
|
|
|
#if SAVE_POSITION
|
|
|
|
//-----------------------------------
|
|
void CTearOffWindow::FinishCreateSelf()
|
|
//-----------------------------------
|
|
{
|
|
Inherited::FinishCreateSelf();
|
|
CSaveWindowStatus::FinishCreateWindow();
|
|
|
|
SDimension16 zero_zero = {0,0};
|
|
AdjustWindowSizeBy(zero_zero);
|
|
}
|
|
|
|
//-----------------------------------
|
|
void CTearOffWindow::AttemptClose()
|
|
//-----------------------------------
|
|
{
|
|
AttemptCloseWindow();
|
|
Inherited::AttemptClose();
|
|
}
|
|
|
|
//-----------------------------------
|
|
void CTearOffWindow::DoClose()
|
|
//-----------------------------------
|
|
{
|
|
AttemptCloseWindow();
|
|
Inherited::DoClose();
|
|
}
|
|
|
|
#endif // SAVE_POSITION
|
|
|
|
|
|
void CTearOffWindow::HandleModeChange( Int8 inNewMode )
|
|
{
|
|
SDimension16 size_change={ 0, 0 };
|
|
if ( CToolbarButtonContainer* container_ptr = dynamic_cast<CToolbarButtonContainer*>(FindPaneByID('TBPv')) )
|
|
container_ptr->HandleModeChange(inNewMode, size_change);
|
|
AdjustWindowSizeBy(size_change);
|
|
}
|
|
|
|
|
|
void CTearOffWindow::DoSetZoom( Boolean )
|
|
{
|
|
SDimension16 size_change={ 0, 0 };
|
|
if ( CToolbarPatternBevelView* container_ptr = dynamic_cast<CToolbarPatternBevelView*>(FindPaneByID('TBPv')) )
|
|
container_ptr->RotateArrangement(size_change);
|
|
AdjustWindowSizeBy(size_change);
|
|
|
|
SDimension16 frameSize;
|
|
GetFrameSize(frameSize);
|
|
PREF_SetBoolPref("taskbar.mac.is_vertical", XP_Bool(frameSize.height > frameSize.width));
|
|
}
|
|
|
|
void CTearOffWindow::AdjustWindowSizeBy( SDimension16& size_change )
|
|
{
|
|
/*
|
|
Always adjust the size (even if size_change is {0,0}) because the caller
|
|
might be trying to ensure that the window is pinned to the screen.
|
|
*/
|
|
Rect frame_rect;
|
|
CalcPortFrameRect(frame_rect);
|
|
PortToGlobalPoint(topLeft(frame_rect));
|
|
PortToGlobalPoint(botRight(frame_rect));
|
|
|
|
frame_rect.right += size_change.width;
|
|
frame_rect.bottom += size_change.height;
|
|
|
|
VerifyWindowBounds(mWindowSelf, &frame_rect);
|
|
|
|
DoSetBounds(frame_rect);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ CTearOffWindow destructor
|
|
// ---------------------------------------------------------------------------
|
|
// Pass on to the manager
|
|
void CTearOffWindow::ListenToMessage(MessageT inMessage, void *ioParam)
|
|
{
|
|
if ( inMessage == CToolbarModeManager::msg_ToolbarModeChange )
|
|
HandleModeChange((Int8)ioParam);
|
|
else
|
|
CTearOffManager::GetDefaultManager()->WindowReceivedMessage(this, inMessage, ioParam);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* class CTearOffManager
|
|
*****************************************************************************/
|
|
#pragma mark -
|
|
#pragma mark CTearOffManager
|
|
#pragma mark -
|
|
CTearOffManager * CTearOffManager::sDefaultFloatManager = NULL;
|
|
|
|
#pragma mark struct ButtonBarRecord
|
|
// holds information about a single button bar, stored in fPaletteBars list
|
|
struct ButtonBarRecord
|
|
{
|
|
ResIDT fID; // ResID of the PPob loaded into the button bar.
|
|
ResIDT fWindowID; // ResID of the PPob loaded into the floating window.
|
|
CTearOffBar * fBar; // Pointer to the bar
|
|
LListener * fListener; // The listener for this bar
|
|
|
|
ButtonBarRecord()
|
|
{
|
|
fID = -1;
|
|
fWindowID = -1;
|
|
fBar = NULL;
|
|
fListener = NULL;
|
|
}
|
|
|
|
ButtonBarRecord(ResIDT id, ResIDT wID, CTearOffBar * bar, LListener * listener)
|
|
{
|
|
fID = id;
|
|
fWindowID = wID;
|
|
fBar = bar;
|
|
fListener = listener;
|
|
}
|
|
};
|
|
|
|
/****************************************************************************
|
|
* struct FloatWindowRecord
|
|
* used to keep a list of loaded windows
|
|
****************************************************************************/
|
|
#pragma mark struct FloatWindowRecord
|
|
struct FloatWindowRecord
|
|
{
|
|
CTearOffWindow * fWindow;
|
|
ResIDT fID; // Res ID of the PPob to be loaeded
|
|
CTearOffBar * fActiveBar;
|
|
|
|
FloatWindowRecord(CTearOffWindow * window, ResIDT resID, CTearOffBar * activeBar = NULL)
|
|
{
|
|
fWindow = window;
|
|
fID = resID;
|
|
fActiveBar = activeBar;
|
|
}
|
|
|
|
};
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ Compare the window records
|
|
// ---------------------------------------------------------------------------
|
|
// Wildcards can be used for fID and fWindow fields
|
|
// fListener field is not used.
|
|
|
|
#define WILDCARD -1
|
|
|
|
Int32 CTearOffManager::CPaletteWindowComparator::Compare(const void* inItemOne,
|
|
const void* inItemTwo,
|
|
Uint32 inSizeOne,
|
|
Uint32 inSizeTwo) const
|
|
{
|
|
#pragma unused (inSizeOne, inSizeTwo) // Cause we know what the items are
|
|
|
|
FloatWindowRecord * item1 = (FloatWindowRecord *)inItemOne;
|
|
FloatWindowRecord * item2 = (FloatWindowRecord *)inItemTwo;
|
|
|
|
if ( item1->fID != item2->fID && // Different floaters
|
|
(item1->fID != WILDCARD) &&
|
|
(item2->fID != WILDCARD))
|
|
return (item1->fWindow - item2->fWindow);
|
|
else // Same floaters
|
|
if ( item1->fWindow == item2->fWindow ||
|
|
( item1->fWindow == (void*)WILDCARD ) ||
|
|
( item2->fWindow == (void*)WILDCARD ) )
|
|
return 0;
|
|
else
|
|
return item1->fWindow - item2->fWindow;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ Compare the bars
|
|
// ---------------------------------------------------------------------------
|
|
// Wildcards can be used for fID and fBar fields
|
|
// fListener field is not used.
|
|
|
|
Int32 CTearOffManager::CPaletteBarComparator::Compare(const void* inItemOne,
|
|
const void* inItemTwo,
|
|
Uint32 inSizeOne,
|
|
Uint32 inSizeTwo) const
|
|
{
|
|
#pragma unused (inSizeOne, inSizeTwo) // Cause we know what the items are
|
|
|
|
ButtonBarRecord * item1 = (ButtonBarRecord *)inItemOne;
|
|
ButtonBarRecord * item2 = (ButtonBarRecord *)inItemTwo;
|
|
|
|
|
|
if ( item1->fID != item2->fID && // Different IDs
|
|
(item1->fID != WILDCARD) &&
|
|
(item2->fID != WILDCARD) )
|
|
return ( item1->fBar - item2->fBar );
|
|
if (item1->fWindowID != item2->fWindowID && // Different floaters
|
|
(item1->fWindowID != WILDCARD) &&
|
|
(item2->fWindowID != WILDCARD) )
|
|
return ( item1->fBar - item2->fBar );
|
|
else // Same floaters
|
|
if ( item1->fBar == item2->fBar ||
|
|
( item1->fBar == (void*)WILDCARD ) ||
|
|
( item2->fBar == (void*)WILDCARD ) )
|
|
return 0;
|
|
else
|
|
return item1->fBar - item2->fBar;
|
|
return 0; // Kill the warning
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ CTearOffManager Constructor
|
|
// ---------------------------------------------------------------------------
|
|
// sets the default manager
|
|
|
|
CTearOffManager::CTearOffManager(LCommander * defaultCommander)
|
|
{
|
|
sDefaultFloatManager = this;
|
|
|
|
// These lists cannot be sorted, because sometimes we do wildcard lookups
|
|
// If you want to sort them, implement CompareKey better
|
|
fPaletteBars = new LArray( sizeof (ButtonBarRecord), &fBarCompare, false );
|
|
fPaletteWindows = new LArray( sizeof (FloatWindowRecord), &fWindowCompare, false );
|
|
|
|
fDefaultCommander = defaultCommander;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ CTearOffManager destructor -- never called, here for completeness
|
|
// ---------------------------------------------------------------------------
|
|
// clean up
|
|
CTearOffManager::~CTearOffManager()
|
|
{
|
|
delete fPaletteBars;
|
|
delete fPaletteWindows;
|
|
}
|
|
|
|
|
|
void CTearOffManager::ListenToMessage(MessageT inMessage, void *ioParam)
|
|
{
|
|
BroadcastMessage(inMessage, ioParam);
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ RegisterBar
|
|
// ---------------------------------------------------------------------------
|
|
// Insert the bar in the bar list. Hide or show it, depending on the window
|
|
|
|
void CTearOffManager::RegisterBar(CTearOffBar * inBar)
|
|
{
|
|
// Insert it into the list
|
|
ButtonBarRecord barRec( inBar->fInPlaceSubpaneID, inBar->fFloatingSubpaneID, inBar, NULL);
|
|
fPaletteBars->InsertItemsAt(1, fPaletteBars->GetCount(), &barRec, sizeof( barRec ) );
|
|
|
|
// Decide whether to hide or show the bar
|
|
|
|
FloatWindowRecord fr( (CTearOffWindow *)WILDCARD, inBar->fFloatingSubpaneID );
|
|
ArrayIndexT where = fPaletteWindows->FetchIndexOfKey( &fr );
|
|
if ( where != LArray::index_Bad )
|
|
inBar->HidePalette();
|
|
else
|
|
inBar->ShowPalette();
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ UnregisterBar
|
|
// ---------------------------------------------------------------------------
|
|
// Remove the bar from the bar list
|
|
// If there are any "left-over" floaters, remove them
|
|
|
|
void CTearOffManager::UnregisterBar(CTearOffBar * inBar)
|
|
{
|
|
ButtonBarRecord bar( WILDCARD, WILDCARD, inBar, NULL);
|
|
ArrayIndexT where = fPaletteBars->FetchIndexOfKey(&bar);
|
|
if ( where != LArray::index_Bad )
|
|
fPaletteBars->RemoveItemsAt( 1, where );
|
|
else
|
|
SignalCStr_("Unregistering a bar that was never registered?");
|
|
|
|
// If there are no other bars with the same ID,
|
|
// remove the floater window (floater might not exist)
|
|
|
|
ButtonBarRecord brotherBar( inBar->fInPlaceSubpaneID, inBar->fFloatingSubpaneID,
|
|
(CTearOffBar *)WILDCARD, NULL );
|
|
|
|
where = fPaletteBars->FetchIndexOfKey(&brotherBar);
|
|
if ( where == LArray::index_Bad )
|
|
// Remove the floaters with this ID
|
|
{
|
|
FloatWindowRecord fw( (CTearOffWindow*) WILDCARD, inBar->fFloatingSubpaneID );
|
|
ArrayIndexT where = fPaletteWindows->FetchIndexOfKey( &fw );
|
|
if ( where != LArray::index_Bad )
|
|
{
|
|
fPaletteWindows->FetchItemAt( where, &fw );
|
|
if (fw.fWindow->fVisibility != 0)
|
|
delete fw.fWindow; // this will automatically remove it from the list
|
|
}
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ RegisterListener
|
|
// ---------------------------------------------------------------------------
|
|
// Set the listener
|
|
// Broadcast the palette message to the window, depending on where the palette is
|
|
|
|
void CTearOffManager::RegisterListener(CTearOffBar * inBar,
|
|
LListener * listener)
|
|
{
|
|
ButtonBarRecord bar( WILDCARD, WILDCARD, inBar, listener );
|
|
ArrayIndexT where = fPaletteBars->FetchIndexOfKey(&bar);
|
|
if (where != LArray::index_Bad)
|
|
{
|
|
// assign the listener
|
|
fPaletteBars->FetchItemAt( where, &bar );
|
|
bar.fListener = listener;
|
|
fPaletteBars->AssignItemsAt( 1, where , &bar );
|
|
|
|
// broadcast the palette message to the listener
|
|
FloatWindowRecord fr( (CTearOffWindow *)WILDCARD, inBar->fFloatingSubpaneID );
|
|
ArrayIndexT where = fPaletteWindows->FetchIndexOfKey( &fr );
|
|
|
|
if ( where != LArray::index_Bad )
|
|
{
|
|
// We have a window to register
|
|
fPaletteWindows->FetchItemAt( where, &fr );
|
|
SetBarsView( inBar, fr.fWindow );
|
|
}
|
|
else
|
|
// The bar holds the palette
|
|
{
|
|
SetBarsView( inBar, inBar );
|
|
}
|
|
}
|
|
else
|
|
SignalCStr_("Bar never registered?");
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ BarReceivedMessage
|
|
// ---------------------------------------------------------------------------
|
|
// Relay the message to its listeners
|
|
|
|
void CTearOffManager::BarReceivedMessage(CTearOffBar * inBar,
|
|
MessageT inMessage,
|
|
void *ioParam)
|
|
{
|
|
ButtonBarRecord bar( WILDCARD, WILDCARD, inBar, NULL );
|
|
ArrayIndexT where = fPaletteBars->FetchIndexOfKey(&bar);
|
|
|
|
if ( where != LArray::index_Bad )
|
|
{
|
|
fPaletteBars->FetchItemAt( where, &bar );
|
|
// SignalIfNot_(bar.fListener);
|
|
if (bar.fListener)
|
|
bar.fListener->ListenToMessage( inMessage, ioParam );
|
|
}
|
|
else
|
|
SignalCStr_("Bar never registered?");
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ DragBar
|
|
// ---------------------------------------------------------------------------
|
|
// Assert that the window exists
|
|
// move it to the new location
|
|
|
|
void CTearOffManager::DragBar( CTearOffBar * inBar,
|
|
Int16 inH,
|
|
Int16 inV,
|
|
Boolean usePosition )
|
|
{
|
|
try
|
|
{
|
|
CTearOffWindow * win = AssertBarWindowExists(inBar);
|
|
|
|
#if SAVE_POSITION
|
|
if (usePosition) {
|
|
#endif
|
|
Point topLeft;
|
|
topLeft.h = inH;
|
|
topLeft.v = inV;
|
|
win->DoSetPosition(topLeft);
|
|
#if SAVE_POSITION
|
|
}
|
|
#endif
|
|
win->Show();
|
|
|
|
SetBarsView( inBar, win );
|
|
}
|
|
catch(OSErr inErr)
|
|
{
|
|
SignalCStr_("Did you include UTearOffPalette.r in your project?");
|
|
// No window, button bar stays where it was
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ BarActivated
|
|
// ---------------------------------------------------------------------------
|
|
// Upon activation:
|
|
// Tell its float windowGets the floater window for the bar
|
|
// Tells listener what the current palette is
|
|
//
|
|
void CTearOffManager::BarActivated( CTearOffBar * inBar)
|
|
{
|
|
// Find the floater window
|
|
FloatWindowRecord fw( (CTearOffWindow *) WILDCARD, inBar->fFloatingSubpaneID );
|
|
ArrayIndexT where = fPaletteWindows->FetchIndexOfKey( &fw );
|
|
|
|
// If we have a window, make this bar the active one
|
|
if ( where != LArray::index_Bad )
|
|
{
|
|
fPaletteWindows->FetchItemAt( where, &fw );
|
|
if ( fw.fActiveBar != inBar )
|
|
{
|
|
if ( fw.fActiveBar == NULL ) // If there was no view, we need to enable us
|
|
{
|
|
LPane * view;
|
|
LArrayIterator iter( fw.fWindow->GetSubPanes());
|
|
if ( iter.Next(&view) ) // We have disabled this on suspends
|
|
view->Enable();
|
|
}
|
|
|
|
fw.fActiveBar = inBar;
|
|
fPaletteWindows->AssignItemsAt( 1, where , &fw );
|
|
fw.fWindow->Show();
|
|
|
|
|
|
SetBarsView(inBar, fw.fWindow);
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ BarDeactivated
|
|
// ---------------------------------------------------------------------------
|
|
// Upon deactivation
|
|
// If we have a floating window, make it inactive and tell listener about it
|
|
|
|
void CTearOffManager::BarDeactivated( CTearOffBar * inBar)
|
|
{
|
|
FloatWindowRecord fw( (CTearOffWindow *) WILDCARD, inBar->fFloatingSubpaneID );
|
|
ArrayIndexT where = fPaletteWindows->FetchIndexOfKey( &fw );
|
|
|
|
if ( where != LArray::index_Bad )
|
|
{
|
|
fPaletteWindows->FetchItemAt( where, &fw );
|
|
if ( fw.fActiveBar == inBar )
|
|
{
|
|
if ( fw.fWindow->fVisibility == 2 )
|
|
fw.fWindow->Hide();
|
|
else
|
|
{
|
|
if (inBar->DisablePaletteWindow())
|
|
{
|
|
// Disable all the subpanes of our main subpane
|
|
// Do not disable the main pane, because no one enables it
|
|
LPane * view;
|
|
LArrayIterator iter( fw.fWindow->GetSubPanes());
|
|
if ( iter.Next(&view) )
|
|
view->Disable();
|
|
}
|
|
}
|
|
fw.fActiveBar = NULL;
|
|
fPaletteWindows->AssignItemsAt( 1, where , &fw );
|
|
RemoveBarsView(inBar, inBar->fTransparentPane);
|
|
}
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ SetBarsView
|
|
// ---------------------------------------------------------------------------
|
|
// Tell listener what its palette view is
|
|
// InView is either FBar, or FWindow. In either case, the palette is the first subview
|
|
|
|
void CTearOffManager::SetBarsView( CTearOffBar * inBar,
|
|
LView * inView)
|
|
{
|
|
SignalIfNot_( inView );
|
|
|
|
// Get the bar record
|
|
ButtonBarRecord br( WILDCARD, WILDCARD, inBar, (LListener*) WILDCARD );
|
|
ArrayIndexT where = fPaletteBars->FetchIndexOfKey( &br );
|
|
|
|
if ( where != LArray::index_Bad )
|
|
{
|
|
fPaletteBars->FetchItemAt( where, &br );
|
|
if ( br.fListener )
|
|
{
|
|
// Palette is the first subview
|
|
LView * topPaletteView;
|
|
LArrayIterator iter( inView->GetSubPanes());
|
|
if ( iter.Next(&topPaletteView) )
|
|
br.fListener->ListenToMessage( msg_SetTearOffPalette, topPaletteView );
|
|
}
|
|
}
|
|
else
|
|
SignalCStr_("Where is the bar?");
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ RemoveBarsView
|
|
// ---------------------------------------------------------------------------
|
|
// Similar to SetBarsView. Must get the top pane ID from somewhere
|
|
|
|
void CTearOffManager::RemoveBarsView( CTearOffBar * inBar, PaneIDT inViewID)
|
|
{
|
|
ButtonBarRecord br( WILDCARD, WILDCARD, inBar, (LListener*) WILDCARD );
|
|
ArrayIndexT where = fPaletteBars->FetchIndexOfKey( &br );
|
|
|
|
if ( where != LArray::index_Bad )
|
|
{
|
|
fPaletteBars->FetchItemAt( where, &br );
|
|
if ( br.fListener )
|
|
br.fListener->ListenToMessage( msg_RemoveTearOffPalette, (void*) inViewID );
|
|
}
|
|
else
|
|
SignalCStr_("Where is the bar?");
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ AssertBarWindowExists
|
|
// ---------------------------------------------------------------------------
|
|
// Create the window if it does not exist
|
|
|
|
CTearOffWindow * CTearOffManager::AssertBarWindowExists(CTearOffBar * inBar)
|
|
{
|
|
return AssertBarWindowExists(
|
|
inBar->fFloatingSubpaneID,
|
|
inBar->IsFloaterOnSide(),
|
|
inBar->fVisibility,
|
|
inBar->fTitle
|
|
);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ AssertBarWindowExists
|
|
// ---------------------------------------------------------------------------
|
|
// Create the window if it does not exist
|
|
|
|
CTearOffWindow * CTearOffManager::AssertBarWindowExists(ResIDT inWinID,
|
|
Boolean inSideways,
|
|
UInt8 visibility,
|
|
Str255 &title)
|
|
{
|
|
FloatWindowRecord fw( (CTearOffWindow *) WILDCARD, inWinID );
|
|
ArrayIndexT where = fPaletteWindows->FetchIndexOfKey( &fw );
|
|
CTearOffWindow * newWindow = nil;
|
|
if (where == LArray::index_Bad)
|
|
{
|
|
// Create a new window, load the palette into it
|
|
ResIDT windowResID = inSideways ? SIDE_FLOAT_ID : FLOAT_ID;
|
|
|
|
newWindow = (CTearOffWindow *) LWindow::CreateWindow(windowResID, fDefaultCommander);
|
|
|
|
ThrowIfNil_(newWindow);
|
|
newWindow->fVisibility = visibility;
|
|
|
|
LView * view = UReanimator::CreateView(inWinID, newWindow, newWindow);
|
|
ThrowIfNil_( view );
|
|
view->FinishCreate();
|
|
|
|
UReanimator::LinkListenerToControls(CTearOffManager::GetDefaultManager(),
|
|
view, inWinID);
|
|
// Resize the window
|
|
Point corner = {0,0};
|
|
#if SAVE_POSITION
|
|
newWindow->PortToGlobalPoint(corner);
|
|
#endif
|
|
SDimension16 viewSize;
|
|
Rect winBounds;
|
|
view->GetFrameSize(viewSize);
|
|
::SetRect(&winBounds,
|
|
corner.h, corner.v,
|
|
corner.h + viewSize.width, corner.v + viewSize.height);
|
|
newWindow->DoSetBounds( winBounds );
|
|
newWindow->SetDescriptor(title);
|
|
|
|
SBooleanRect boundToSuperview={ true, true, true, true };
|
|
view->SetFrameBinding(boundToSuperview);
|
|
|
|
Int32 toolbarStyle;
|
|
if ( (PREF_GetIntPref("browser.chrome.toolbar_style", &toolbarStyle) == PREF_NOERROR)
|
|
&& (toolbarStyle != CToolbarModeManager::defaultToolbarMode) )
|
|
{
|
|
((CTearOffWindow*)newWindow)->HandleModeChange(toolbarStyle);
|
|
}
|
|
|
|
XP_Bool is_vertical = true;
|
|
if ( (PREF_GetBoolPref("taskbar.mac.is_vertical", &is_vertical) == PREF_NOERROR)
|
|
&& !is_vertical )
|
|
{
|
|
((CTearOffWindow*)newWindow)->DoSetZoom(Boolean());
|
|
}
|
|
|
|
// Add the record to the list of managed floaters
|
|
FloatWindowRecord fw(newWindow, inWinID, NULL);
|
|
fPaletteWindows->InsertItemsAt( 1, fPaletteWindows->GetCount(), &fw, sizeof (fw) );
|
|
|
|
// Hide the bars button palletes
|
|
LArrayIterator iter(*fPaletteBars);
|
|
ButtonBarRecord bar;
|
|
while ( iter.Next(&bar) )
|
|
if (bar.fWindowID == fw.fID)
|
|
{
|
|
bar.fBar->HidePalette();
|
|
bar.fBar->fTransparentPane = view->GetPaneID();
|
|
RemoveBarsView( bar.fBar, bar.fBar->fTransparentPane );
|
|
}
|
|
// Link up the new controls
|
|
UReanimator::LinkListenerToControls( newWindow, newWindow, fw.fID );
|
|
}
|
|
else
|
|
{
|
|
fPaletteWindows->FetchItemAt( where, &fw );
|
|
return fw.fWindow;
|
|
}
|
|
return newWindow;
|
|
} // CTearOffManager::AssertBarWindowExists
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ UnregisterWindow
|
|
// ---------------------------------------------------------------------------
|
|
// Remove the window from the list
|
|
// Show all the floaters
|
|
|
|
void CTearOffManager::UnregisterWindow(CTearOffWindow * window)
|
|
{
|
|
// Remove the window from the list
|
|
FloatWindowRecord fw( window, WILDCARD );
|
|
ArrayIndexT where = fPaletteWindows->FetchIndexOfKey( &fw );
|
|
|
|
if ( where != LArray::index_Bad )
|
|
{
|
|
fPaletteWindows->FetchItemAt( where, &fw );
|
|
fPaletteWindows->RemoveItemsAt( 1, where );
|
|
}
|
|
else
|
|
SignalCStr_("Removal of unregistered window?");
|
|
|
|
// Tell all button bars to show themselves
|
|
|
|
LArrayIterator iter(*fPaletteBars);
|
|
ButtonBarRecord bar;
|
|
while ( iter.Next(&bar) )
|
|
if (bar.fWindowID == fw.fID)
|
|
{
|
|
bar.fBar->ShowPalette();
|
|
SetBarsView(bar.fBar, bar.fBar);
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ CloseFloatingWindow
|
|
// ---------------------------------------------------------------------------
|
|
// Closes the Floating Window
|
|
|
|
void CTearOffManager::CloseFloatingWindow(ResIDT inWinID)
|
|
{
|
|
// find the window in the list
|
|
FloatWindowRecord fw((CTearOffWindow *)WILDCARD, inWinID, (CTearOffBar *)WILDCARD );
|
|
ArrayIndexT where = fPaletteWindows->FetchIndexOfKey( &fw );
|
|
|
|
if ( where != LArray::index_Bad )
|
|
{
|
|
fPaletteWindows->FetchItemAt( where, &fw );
|
|
fw.fWindow->ProcessCommand(cmd_Close);
|
|
}
|
|
else
|
|
{
|
|
SignalCStr_("close of unregistered window?");
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ OpenFloatingWindow
|
|
// ---------------------------------------------------------------------------
|
|
// Opens the Floating Window
|
|
|
|
void CTearOffManager::OpenFloatingWindow( ResIDT inWinID,
|
|
Point /* inTopLeft */,
|
|
Boolean inSideways,
|
|
UInt8 visibility,
|
|
Str255 &title)
|
|
{
|
|
// find the window in the list
|
|
FloatWindowRecord fw((CTearOffWindow *)WILDCARD, inWinID, (CTearOffBar *)WILDCARD );
|
|
ArrayIndexT where = fPaletteWindows->FetchIndexOfKey( &fw );
|
|
|
|
if (LArray::index_Bad == where)
|
|
{
|
|
try
|
|
{
|
|
CTearOffWindow * win = AssertBarWindowExists(inWinID, inSideways, visibility, title);
|
|
|
|
#if !SAVE_POSITION
|
|
win->DoSetPosition(inTopLeft);
|
|
#endif
|
|
win->Show();
|
|
}
|
|
catch(OSErr inErr)
|
|
{
|
|
SignalCStr_("Did you include UTearOffPalette.r in your project?");
|
|
// No window, button bar stays where it was
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SignalCStr_("open of open window?");
|
|
}
|
|
}
|
|
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ IsFloatingWindow
|
|
// ---------------------------------------------------------------------------
|
|
// Closes the Floating Window
|
|
|
|
Boolean CTearOffManager::IsFloatingWindow(ResIDT inWinID)
|
|
{
|
|
// find the window in the list
|
|
FloatWindowRecord fw((CTearOffWindow *)WILDCARD, inWinID, (CTearOffBar *)WILDCARD );
|
|
ArrayIndexT where = fPaletteWindows->FetchIndexOfKey( &fw );
|
|
|
|
return where != LArray::index_Bad;
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ WindowReceivedMessage
|
|
// ---------------------------------------------------------------------------
|
|
// Rebroadcast the message to the listener of the currently active bar
|
|
void CTearOffManager::WindowReceivedMessage(CTearOffWindow * inWin,
|
|
MessageT inMessage,
|
|
void *ioParam)
|
|
{
|
|
// Get the window record
|
|
FloatWindowRecord fw( inWin, WILDCARD );
|
|
ArrayIndexT where = fPaletteWindows->FetchIndexOfKey( &fw );
|
|
|
|
if ( where != LArray::index_Bad )
|
|
{
|
|
fPaletteWindows->FetchItemAt( where, &fw );
|
|
|
|
// If there is an active bar attached to this window
|
|
// rebroadcast the message to its listener
|
|
|
|
if (fw.fActiveBar)
|
|
{
|
|
ButtonBarRecord bar( WILDCARD, WILDCARD, fw.fActiveBar , NULL );
|
|
where = fPaletteBars->FetchIndexOfKey(&bar);
|
|
if ( where != LArray::index_Bad )
|
|
{
|
|
fPaletteBars->FetchItemAt( where, &bar );
|
|
if ( bar.fListener != NULL )
|
|
bar.fListener->ListenToMessage( inMessage, ioParam );
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
SignalCStr_("Message from a window we do not know about?");
|
|
}
|
|
|
|
#pragma mark -
|
|
// ---------------------------------------------------------------------------
|
|
// ¥ InitUTearOffPalette [static]
|
|
// ---------------------------------------------------------------------------
|
|
// Registers classes, creates a single float manager
|
|
void InitUTearOffPalette(LCommander * defCommander)
|
|
{
|
|
RegisterClass_( CTearOffBar);
|
|
RegisterClass_( CTearOffWindow);
|
|
new CTearOffManager(defCommander);
|
|
}
|
|
|