mozilla
/
pjs
зеркало из https://github.com/mozilla/pjs.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

fixes so that RDF toolbars can work too.

This commit is contained in:
pinkerton%netscape.com 1998-10-01 21:35:41 +00:00
Родитель 77e82cb96a
Коммит 0f407a1c12
2 изменённых файлов: 0 добавлений и 696 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

591
cmd/macfe/gui/CDragBarContainer.cp
Просмотреть файл

@ -1,591 +0,0 @@
/* -*- 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.0 (the "NPL"); you may not use this file except in
* compliance with the NPL. You may obtain a copy of the NPL at
* http://www.mozilla.org/NPL/
*
* Software distributed under the NPL is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
* for the specific language governing rights and limitations under the
* NPL.
*
* The Initial Developer of this code under the NPL is Netscape
* Communications Corporation. Portions created by Netscape are
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
* Reserved.
*/
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// CDragBarContainer.cp
//
//
// NOTE: It is assumed that the first level sub views of this container are
// either CDragBar's or the CDragBarDockControl.
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
#include "CDragBar.h"
#include "CDragBarContainer.h"
#include "CDragBarDockControl.h"
#include "CDragBarDragTask.h"
#include "UGraphicGizmos.h"
#include <UMemoryMgr.h>
#include <LArray.h>
#include <LArrayIterator.h>
#include <Drag.h>
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
CDragBarContainer::CDragBarContainer(LStream* inStream)
: CBrokeredView(inStream),
LDropArea(GetMacPort()),
mBars(sizeof(CDragBar*))
{
*inStream >> mBarListResID;
mDock = NULL;
SetRefreshAllWhenResized(false);
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
CDragBarContainer::~CDragBarContainer()
{
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
void CDragBarContainer::FinishCreateSelf(void)
{
CBrokeredView::FinishCreateSelf();
// We need to get the dock first so that when we initialize the initial
// state of the bars we have somewhere to put them.
mDock = dynamic_cast<CDragBarDockControl*>(FindPaneByID(CDragBarDockControl::class_ID));
Assert_(mDock != NULL);
mDock->AddListener(this);
StResource theIDList('RidL', mBarListResID);
{
StHandleLocker theLock(theIDList);
LDataStream theBarStream(*theIDList.mResourceH, ::GetHandleSize(theIDList));
Int16 theItemCount;
theBarStream >> theItemCount;
for (Int16 i = 0; i < theItemCount; i++)
{
PaneIDT thePaneID;
theBarStream >> thePaneID;
CDragBar* theBar = dynamic_cast<CDragBar*>(FindPaneByID(thePaneID));
Assert_(theBar != NULL);
if (theBar->IsDocked())
mDock->AddBarToDock(theBar);
mBars.InsertItemsAt(1, LArray::index_Last, &theBar);
theBar->AddListener(this);
}
}
AdjustContainer();
AdjustDock();
// Because new toolbar drag bars could adjust their frames
// at FinishCreateSelf time, call RepositionBars
RepositionBars();
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
void
CDragBarContainer::AddBar( CDragBar* inBar )
{
if ( inBar->IsDocked() )
mDock->AddBarToDock(inBar);
mBars.InsertItemsAt(1, LArray::index_Last, &inBar);
inBar->AddListener(this);
AdjustContainer();
AdjustDock();
RepositionBars();
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
void CDragBarContainer::ListenToMessage(
MessageT inMessage,
void* ioParam)
{
if (inMessage == msg_DragBarCollapse)
{
CDragBar* theBar = (CDragBar*)ioParam;
NoteCollapseBar(theBar);
}
else if (inMessage == msg_DragBarExpand)
{
CDragBar* theBar = (CDragBar*)ioParam;
NoteExpandBar(theBar);
}
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
void CDragBarContainer::SavePlace(LStream *outPlace)
{
*outPlace << mBars.GetCount();
CDragBar* theBar;
LArrayIterator theIter(mBars, LArrayIterator::from_Start);
while (theIter.Next(&theBar))
{
*outPlace << theBar->GetPaneID();
*outPlace << theBar->IsDocked();
*outPlace << theBar->IsAvailable();
}
mDock->SavePlace(outPlace);
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
void CDragBarContainer::RestorePlace(LStream *inPlace)
{
Int32 theBarCount;
*inPlace >> theBarCount;
for (Int32 theIndex = LArray::index_First; theIndex <= theBarCount; theIndex++)
{
PaneIDT thePaneID;
*inPlace >> thePaneID;
Boolean bIsDocked;
*inPlace >> bIsDocked;
Boolean bIsAvailable;
*inPlace >> bIsAvailable;
CDragBar* theBar = dynamic_cast<CDragBar*>(FindPaneByID(thePaneID));
// Assert_(theBar != NULL); -- oops! theBar might legitimately not exist yet
if ( theBar )
{
// First we want to place the bar in the same position in the
// bar array as it was before. We can tell that by its position
// from when it was saved out.
ArrayIndexT theBarIndex = mBars.FetchIndexOf(&theBar);
Assert_(theBarIndex != LArray::index_Bad);
mBars.MoveItem(theBarIndex, theIndex);
// Now we need to sync the state of the bar properly.
if (bIsDocked && !theBar->IsDocked())
mDock->AddBarToDock(theBar);
if (bIsAvailable)
theBar->Show();
else
theBar->Hide();
theBar->SetAvailable(bIsAvailable);
}
}
mDock->RestorePlace(inPlace);
RepositionBars();
AdjustContainer();
AdjustDock();
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥ Hides the drag bar from the container AND dock without changing the docking
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
void CDragBarContainer::HideBar(CDragBar* inBar, Boolean inRefresh)
{ // hide drag bar
if (inBar->IsAvailable())
{
if (!inBar->IsDocked()) inBar->Hide(); // hide if undocked
mDock->HideBar(inBar);
inBar->SetAvailable(false);
RepositionBars();
AdjustContainer();
AdjustDock();
if (inRefresh) Refresh();
}
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥ Show the drag bar without changing the docking
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
void CDragBarContainer::ShowBar(CDragBar* inBar, Boolean inRefresh)
{
if (!inBar->IsAvailable())
{
if (!inBar->IsDocked()) inBar->Show(); // show if undocked
mDock->ShowBar(inBar);
inBar->SetAvailable(true);
RepositionBars();
AdjustContainer();
AdjustDock();
if (inRefresh) Refresh();
}
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
void CDragBarContainer::NoteCollapseBar(CDragBar* inBar)
{
FocusDraw();
// 3/6/97 pkc
// When inBar is NULL, we just want to adjust things, but we
// don't need to add a bar to the dock
if (inBar)
mDock->AddBarToDock(inBar);
RepositionBars();
AdjustContainer();
AdjustDock();
Refresh();
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
void CDragBarContainer::NoteExpandBar(CDragBar* inBar)
{
FocusDraw();
mDock->RemoveBarFromDock(inBar);
AdjustDock(); // show or hide as appropriate
RepositionBars();
AdjustContainer();
Refresh();
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
void CDragBarContainer::RepositionBars(void)
{
Rect theContainerFrame;
CalcLocalFrameRect(theContainerFrame);
Int32 theHeight = theContainerFrame.top;
CDragBar* theBar;
LArrayIterator theIter(mBars, LArrayIterator::from_Start);
while (theIter.Next(&theBar))
{
if (theBar->IsDocked()) // Docked bars are ignored
continue;
if (!theBar->IsAvailable()) // Unavailable (hidden from container and dock)
continue;
SDimension16 theBarSize;
theBar->GetFrameSize(theBarSize);
theBar->PlaceInSuperFrameAt(theContainerFrame.left, theHeight, false);
theHeight += theBarSize.height;
}
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
void CDragBarContainer::SwapBars(
CDragBar* inSourceBar,
CDragBar* inDestBar,
Boolean inRefresh)
{
if (inSourceBar == inDestBar)
return;
// Get the indeces and swap the bars in the array
ArrayIndexT theSourceIndex = mBars.FetchIndexOf(&inSourceBar);
Assert_(theSourceIndex != LArray::index_Bad);
ArrayIndexT theDestIndex = mBars.FetchIndexOf(&inDestBar);
Assert_(theDestIndex != LArray::index_Bad);
mBars.SwapItems(theSourceIndex, theDestIndex);
// align the indeces so we can loop up from one to another.
if (theSourceIndex > theDestIndex)
{
ArrayIndexT theTemp = theSourceIndex;
theSourceIndex = theDestIndex;
theDestIndex = theTemp;
}
// Now we need to invalidate all of the bars between, and including,
// the source and destination.
FocusDraw();
while (theSourceIndex <= theDestIndex)
{
CDragBar* theBar = NULL;
mBars.FetchItemAt(theSourceIndex, &theBar);
Assert_(theBar != NULL);
Rect thePortFrame;
theBar->CalcPortFrameRect(thePortFrame);
theBar->InvalPortRect(&thePortFrame);
theSourceIndex++;
}
if (inRefresh)
{
RepositionBars();
UpdatePort(); // expensive call!!! use sparingly
}
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
void CDragBarContainer::AdjustContainer(void)
{
// First get our frame size, we need the width.
SDimension16 theNewSize;
GetFrameSize(theNewSize);
// The height is the sum of the non-docked bars
// If all bars are docked, the size is the height of the dock
theNewSize.height = 0;
CDragBar* theBar;
LArrayIterator theIter(mBars, LArrayIterator::from_Start);
while (theIter.Next(&theBar))
{
if (theBar->IsDocked()) // Docked bars are ignored.
continue;
if (!theBar->IsAvailable()) // Unavailable (hidden from container and dock)
continue;
SDimension16 theBarSize;
theBar->GetFrameSize(theBarSize);
theNewSize.height += theBarSize.height;
}
SDimension16 theDockSize;
mDock->GetFrameSize(theDockSize);
if (mDock->HasDockedBars())
theNewSize.height += theDockSize.height;
ResizeFrameTo(theNewSize.width, theNewSize.height, true);
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
void CDragBarContainer::AdjustDock(void)
{
if (mDock->HasDockedBars())
mDock->Show();
else
mDock->Hide();
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
//
#pragma mark --- DROP AREA BEHAVIOUR ---
//
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥ PointInDropArea
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// Return whether a Point, in Global coords, is inside a DropArea
Boolean CDragBarContainer::PointInDropArea(
Point inPoint)
{
GlobalToPortPoint(inPoint);
return IsHitBy(inPoint.h, inPoint.v);
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
Boolean CDragBarContainer::ItemIsAcceptable(
DragReference inDragRef,
ItemReference inItemRef)
{
Boolean bIsAcceptable = false;
FlavorFlags theFlags;
OSErr theErr = ::GetFlavorFlags(inDragRef, inItemRef, Flavor_DragBar, &theFlags);
if (theErr == noErr)
{
DragAttributes theAttributes;
theErr = ::GetDragAttributes(inDragRef, &theAttributes);
if (theErr == noErr)
bIsAcceptable = (theAttributes & kDragInsideSenderWindow) != 0;
}
return bIsAcceptable;
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥ EnterDropArea
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// A Drag is entering a DropArea. This call will be followed by a
// corresponding LeaveDropArea call (when the Drag moves out of the
// DropArea or after the Drag is received by this DropArea).
//
// If the DropArea can accept the Drag and the Drag is coming from outside
// the DropArea, hilite the DropArea
void CDragBarContainer::EnterDropArea(
DragReference /* inDragRef */,
Boolean /* inDragHasLeftSender */)
{
// NULL IMPLEMENTATION
// No hiliting necessary.
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥ LeaveDropArea
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// A Drag is leaving a DropArea. This call will have been preceded by
// a corresponding EnterDropArea call.
//
// Remove hiliting of the DropArea if necessary
void CDragBarContainer::LeaveDropArea(
DragReference /* inDragRef */)
{
// No hiliting necessary.
mCanAcceptCurrentDrag = false;
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥ InsideDropArea
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// Track a Drag while it is inside a DropArea. This function is called
// repeatedly while an acceptable Drag is inside a DropArea.
//
// This more difficult than it needs to be, because PowerPlant does not pass the refCon
// through to this routine. If it did, I could easily get at the tracking bar.
// Instead I need to go through the drag item reference number to get the
// task, and then get the tracking bar.
void CDragBarContainer::InsideDropArea(DragReference inDragRef)
{
FocusDraw();
Point theMouse, thePinnedMouse;
OSErr theErr = ::GetDragMouse(inDragRef, &theMouse, &thePinnedMouse);
if (theErr != noErr)
{
return;
}
GlobalToPortPoint(theMouse);
LPane* thePane = FindShallowSubPaneContaining(theMouse.h, theMouse.v);
// We have the special knowledge that the top level sub panes
// can only be other drag bars, or the dock.
CDragBar* theBar = dynamic_cast<CDragBar*>(thePane);
if (theBar != NULL)
{
CDragBarDragTask* theTask = NULL;
theErr = ::GetDragItemReferenceNumber(inDragRef, 1, (ItemReference*)(&theTask));
if (theErr != noErr)
{
return;
}
// See if we're over a bar, and it's not the one we're dragging
CDragBar* theTrackingBar = theTask->GetTrackingBar();
if (theBar != theTrackingBar)
{
ArrayIndexT theBarPosition;
theBarPosition = mBars.FetchIndexOf(&theBar);
ArrayIndexT theTrackPosition;
theTrackPosition = mBars.FetchIndexOf(&theTrackingBar);
// OK, we have the indeces which correspond to the bars' top to
// bottom ordering on the screen. To prevent violent swapping of the bars,
// we only want to swap if the point has passed through the mid horizontal
// point of the bar in the direction leading away from the current tracking
// bar.
Rect theBarPortFrame;
theBar->CalcPortFrameRect(theBarPortFrame);
Int16 theMidLine = theBarPortFrame.top + (RectHeight(theBarPortFrame) / 2);
Boolean bShouldSwap;
if ((theBarPosition < theTrackPosition) && (theMouse.v <= theMidLine))
bShouldSwap = true;
else if ((theBarPosition > theTrackPosition) && (theMouse.v >= theMidLine))
bShouldSwap = true;
else
bShouldSwap = false;
if (bShouldSwap)
SwapBars(theTrackingBar, theBar, true);
}
}
}
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// ¥ ReceiveDragItem
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// Process an Item which has been dragged into a DropArea
//
// This function gets called once for each Item contained in a completed
// Drag. The Item will have returned true from ItemIsAcceptable().
//
// The DropArea is focused upon entry and inItemBounds is specified
// in the local coordinates of the DropArea.
void CDragBarContainer::ReceiveDragItem(
DragReference /* inDragRef */,
DragAttributes /* inDragAttrs */,
ItemReference /* inItemRef */,
Rect& /* inItemBounds */) // In Local coordinates
{
}

105
cmd/macfe/gui/CDragBarContainer.h
Просмотреть файл

@ -1,105 +0,0 @@
/* -*- 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.0 (the "NPL"); you may not use this file except in
* compliance with the NPL. You may obtain a copy of the NPL at
* http://www.mozilla.org/NPL/
*
* Software distributed under the NPL is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
* for the specific language governing rights and limitations under the
* NPL.
*
* The Initial Developer of this code under the NPL is Netscape
* Communications Corporation. Portions created by Netscape are
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
* Reserved.
*/
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
// CDragBarContainer.h
// ÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ
#pragma once
#include "CSwatchBrokerView.h"
#include <LDragAndDrop.h>
#include <LListener.h>
#include <LArray.h>
class CDragBarDockControl;
class CDragBar;
class CDragBarContainer :
public CBrokeredView,
public LDropArea,
public LListener
{
public:
enum { class_ID = 'DbCt' };
CDragBarContainer(LStream* inStream);
virtual ~CDragBarContainer();
virtual Boolean PointInDropArea(Point inGlobalPt);
virtual void ListenToMessage(
MessageT inMessage,
void* ioParam);
virtual void SavePlace(LStream *outPlace);
virtual void RestorePlace(LStream *inPlace);
// from JavaScript one can hide/show drag bars independently of docking
virtual void HideBar(CDragBar* inBar, Boolean inRefresh = false);
virtual void ShowBar(CDragBar* inBar, Boolean inRefresh = false);
protected:
virtual void AddBar(CDragBar* inBar);
virtual void NoteCollapseBar(CDragBar* inBar);
virtual void NoteExpandBar(CDragBar* inBar);
virtual void RepositionBars(void);
virtual void SwapBars(
CDragBar* inSouceBar,
CDragBar* inDestBar,
Boolean inRefresh = false);
virtual void AdjustContainer(void);
virtual void AdjustDock(void);
virtual void FinishCreateSelf(void);
// DROP AREA BEHAVIOUR
virtual Boolean ItemIsAcceptable(
DragReference inDragRef,
ItemReference inItemRef);
virtual void EnterDropArea(
DragReference inDragRef,
Boolean inDragHasLeftSender);
virtual void LeaveDropArea(
DragReference inDragRef);
virtual void InsideDropArea(
DragReference inDragRef);
virtual void ReceiveDragItem(
DragReference inDragRef,
DragAttributes inDragAttrs,
ItemReference inItemRef,
Rect &inItemBounds);
ResIDT mBarListResID;
LArray mBars;
CDragBarDockControl* mDock;
};