2001-09-28 20:14:13 +00:00
|
|
|
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
2004-04-17 16:52:41 +00:00
|
|
|
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
|
1998-04-13 20:24:54 +00:00
|
|
|
*
|
2004-04-17 16:52:41 +00:00
|
|
|
* The contents of this file are subject to the Mozilla 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/MPL/
|
1998-04-13 20:24:54 +00:00
|
|
|
*
|
2001-09-28 20:14:13 +00:00
|
|
|
* 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.
|
1998-04-13 20:24:54 +00:00
|
|
|
*
|
1999-11-06 03:40:37 +00:00
|
|
|
* The Original Code is mozilla.org code.
|
|
|
|
*
|
2004-04-17 16:52:41 +00:00
|
|
|
* The Initial Developer of the Original Code is
|
2001-09-28 20:14:13 +00:00
|
|
|
* Netscape Communications Corporation.
|
|
|
|
* Portions created by the Initial Developer are Copyright (C) 1998
|
|
|
|
* the Initial Developer. All Rights Reserved.
|
1999-11-06 03:40:37 +00:00
|
|
|
*
|
2001-09-28 20:14:13 +00:00
|
|
|
* Contributor(s):
|
|
|
|
*
|
|
|
|
* Alternatively, the contents of this file may be used under the terms of
|
2004-04-17 16:52:41 +00:00
|
|
|
* either of the GNU General Public License Version 2 or later (the "GPL"),
|
|
|
|
* or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
|
2001-09-28 20:14:13 +00:00
|
|
|
* in which case the provisions of the GPL or the LGPL are applicable instead
|
|
|
|
* of those above. If you wish to allow use of your version of this file only
|
|
|
|
* under the terms of either the GPL or the LGPL, and not to allow others to
|
2004-04-17 16:52:41 +00:00
|
|
|
* use your version of this file under the terms of the MPL, indicate your
|
2001-09-28 20:14:13 +00:00
|
|
|
* decision by deleting the provisions above and replace them with the notice
|
|
|
|
* and other provisions required by the GPL or the LGPL. If you do not delete
|
|
|
|
* the provisions above, a recipient may use your version of this file under
|
2004-04-17 16:52:41 +00:00
|
|
|
* the terms of any one of the MPL, the GPL or the LGPL.
|
2001-09-28 20:14:13 +00:00
|
|
|
*
|
|
|
|
* ***** END LICENSE BLOCK ***** */
|
1998-04-13 20:24:54 +00:00
|
|
|
|
|
|
|
#include "nsView.h"
|
|
|
|
#include "nsIWidget.h"
|
2001-11-07 04:05:38 +00:00
|
|
|
#include "nsViewManager.h"
|
1998-04-13 20:24:54 +00:00
|
|
|
#include "nsIFrame.h"
|
|
|
|
#include "nsIPresContext.h"
|
|
|
|
#include "nsIWidget.h"
|
|
|
|
#include "nsIButton.h"
|
|
|
|
#include "nsGUIEvent.h"
|
|
|
|
#include "nsIDeviceContext.h"
|
1999-03-09 09:44:27 +00:00
|
|
|
#include "nsIComponentManager.h"
|
1998-04-13 20:24:54 +00:00
|
|
|
#include "nsIRenderingContext.h"
|
|
|
|
#include "nsTransform2D.h"
|
1998-04-23 21:51:43 +00:00
|
|
|
#include "nsIScrollableView.h"
|
1998-10-11 01:00:59 +00:00
|
|
|
#include "nsVoidArray.h"
|
1998-10-23 17:58:44 +00:00
|
|
|
#include "nsGfxCIID.h"
|
1998-10-15 04:55:21 +00:00
|
|
|
#include "nsIRegion.h"
|
1998-04-13 20:24:54 +00:00
|
|
|
|
1999-11-14 02:51:25 +00:00
|
|
|
|
1998-11-23 23:50:17 +00:00
|
|
|
//mmptemp
|
|
|
|
|
1998-08-31 19:09:55 +00:00
|
|
|
static nsEventStatus PR_CALLBACK HandleEvent(nsGUIEvent *aEvent);
|
|
|
|
|
|
|
|
|
1998-07-11 06:17:09 +00:00
|
|
|
//#define SHOW_VIEW_BORDERS
|
1998-06-16 17:05:42 +00:00
|
|
|
//#define HIDE_ALL_WIDGETS
|
|
|
|
|
1998-04-13 20:24:54 +00:00
|
|
|
//
|
|
|
|
// Main events handler
|
|
|
|
//
|
|
|
|
nsEventStatus PR_CALLBACK HandleEvent(nsGUIEvent *aEvent)
|
|
|
|
{
|
2000-10-28 22:17:53 +00:00
|
|
|
//printf(" %d %d %d (%d,%d) \n", aEvent->widget, aEvent->widgetSupports,
|
1998-05-29 22:44:13 +00:00
|
|
|
// aEvent->message, aEvent->point.x, aEvent->point.y);
|
1998-08-08 04:23:33 +00:00
|
|
|
nsEventStatus result = nsEventStatus_eIgnore;
|
2001-11-07 04:05:38 +00:00
|
|
|
nsView *view = nsView::GetViewFor(aEvent->widget);
|
1999-04-16 04:23:43 +00:00
|
|
|
|
2003-07-03 13:05:57 +00:00
|
|
|
if (view)
|
1999-04-16 04:23:43 +00:00
|
|
|
{
|
2003-07-03 13:05:57 +00:00
|
|
|
view->GetViewManager()->DispatchEvent(aEvent, &result);
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2001-01-27 23:31:15 +00:00
|
|
|
MOZ_DECL_CTOR_COUNTER(nsView)
|
1999-10-05 14:52:53 +00:00
|
|
|
|
2001-12-01 14:31:45 +00:00
|
|
|
nsView::nsView()
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
1999-10-05 14:52:53 +00:00
|
|
|
MOZ_COUNT_CTOR(nsView);
|
|
|
|
|
1998-04-13 20:24:54 +00:00
|
|
|
mVis = nsViewVisibility_kShow;
|
2002-10-11 01:23:13 +00:00
|
|
|
// Views should be transparent by default. Not being transparent is
|
|
|
|
// a promise that the view will paint all its pixels opaquely. Views
|
|
|
|
// should make this promise explicitly by calling
|
|
|
|
// SetViewContentTransparency.
|
|
|
|
mVFlags = NS_VIEW_FLAG_TRANSPARENT;
|
1998-11-03 06:36:36 +00:00
|
|
|
mOpacity = 1.0f;
|
1999-07-19 19:57:30 +00:00
|
|
|
mViewManager = nsnull;
|
2001-11-30 04:09:36 +00:00
|
|
|
mChildRemoved = PR_FALSE;
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
2003-02-23 02:53:15 +00:00
|
|
|
void nsView::DropMouseGrabbing() {
|
|
|
|
// check to see if we are grabbing events
|
|
|
|
if (mViewManager->GetMouseEventGrabber() == this) {
|
|
|
|
// we are grabbing events. Move the grab to the parent if we can.
|
|
|
|
PRBool boolResult; //not used
|
|
|
|
// if GetParent() returns null, then we release the grab, which is the best we can do
|
|
|
|
mViewManager->GrabMouseEvents(GetParent(), boolResult);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-12-01 14:31:45 +00:00
|
|
|
nsView::~nsView()
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
1999-10-05 14:52:53 +00:00
|
|
|
MOZ_COUNT_DTOR(nsView);
|
|
|
|
|
2003-02-23 02:53:15 +00:00
|
|
|
while (GetFirstChild())
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
2002-02-19 21:33:26 +00:00
|
|
|
nsView* child = GetFirstChild();
|
|
|
|
if (child->GetViewManager() == mViewManager) {
|
|
|
|
child->Destroy();
|
|
|
|
} else {
|
|
|
|
// just unhook it. Someone else will want to destroy this.
|
|
|
|
RemoveChild(child);
|
|
|
|
}
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
2003-02-23 02:53:15 +00:00
|
|
|
DropMouseGrabbing();
|
|
|
|
|
|
|
|
if (mViewManager)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
2002-02-19 21:33:26 +00:00
|
|
|
// Root views can have parents!
|
2003-02-23 02:53:15 +00:00
|
|
|
if (mParent)
|
2002-02-19 21:33:26 +00:00
|
|
|
{
|
|
|
|
mViewManager->RemoveChild(this);
|
|
|
|
}
|
|
|
|
|
1998-04-13 20:24:54 +00:00
|
|
|
mViewManager = nsnull;
|
|
|
|
}
|
2003-02-23 02:53:15 +00:00
|
|
|
else if (mParent)
|
1998-08-08 04:23:33 +00:00
|
|
|
{
|
1998-05-01 03:13:34 +00:00
|
|
|
mParent->RemoveChild(this);
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
1998-08-08 04:23:33 +00:00
|
|
|
|
2003-02-23 02:53:15 +00:00
|
|
|
if (mZParent)
|
2000-08-12 19:05:52 +00:00
|
|
|
{
|
2001-11-08 23:11:01 +00:00
|
|
|
mZParent->RemoveReparentedView();
|
2000-08-12 19:05:52 +00:00
|
|
|
mZParent->Destroy();
|
|
|
|
}
|
1998-11-03 06:36:36 +00:00
|
|
|
|
2000-08-12 19:05:52 +00:00
|
|
|
// Destroy and release the widget
|
2003-02-23 02:53:15 +00:00
|
|
|
if (mWindow)
|
1998-11-03 06:36:36 +00:00
|
|
|
{
|
1998-08-08 04:23:33 +00:00
|
|
|
mWindow->SetClientData(nsnull);
|
|
|
|
mWindow->Destroy();
|
|
|
|
NS_RELEASE(mWindow);
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
1998-10-15 04:55:21 +00:00
|
|
|
NS_IF_RELEASE(mDirtyRegion);
|
2004-03-11 00:32:01 +00:00
|
|
|
|
|
|
|
delete mClipRect;
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
1999-09-12 03:23:09 +00:00
|
|
|
nsresult nsView::QueryInterface(const nsIID& aIID, void** aInstancePtr)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
|
|
|
if (nsnull == aInstancePtr) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
1999-08-10 00:56:40 +00:00
|
|
|
|
|
|
|
*aInstancePtr = nsnull;
|
|
|
|
|
1999-09-12 03:23:09 +00:00
|
|
|
if (aIID.Equals(NS_GET_IID(nsIView)) || (aIID.Equals(NS_GET_IID(nsISupports)))) {
|
1998-04-13 20:24:54 +00:00
|
|
|
*aInstancePtr = (void*)(nsIView*)this;
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_NOINTERFACE;
|
|
|
|
}
|
|
|
|
|
|
|
|
nsrefcnt nsView::AddRef()
|
|
|
|
{
|
1998-08-08 04:23:33 +00:00
|
|
|
NS_WARNING("not supported for views");
|
|
|
|
return 1;
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
nsrefcnt nsView::Release()
|
|
|
|
{
|
1998-08-08 04:23:33 +00:00
|
|
|
NS_WARNING("not supported for views");
|
|
|
|
return 1;
|
|
|
|
}
|
1998-05-01 03:13:34 +00:00
|
|
|
|
2001-11-07 04:05:38 +00:00
|
|
|
nsView* nsView::GetViewFor(nsIWidget* aWidget)
|
1998-08-08 04:23:33 +00:00
|
|
|
{
|
1998-12-16 03:37:56 +00:00
|
|
|
NS_PRECONDITION(nsnull != aWidget, "null widget ptr");
|
|
|
|
|
1998-08-08 04:23:33 +00:00
|
|
|
// The widget's client data points back to the owning view
|
2003-07-03 13:05:57 +00:00
|
|
|
if (aWidget) {
|
|
|
|
void* clientData;
|
|
|
|
aWidget->GetClientData(clientData);
|
2001-04-11 05:29:36 +00:00
|
|
|
nsISupports* data = (nsISupports*)clientData;
|
|
|
|
|
2003-07-03 13:05:57 +00:00
|
|
|
if (data) {
|
2001-11-07 04:05:38 +00:00
|
|
|
nsIView* view = nsnull;
|
|
|
|
if (NS_SUCCEEDED(data->QueryInterface(NS_GET_IID(nsIView), (void **)&view))) {
|
|
|
|
return NS_STATIC_CAST(nsView*, view);
|
2001-04-11 05:29:36 +00:00
|
|
|
}
|
|
|
|
}
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
2001-11-07 04:05:38 +00:00
|
|
|
return nsnull;
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
2004-01-30 03:20:41 +00:00
|
|
|
nsresult nsIView::Init(nsIViewManager* aManager,
|
|
|
|
const nsRect &aBounds,
|
|
|
|
const nsIView *aParent,
|
|
|
|
nsViewVisibility aVisibilityFlag)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
2000-10-28 22:17:53 +00:00
|
|
|
//printf(" \n callback=%d data=%d", aWidgetCreateCallback, aCallbackData);
|
1998-04-13 20:24:54 +00:00
|
|
|
NS_PRECONDITION(nsnull != aManager, "null ptr");
|
|
|
|
if (nsnull == aManager) {
|
|
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
}
|
|
|
|
if (nsnull != mViewManager) {
|
|
|
|
return NS_ERROR_ALREADY_INITIALIZED;
|
|
|
|
}
|
1998-08-08 04:23:33 +00:00
|
|
|
// we don't hold a reference to the view manager
|
2001-11-07 04:05:38 +00:00
|
|
|
mViewManager = NS_STATIC_CAST(nsViewManager*, aManager);
|
1998-04-13 20:24:54 +00:00
|
|
|
|
2004-01-30 03:20:41 +00:00
|
|
|
nsView* v = NS_STATIC_CAST(nsView*, this);
|
|
|
|
v->SetPosition(aBounds.x, aBounds.y);
|
2002-01-27 07:56:23 +00:00
|
|
|
nsRect dim(0, 0, aBounds.width, aBounds.height);
|
2004-01-30 03:20:41 +00:00
|
|
|
v->SetDimensions(dim, PR_FALSE);
|
|
|
|
v->SetVisibility(aVisibilityFlag);
|
2002-01-27 07:56:23 +00:00
|
|
|
|
2004-01-30 03:20:41 +00:00
|
|
|
// We shouldn't set the parent here. It should be set when we put this view
|
|
|
|
// into the view hierarchy.
|
|
|
|
v->SetParent(NS_STATIC_CAST(nsView*, NS_CONST_CAST(nsIView*, aParent)));
|
1998-04-13 20:24:54 +00:00
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2004-01-30 03:20:41 +00:00
|
|
|
void nsIView::Destroy()
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
2004-05-06 03:17:14 +00:00
|
|
|
// We don't want to tear down the root view when the viewport frame
|
|
|
|
// (which has the root view as its view) goes away. The root view will
|
|
|
|
// be deleted when the view manager dies.
|
|
|
|
if (!IsRoot()) {
|
|
|
|
delete this;
|
|
|
|
}
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
2001-12-01 14:31:45 +00:00
|
|
|
NS_IMETHODIMP nsView::Paint(nsIRenderingContext& rc, const nsRect& rect,
|
1998-10-11 01:00:59 +00:00
|
|
|
PRUint32 aPaintFlags, PRBool &aResult)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
2000-08-24 19:54:46 +00:00
|
|
|
// Just paint, assume compositor knows what it's doing.
|
|
|
|
if (nsnull != mClientData) {
|
|
|
|
nsCOMPtr<nsIViewObserver> observer;
|
|
|
|
if (NS_OK == mViewManager->GetViewObserver(*getter_AddRefs(observer))) {
|
|
|
|
observer->Paint((nsIView *)this, rc, rect);
|
|
|
|
}
|
|
|
|
}
|
2004-03-11 00:32:01 +00:00
|
|
|
return NS_OK;
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
2001-12-01 14:31:45 +00:00
|
|
|
NS_IMETHODIMP nsView::Paint(nsIRenderingContext& rc, const nsIRegion& region,
|
1998-08-30 19:16:11 +00:00
|
|
|
PRUint32 aPaintFlags, PRBool &aResult)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
|
|
|
// XXX apply region to rc
|
|
|
|
// XXX get bounding rect from region
|
1998-08-28 03:05:23 +00:00
|
|
|
//if (nsnull != mClientData)
|
|
|
|
//{
|
|
|
|
// nsIViewObserver *obs;
|
|
|
|
//
|
|
|
|
// if (NS_OK == mViewManager->GetViewObserver(obs))
|
|
|
|
// {
|
|
|
|
// obs->Paint((nsIView *)this, rc, rect, aPaintFlags);
|
|
|
|
// NS_RELEASE(obs);
|
|
|
|
// }
|
|
|
|
//}
|
1998-08-30 19:16:11 +00:00
|
|
|
aResult = PR_FALSE;
|
|
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
2002-01-27 07:56:23 +00:00
|
|
|
void nsView::SetPosition(nscoord aX, nscoord aY)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
2002-01-27 07:56:23 +00:00
|
|
|
mDimBounds.x += aX - mPosX;
|
|
|
|
mDimBounds.y += aY - mPosY;
|
|
|
|
mPosX = aX;
|
|
|
|
mPosY = aY;
|
1998-04-13 20:24:54 +00:00
|
|
|
|
2004-01-30 03:20:41 +00:00
|
|
|
NS_ASSERTION(GetParent() || (aX == 0 && aY == 0),
|
|
|
|
"Don't try to move the root widget to something non-zero");
|
2004-01-10 05:36:32 +00:00
|
|
|
|
|
|
|
ResetWidgetPosition(PR_TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
void nsView::SetPositionIgnoringChildWidgets(nscoord aX, nscoord aY)
|
|
|
|
{
|
|
|
|
mDimBounds.x += aX - mPosX;
|
|
|
|
mDimBounds.y += aY - mPosY;
|
|
|
|
mPosX = aX;
|
|
|
|
mPosY = aY;
|
|
|
|
|
|
|
|
ResetWidgetPosition(PR_FALSE);
|
|
|
|
}
|
1999-12-14 22:21:58 +00:00
|
|
|
|
2004-01-10 05:36:32 +00:00
|
|
|
void nsView::ResetWidgetPosition(PRBool aRecurse) {
|
|
|
|
if (mWindow)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
2000-04-03 03:55:38 +00:00
|
|
|
// see if we are caching our widget changes. Yes?
|
|
|
|
// mark us as changed. Later we will actually move the
|
|
|
|
// widget.
|
|
|
|
PRBool caching = PR_FALSE;
|
|
|
|
mViewManager->IsCachingWidgetChanges(&caching);
|
|
|
|
if (caching) {
|
2001-12-01 14:31:45 +00:00
|
|
|
mVFlags |= NS_VIEW_FLAG_WIDGET_MOVED;
|
2002-01-27 07:56:23 +00:00
|
|
|
return;
|
2000-04-03 03:55:38 +00:00
|
|
|
}
|
|
|
|
|
1998-08-28 04:56:56 +00:00
|
|
|
nsIDeviceContext *dx;
|
1998-08-28 03:05:23 +00:00
|
|
|
float scale;
|
1998-06-04 02:02:08 +00:00
|
|
|
|
1998-08-28 04:56:56 +00:00
|
|
|
mViewManager->GetDeviceContext(dx);
|
2004-02-05 01:57:10 +00:00
|
|
|
scale = dx->AppUnitsToDevUnits();
|
1998-10-19 00:44:28 +00:00
|
|
|
NS_RELEASE(dx);
|
1998-06-04 02:02:08 +00:00
|
|
|
|
2004-01-30 03:20:41 +00:00
|
|
|
nsPoint offset(0, 0);
|
|
|
|
if (GetParent()) {
|
|
|
|
GetParent()->GetNearestWidget(&offset);
|
|
|
|
}
|
1998-08-30 19:16:11 +00:00
|
|
|
|
2004-01-30 03:20:41 +00:00
|
|
|
mWindow->Move(NSTwipsToIntPixels((mDimBounds.x + offset.x), scale),
|
|
|
|
NSTwipsToIntPixels((mDimBounds.y + offset.y), scale));
|
2004-01-10 05:36:32 +00:00
|
|
|
} else if (aRecurse) {
|
|
|
|
// reposition any widgets under this view
|
|
|
|
for (nsView* v = GetFirstChild(); v; v = v->GetNextSibling()) {
|
|
|
|
v->ResetWidgetPosition(aRecurse);
|
|
|
|
}
|
2002-01-27 07:56:23 +00:00
|
|
|
}
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
2001-12-01 14:31:45 +00:00
|
|
|
NS_IMETHODIMP nsView::SynchWidgetSizePosition()
|
2000-04-03 03:55:38 +00:00
|
|
|
{
|
2000-04-11 23:55:15 +00:00
|
|
|
// if the widget was moved or resized
|
2001-12-01 14:31:45 +00:00
|
|
|
if (mVFlags & NS_VIEW_FLAG_WIDGET_MOVED || mVFlags & NS_VIEW_FLAG_WIDGET_RESIZED)
|
2000-04-03 03:55:38 +00:00
|
|
|
{
|
|
|
|
nsIDeviceContext *dx;
|
|
|
|
float t2p;
|
|
|
|
|
|
|
|
mViewManager->GetDeviceContext(dx);
|
2004-02-05 01:57:10 +00:00
|
|
|
t2p = dx->AppUnitsToDevUnits();
|
2000-04-03 03:55:38 +00:00
|
|
|
NS_RELEASE(dx);
|
2000-04-25 07:10:48 +00:00
|
|
|
// if we just resized do it
|
2001-12-01 14:31:45 +00:00
|
|
|
if (mVFlags & NS_VIEW_FLAG_WIDGET_RESIZED)
|
2000-04-25 07:10:48 +00:00
|
|
|
{
|
|
|
|
|
2002-01-27 07:56:23 +00:00
|
|
|
PRInt32 width = NSTwipsToIntPixels(mDimBounds.width, t2p);
|
|
|
|
PRInt32 height = NSTwipsToIntPixels(mDimBounds.height, t2p);
|
2000-04-25 07:10:48 +00:00
|
|
|
|
|
|
|
nsRect bounds;
|
|
|
|
mWindow->GetBounds(bounds);
|
|
|
|
|
2000-05-26 06:42:29 +00:00
|
|
|
if (bounds.width != width || bounds.height != bounds.height) {
|
2000-04-25 07:10:48 +00:00
|
|
|
mWindow->Resize(width,height, PR_TRUE);
|
2000-05-26 06:42:29 +00:00
|
|
|
}
|
2000-04-03 03:55:38 +00:00
|
|
|
|
2001-12-01 14:31:45 +00:00
|
|
|
mVFlags &= ~NS_VIEW_FLAG_WIDGET_RESIZED;
|
2000-04-25 07:10:48 +00:00
|
|
|
}
|
|
|
|
|
2001-12-01 14:31:45 +00:00
|
|
|
if (mVFlags & NS_VIEW_FLAG_WIDGET_MOVED) {
|
2000-04-25 07:10:48 +00:00
|
|
|
// if we just moved do it.
|
2004-01-30 03:20:41 +00:00
|
|
|
nsPoint offset;
|
|
|
|
GetParent()->GetNearestWidget(&offset);
|
2000-04-25 07:10:48 +00:00
|
|
|
|
2004-01-30 03:20:41 +00:00
|
|
|
PRInt32 x = NSTwipsToIntPixels(mDimBounds.x + offset.x, t2p);
|
|
|
|
PRInt32 y = NSTwipsToIntPixels(mDimBounds.y + offset.y, t2p);
|
2000-04-25 07:10:48 +00:00
|
|
|
|
|
|
|
nsRect bounds;
|
|
|
|
mWindow->GetBounds(bounds);
|
|
|
|
|
2000-05-26 06:42:29 +00:00
|
|
|
if (bounds.x != x || bounds.y != y) {
|
2000-04-25 07:10:48 +00:00
|
|
|
mWindow->Move(x,y);
|
2000-05-26 06:42:29 +00:00
|
|
|
}
|
2000-04-25 07:10:48 +00:00
|
|
|
|
2001-12-01 14:31:45 +00:00
|
|
|
mVFlags &= ~NS_VIEW_FLAG_WIDGET_MOVED;
|
2000-04-25 07:10:48 +00:00
|
|
|
}
|
2000-04-03 03:55:38 +00:00
|
|
|
}
|
2000-04-25 07:10:48 +00:00
|
|
|
|
2000-04-03 03:55:38 +00:00
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2002-01-27 07:56:23 +00:00
|
|
|
void nsView::SetDimensions(const nsRect& aRect, PRBool aPaint)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
2002-01-27 07:56:23 +00:00
|
|
|
nsRect dims = aRect;
|
|
|
|
dims.MoveBy(mPosX, mPosY);
|
1998-04-13 20:24:54 +00:00
|
|
|
|
2002-01-27 07:56:23 +00:00
|
|
|
if (mDimBounds.x == dims.x && mDimBounds.y == dims.y && mDimBounds.width == dims.width
|
|
|
|
&& mDimBounds.height == dims.height) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (nsnull == mWindow)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
2002-01-27 07:56:23 +00:00
|
|
|
mDimBounds = dims;
|
1998-04-23 21:51:43 +00:00
|
|
|
}
|
2002-01-27 07:56:23 +00:00
|
|
|
else
|
1998-04-23 21:51:43 +00:00
|
|
|
{
|
2002-01-27 07:56:23 +00:00
|
|
|
PRBool needToMoveWidget = mDimBounds.x != dims.x || mDimBounds.y != dims.y;
|
|
|
|
|
|
|
|
mDimBounds = dims;
|
|
|
|
|
2000-04-03 03:55:38 +00:00
|
|
|
PRBool caching = PR_FALSE;
|
|
|
|
mViewManager->IsCachingWidgetChanges(&caching);
|
|
|
|
if (caching) {
|
2002-01-27 07:56:23 +00:00
|
|
|
mVFlags |= NS_VIEW_FLAG_WIDGET_RESIZED | (needToMoveWidget ? NS_VIEW_FLAG_WIDGET_MOVED : 0);
|
|
|
|
return;
|
2000-04-03 03:55:38 +00:00
|
|
|
}
|
|
|
|
|
1998-08-28 04:56:56 +00:00
|
|
|
nsIDeviceContext *dx;
|
1998-08-28 03:05:23 +00:00
|
|
|
float t2p;
|
1998-04-23 21:51:43 +00:00
|
|
|
|
1998-08-28 04:56:56 +00:00
|
|
|
mViewManager->GetDeviceContext(dx);
|
2004-02-05 01:57:10 +00:00
|
|
|
t2p = dx->AppUnitsToDevUnits();
|
1998-08-28 03:05:23 +00:00
|
|
|
|
2002-01-27 07:56:23 +00:00
|
|
|
if (needToMoveWidget) {
|
2004-01-30 03:20:41 +00:00
|
|
|
NS_ASSERTION(GetParent(), "Don't try to move the root widget, dude");
|
|
|
|
|
|
|
|
nsPoint offset;
|
|
|
|
GetParent()->GetNearestWidget(&offset);
|
|
|
|
|
|
|
|
mWindow->Move(NSTwipsToIntPixels((mDimBounds.x + offset.x), t2p),
|
|
|
|
NSTwipsToIntPixels((mDimBounds.y + offset.y), t2p));
|
2002-01-27 07:56:23 +00:00
|
|
|
}
|
|
|
|
mWindow->Resize(NSTwipsToIntPixels(mDimBounds.width, t2p), NSTwipsToIntPixels(mDimBounds.height, t2p),
|
1998-08-26 21:24:58 +00:00
|
|
|
aPaint);
|
1998-04-23 21:51:43 +00:00
|
|
|
|
1998-08-28 03:05:23 +00:00
|
|
|
NS_RELEASE(dx);
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-12-01 14:31:45 +00:00
|
|
|
NS_IMETHODIMP nsView::SetVisibility(nsViewVisibility aVisibility)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
2003-05-22 04:59:30 +00:00
|
|
|
|
1998-04-13 20:24:54 +00:00
|
|
|
mVis = aVisibility;
|
|
|
|
|
2001-05-04 03:02:55 +00:00
|
|
|
if (aVisibility == nsViewVisibility_kHide)
|
|
|
|
{
|
2003-02-23 02:53:15 +00:00
|
|
|
DropMouseGrabbing();
|
2001-05-04 03:02:55 +00:00
|
|
|
}
|
|
|
|
|
2003-05-22 04:59:30 +00:00
|
|
|
if (nsnull != mWindow)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
1998-06-16 17:05:42 +00:00
|
|
|
#ifndef HIDE_ALL_WIDGETS
|
1998-04-13 20:24:54 +00:00
|
|
|
if (mVis == nsViewVisibility_kShow)
|
|
|
|
mWindow->Show(PR_TRUE);
|
|
|
|
else
|
1998-06-16 17:05:42 +00:00
|
|
|
#endif
|
1998-04-13 20:24:54 +00:00
|
|
|
mWindow->Show(PR_FALSE);
|
|
|
|
}
|
1998-08-30 19:16:11 +00:00
|
|
|
|
|
|
|
return NS_OK;
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
2000-01-25 01:53:34 +00:00
|
|
|
NS_IMETHODIMP nsView::SetFloating(PRBool aFloatingView)
|
|
|
|
{
|
|
|
|
if (aFloatingView)
|
2001-12-01 14:31:45 +00:00
|
|
|
mVFlags |= NS_VIEW_FLAG_FLOATING;
|
2000-01-25 01:53:34 +00:00
|
|
|
else
|
2001-12-01 14:31:45 +00:00
|
|
|
mVFlags &= ~NS_VIEW_FLAG_FLOATING;
|
2000-01-25 01:53:34 +00:00
|
|
|
|
|
|
|
#if 0
|
|
|
|
// recursively make all sub-views "floating" grr.
|
2003-07-03 13:05:57 +00:00
|
|
|
for (nsView* child = mFirstChild; chlid; child = child->GetNextSibling()) {
|
2000-01-25 01:53:34 +00:00
|
|
|
child->SetFloating(aFloatingView);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2001-12-01 14:31:45 +00:00
|
|
|
void nsView::InsertChild(nsView *aChild, nsView *aSibling)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
2001-11-07 04:05:38 +00:00
|
|
|
NS_PRECONDITION(nsnull != aChild, "null ptr");
|
1998-04-13 20:24:54 +00:00
|
|
|
|
2001-11-07 04:05:38 +00:00
|
|
|
if (nsnull != aChild)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
2001-11-07 04:05:38 +00:00
|
|
|
if (nsnull != aSibling)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
1998-08-30 19:16:11 +00:00
|
|
|
#ifdef NS_DEBUG
|
2003-07-03 13:05:57 +00:00
|
|
|
NS_ASSERTION(aSibling->GetParent() == this, "tried to insert view with invalid sibling");
|
1998-08-30 19:16:11 +00:00
|
|
|
#endif
|
1998-04-13 20:24:54 +00:00
|
|
|
//insert after sibling
|
2003-07-03 13:05:57 +00:00
|
|
|
aChild->SetNextSibling(aSibling->GetNextSibling());
|
2001-11-07 04:05:38 +00:00
|
|
|
aSibling->SetNextSibling(aChild);
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2001-11-07 04:05:38 +00:00
|
|
|
aChild->SetNextSibling(mFirstChild);
|
|
|
|
mFirstChild = aChild;
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
2001-11-07 04:05:38 +00:00
|
|
|
aChild->SetParent(this);
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-12-01 14:31:45 +00:00
|
|
|
void nsView::RemoveChild(nsView *child)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
|
|
|
NS_PRECONDITION(nsnull != child, "null ptr");
|
|
|
|
|
|
|
|
if (nsnull != child)
|
|
|
|
{
|
2001-11-07 04:05:38 +00:00
|
|
|
nsView* prevKid = nsnull;
|
|
|
|
nsView* kid = mFirstChild;
|
1998-04-13 20:24:54 +00:00
|
|
|
PRBool found = PR_FALSE;
|
|
|
|
while (nsnull != kid) {
|
|
|
|
if (kid == child) {
|
|
|
|
if (nsnull != prevKid) {
|
2003-07-03 13:05:57 +00:00
|
|
|
prevKid->SetNextSibling(kid->GetNextSibling());
|
1998-04-13 20:24:54 +00:00
|
|
|
} else {
|
2001-11-07 04:05:38 +00:00
|
|
|
mFirstChild = kid->GetNextSibling();
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
child->SetParent(nsnull);
|
|
|
|
found = PR_TRUE;
|
|
|
|
break;
|
|
|
|
}
|
1998-05-01 03:13:34 +00:00
|
|
|
prevKid = kid;
|
2001-11-30 04:09:36 +00:00
|
|
|
mChildRemoved = PR_TRUE;
|
2001-11-07 04:05:38 +00:00
|
|
|
kid = kid->GetNextSibling();
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
NS_ASSERTION(found, "tried to remove non child");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-12-01 14:31:45 +00:00
|
|
|
NS_IMETHODIMP nsView::SetOpacity(float opacity)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
1998-04-28 19:16:24 +00:00
|
|
|
mOpacity = opacity;
|
1998-08-30 19:16:11 +00:00
|
|
|
return NS_OK;
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
2001-12-01 14:31:45 +00:00
|
|
|
NS_IMETHODIMP nsView::SetContentTransparency(PRBool aTransparent)
|
1998-06-03 22:49:45 +00:00
|
|
|
{
|
|
|
|
if (aTransparent == PR_TRUE)
|
2001-12-01 14:31:45 +00:00
|
|
|
mVFlags |= NS_VIEW_FLAG_TRANSPARENT;
|
1998-06-03 22:49:45 +00:00
|
|
|
else
|
2001-12-01 14:31:45 +00:00
|
|
|
mVFlags &= ~NS_VIEW_FLAG_TRANSPARENT;
|
1998-08-30 19:16:11 +00:00
|
|
|
|
|
|
|
return NS_OK;
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
2004-01-30 03:20:41 +00:00
|
|
|
nsresult nsIView::CreateWidget(const nsIID &aWindowIID,
|
2003-03-06 23:07:00 +00:00
|
|
|
nsWidgetInitData *aWidgetInitData,
|
|
|
|
nsNativeWidget aNative,
|
|
|
|
PRBool aEnableDragDrop,
|
|
|
|
PRBool aResetVisibility,
|
|
|
|
nsContentType aContentType)
|
1998-11-04 04:14:10 +00:00
|
|
|
{
|
|
|
|
nsIDeviceContext *dx;
|
2002-01-27 07:56:23 +00:00
|
|
|
nsRect trect = mDimBounds;
|
1998-11-04 04:14:10 +00:00
|
|
|
float scale;
|
|
|
|
|
|
|
|
NS_IF_RELEASE(mWindow);
|
|
|
|
|
|
|
|
mViewManager->GetDeviceContext(dx);
|
2004-02-05 01:57:10 +00:00
|
|
|
scale = dx->AppUnitsToDevUnits();
|
1998-11-04 04:14:10 +00:00
|
|
|
|
|
|
|
trect *= scale;
|
|
|
|
|
2004-01-30 03:20:41 +00:00
|
|
|
nsView* v = NS_STATIC_CAST(nsView*, this);
|
|
|
|
if (NS_OK == v->LoadWidget(aWindowIID))
|
1998-11-04 04:14:10 +00:00
|
|
|
{
|
1998-11-14 01:58:34 +00:00
|
|
|
PRBool usewidgets;
|
|
|
|
|
|
|
|
dx->SupportsNativeWidgets(usewidgets);
|
|
|
|
|
|
|
|
if (PR_TRUE == usewidgets)
|
1998-11-04 04:14:10 +00:00
|
|
|
{
|
2003-03-06 23:07:00 +00:00
|
|
|
PRBool initDataPassedIn = PR_TRUE;
|
|
|
|
nsWidgetInitData initData;
|
|
|
|
if (!aWidgetInitData) {
|
2003-03-11 19:27:30 +00:00
|
|
|
// No initData, we're a child window
|
|
|
|
// Create initData to pass in params
|
2003-03-06 23:07:00 +00:00
|
|
|
initDataPassedIn = PR_FALSE;
|
2003-03-11 19:27:30 +00:00
|
|
|
initData.clipChildren = PR_TRUE; // Clip child window's children
|
2003-03-06 23:07:00 +00:00
|
|
|
aWidgetInitData = &initData;
|
|
|
|
}
|
|
|
|
aWidgetInitData->mContentType = aContentType;
|
|
|
|
|
1998-11-14 01:58:34 +00:00
|
|
|
if (aNative)
|
|
|
|
mWindow->Create(aNative, trect, ::HandleEvent, dx, nsnull, nsnull, aWidgetInitData);
|
|
|
|
else
|
|
|
|
{
|
2003-03-06 23:07:00 +00:00
|
|
|
if (!initDataPassedIn && GetParent() &&
|
|
|
|
GetParent()->GetViewManager() != mViewManager)
|
|
|
|
initData.mListenForResizes = PR_TRUE;
|
2002-06-12 03:22:35 +00:00
|
|
|
|
2004-01-30 03:20:41 +00:00
|
|
|
nsIWidget* parentWidget = GetParent() ? GetParent()->GetNearestWidget(nsnull)
|
|
|
|
: nsnull;
|
|
|
|
mWindow->Create(parentWidget, trect,
|
|
|
|
::HandleEvent, dx, nsnull, nsnull, aWidgetInitData);
|
1998-11-14 01:58:34 +00:00
|
|
|
}
|
1999-08-26 14:41:18 +00:00
|
|
|
if (aEnableDragDrop) {
|
|
|
|
mWindow->EnableDragDrop(PR_TRUE);
|
|
|
|
}
|
1999-09-23 23:26:54 +00:00
|
|
|
|
|
|
|
// propagate the z-index to the widget.
|
2001-12-01 14:31:45 +00:00
|
|
|
mWindow->SetZIndex(mZIndex);
|
1998-11-04 04:14:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//make sure visibility state is accurate
|
2002-04-12 02:05:12 +00:00
|
|
|
|
2001-10-31 05:06:31 +00:00
|
|
|
if (aResetVisibility) {
|
2004-01-30 03:20:41 +00:00
|
|
|
v->SetVisibility(GetVisibility());
|
2003-03-05 14:32:07 +00:00
|
|
|
}
|
1998-11-04 04:14:10 +00:00
|
|
|
|
|
|
|
NS_RELEASE(dx);
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
2002-07-02 12:50:14 +00:00
|
|
|
void nsView::SetZIndex(PRBool aAuto, PRInt32 aZIndex, PRBool aTopMost)
|
2001-12-01 14:31:45 +00:00
|
|
|
{
|
|
|
|
mVFlags = (mVFlags & ~NS_VIEW_FLAG_AUTO_ZINDEX) | (aAuto ? NS_VIEW_FLAG_AUTO_ZINDEX : 0);
|
|
|
|
mZIndex = aZIndex;
|
2002-07-02 12:50:14 +00:00
|
|
|
SetTopMost(aTopMost);
|
|
|
|
|
2001-12-01 14:31:45 +00:00
|
|
|
if (nsnull != mWindow) {
|
|
|
|
mWindow->SetZIndex(aZIndex);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
NS_IMETHODIMP nsView::SetWidget(nsIWidget *aWidget)
|
1998-11-04 04:14:10 +00:00
|
|
|
{
|
|
|
|
NS_IF_RELEASE(mWindow);
|
|
|
|
mWindow = aWidget;
|
|
|
|
|
|
|
|
if (nsnull != mWindow)
|
|
|
|
{
|
|
|
|
NS_ADDREF(mWindow);
|
|
|
|
mWindow->SetClientData((void *)this);
|
|
|
|
}
|
|
|
|
|
|
|
|
return NS_OK;
|
|
|
|
}
|
|
|
|
|
1998-04-13 20:24:54 +00:00
|
|
|
//
|
|
|
|
// internal window creation functions
|
|
|
|
//
|
2001-12-01 14:31:45 +00:00
|
|
|
nsresult nsView::LoadWidget(const nsCID &aClassIID)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
1999-11-14 02:51:25 +00:00
|
|
|
nsresult rv = nsComponentManager::CreateInstance(aClassIID, nsnull, NS_GET_IID(nsIWidget), (void**)&mWindow);
|
1998-04-13 20:24:54 +00:00
|
|
|
|
1999-11-14 02:51:25 +00:00
|
|
|
if (NS_OK == rv) {
|
1998-08-08 04:23:33 +00:00
|
|
|
// Set the widget's client data
|
|
|
|
mWindow->SetClientData((void*)this);
|
1998-04-13 20:24:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2004-01-20 22:15:38 +00:00
|
|
|
#ifdef DEBUG
|
2004-01-30 03:20:41 +00:00
|
|
|
void nsIView::List(FILE* out, PRInt32 aIndent) const
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
1998-08-05 09:02:52 +00:00
|
|
|
PRInt32 i;
|
|
|
|
for (i = aIndent; --i >= 0; ) fputs(" ", out);
|
2001-11-07 04:05:38 +00:00
|
|
|
fprintf(out, "%p ", (void*)this);
|
1998-06-04 20:02:30 +00:00
|
|
|
if (nsnull != mWindow) {
|
|
|
|
nsRect windowBounds;
|
1999-03-18 21:04:00 +00:00
|
|
|
nsRect nonclientBounds;
|
|
|
|
float p2t;
|
|
|
|
nsIDeviceContext *dx;
|
|
|
|
mViewManager->GetDeviceContext(dx);
|
2004-02-05 01:57:10 +00:00
|
|
|
p2t = dx->DevUnitsToAppUnits();
|
1999-03-18 21:04:00 +00:00
|
|
|
NS_RELEASE(dx);
|
1998-11-04 21:46:00 +00:00
|
|
|
mWindow->GetClientBounds(windowBounds);
|
1999-03-18 21:04:00 +00:00
|
|
|
windowBounds *= p2t;
|
|
|
|
mWindow->GetBounds(nonclientBounds);
|
|
|
|
nonclientBounds *= p2t;
|
1999-04-19 23:22:53 +00:00
|
|
|
nsrefcnt widgetRefCnt = mWindow->AddRef() - 1;
|
|
|
|
mWindow->Release();
|
|
|
|
fprintf(out, "(widget=%p[%d] pos={%d,%d,%d,%d}) ",
|
2001-11-07 04:05:38 +00:00
|
|
|
(void*)mWindow, widgetRefCnt,
|
1999-03-18 21:04:00 +00:00
|
|
|
nonclientBounds.x, nonclientBounds.y,
|
1998-06-04 20:02:30 +00:00
|
|
|
windowBounds.width, windowBounds.height);
|
|
|
|
}
|
2003-07-03 13:05:57 +00:00
|
|
|
nsRect brect = GetBounds();
|
1999-03-18 21:04:00 +00:00
|
|
|
fprintf(out, "{%d,%d,%d,%d}",
|
|
|
|
brect.x, brect.y, brect.width, brect.height);
|
2004-01-30 03:20:41 +00:00
|
|
|
const nsView* v = NS_STATIC_CAST(const nsView*, this);
|
|
|
|
if (v->IsZPlaceholderView()) {
|
2004-01-29 00:04:58 +00:00
|
|
|
fprintf(out, " z-placeholder(%p)",
|
|
|
|
(void*)NS_STATIC_CAST(const nsZPlaceholderView*, this)->GetReparentedView());
|
|
|
|
}
|
2004-01-30 03:20:41 +00:00
|
|
|
if (v->GetZParent()) {
|
|
|
|
fprintf(out, " zparent=%p", (void*)v->GetZParent());
|
2004-01-29 00:04:58 +00:00
|
|
|
}
|
|
|
|
fprintf(out, " z=%d vis=%d opc=%1.3f tran=%d clientData=%p <\n",
|
2004-01-30 03:20:41 +00:00
|
|
|
mZIndex, mVis, mOpacity, IsTransparent(), mClientData);
|
2003-07-03 13:05:57 +00:00
|
|
|
for (nsView* kid = mFirstChild; kid; kid = kid->GetNextSibling()) {
|
2004-01-29 00:04:58 +00:00
|
|
|
NS_ASSERTION(kid->GetParent() == this, "incorrect parent");
|
1998-04-13 20:24:54 +00:00
|
|
|
kid->List(out, aIndent + 1);
|
|
|
|
}
|
1998-08-05 09:02:52 +00:00
|
|
|
for (i = aIndent; --i >= 0; ) fputs(" ", out);
|
1998-04-13 20:24:54 +00:00
|
|
|
fputs(">\n", out);
|
|
|
|
}
|
2004-01-20 22:15:38 +00:00
|
|
|
#endif // DEBUG
|
1998-04-13 20:24:54 +00:00
|
|
|
|
2004-01-30 03:20:41 +00:00
|
|
|
nsIWidget* nsIView::GetNearestWidget(nsPoint* aOffset)
|
1998-04-13 20:24:54 +00:00
|
|
|
{
|
2004-01-30 03:20:41 +00:00
|
|
|
nsPoint pt(0, 0);
|
|
|
|
nsView* v;
|
|
|
|
for (v = NS_STATIC_CAST(nsView*, this);
|
|
|
|
v && !v->HasWidget(); v = v->GetParent()) {
|
|
|
|
pt += v->GetPosition();
|
|
|
|
}
|
|
|
|
if (!v) {
|
|
|
|
if (aOffset) {
|
|
|
|
*aOffset = pt;
|
2002-01-27 07:56:23 +00:00
|
|
|
}
|
2004-01-30 03:20:41 +00:00
|
|
|
return NS_STATIC_CAST(nsView*, this)->GetViewManager()->GetWidget();
|
1998-06-16 17:05:42 +00:00
|
|
|
}
|
|
|
|
|
2004-01-30 03:20:41 +00:00
|
|
|
// pt is now the offset from v's origin to this's origin
|
|
|
|
// The widget's origin is the top left corner of v's bounds, which may
|
|
|
|
// not coincide with v's origin
|
|
|
|
if (aOffset) {
|
|
|
|
nsRect vBounds = v->GetBounds();
|
|
|
|
*aOffset = pt + v->GetPosition() - nsPoint(vBounds.x, vBounds.y);
|
2000-01-26 23:04:40 +00:00
|
|
|
}
|
2004-01-30 03:20:41 +00:00
|
|
|
return v->GetWidget();
|
1998-06-16 17:05:42 +00:00
|
|
|
}
|
|
|
|
|
2002-08-30 03:32:05 +00:00
|
|
|
nsresult nsView::GetDirtyRegion(nsIRegion*& aRegion)
|
|
|
|
{
|
|
|
|
if (nsnull == mDirtyRegion) {
|
|
|
|
nsresult rv = GetViewManager()->CreateRegion(&mDirtyRegion);
|
|
|
|
if (NS_FAILED(rv))
|
2003-09-11 02:44:40 +00:00
|
|
|
return rv;
|
2002-08-30 03:32:05 +00:00
|
|
|
}
|
1998-10-15 04:55:21 +00:00
|
|
|
|
2002-08-30 03:32:05 +00:00
|
|
|
aRegion = mDirtyRegion;
|
|
|
|
NS_ADDREF(aRegion);
|
|
|
|
return NS_OK;
|
1998-10-15 04:55:21 +00:00
|
|
|
}
|
|
|
|
|
2004-01-30 03:20:41 +00:00
|
|
|
PRBool nsIView::IsRoot() const
|
2000-03-23 23:49:18 +00:00
|
|
|
{
|
|
|
|
NS_ASSERTION(mViewManager != nsnull," View manager is null in nsView::IsRoot()");
|
2004-05-06 03:17:14 +00:00
|
|
|
return mViewManager->RootView() == this;
|
2000-03-23 23:49:18 +00:00
|
|
|
}
|
2000-04-13 21:56:27 +00:00
|
|
|
|
2004-01-30 23:52:39 +00:00
|
|
|
PRBool nsIView::ExternalIsRoot() const
|
|
|
|
{
|
|
|
|
return nsIView::IsRoot();
|
|
|
|
}
|
|
|
|
|
2004-03-11 00:32:01 +00:00
|
|
|
// Returns PR_TRUE iff we found a placeholder parent edge on the way
|
|
|
|
static PRBool ApplyClipRect(const nsView* aView, nsRect* aRect, PRBool aFollowPlaceholders)
|
2000-04-13 21:56:27 +00:00
|
|
|
{
|
2004-03-11 00:32:01 +00:00
|
|
|
// this records the offset from the origin of the current aView
|
|
|
|
// to the origin of the initial aView
|
|
|
|
nsPoint offset(0, 0);
|
|
|
|
PRBool lastViewIsFloating = aView->GetFloating();
|
|
|
|
PRBool foundPlaceholders = PR_FALSE;
|
2002-09-17 04:16:25 +00:00
|
|
|
while (PR_TRUE) {
|
2004-03-11 00:32:01 +00:00
|
|
|
const nsView* parentView = aView->GetParent();
|
|
|
|
nsPoint offsetFromParent = aView->GetPosition();
|
2002-11-10 18:24:31 +00:00
|
|
|
|
2004-03-11 00:32:01 +00:00
|
|
|
const nsView* zParent = aView->GetZParent();
|
2002-09-17 04:16:25 +00:00
|
|
|
if (zParent) {
|
2004-03-11 00:32:01 +00:00
|
|
|
foundPlaceholders = PR_TRUE;
|
|
|
|
if (aFollowPlaceholders) {
|
|
|
|
// correct offsetFromParent to account for the fact that we're
|
|
|
|
// switching parentView to ZParent
|
|
|
|
// Note tha the common case is that parentView is an ancestor of
|
|
|
|
// ZParent.
|
|
|
|
const nsView* zParentChain;
|
|
|
|
for (zParentChain = zParent;
|
|
|
|
zParentChain != parentView && zParentChain;
|
|
|
|
zParentChain = zParentChain->GetParent()) {
|
|
|
|
offsetFromParent -= zParentChain->GetPosition();
|
2002-10-11 01:23:13 +00:00
|
|
|
}
|
2004-03-11 00:32:01 +00:00
|
|
|
if (!zParentChain) {
|
|
|
|
// uh oh. As we walked up the tree, we missed zParent. This can
|
|
|
|
// happen because of odd (but legal) containing block hierarchies.
|
|
|
|
// Just compute the required offset from scratch; this is slow,
|
|
|
|
// but hopefully rarely executed.
|
|
|
|
offsetFromParent = nsViewManager::ComputeViewOffset(aView)
|
|
|
|
- nsViewManager::ComputeViewOffset(zParent);
|
|
|
|
}
|
|
|
|
parentView = zParent;
|
2002-10-11 01:23:13 +00:00
|
|
|
}
|
2002-09-17 04:16:25 +00:00
|
|
|
}
|
2004-03-11 00:32:01 +00:00
|
|
|
|
2002-09-17 04:16:25 +00:00
|
|
|
if (!parentView) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2002-06-12 03:18:10 +00:00
|
|
|
PRBool parentIsFloating = parentView->GetFloating();
|
|
|
|
if (lastViewIsFloating && !parentIsFloating) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2004-03-11 00:32:01 +00:00
|
|
|
// now make offset be the offset from parentView's origin to the initial
|
|
|
|
// aView's origin
|
|
|
|
offset += offsetFromParent;
|
|
|
|
if (parentView->GetClipChildrenToBounds(aFollowPlaceholders)) {
|
|
|
|
// Get the parent's clip rect (which is just the dimensions in this
|
|
|
|
// case) into the initial aView's coordinates
|
|
|
|
nsRect clipRect = parentView->GetDimensions();
|
|
|
|
clipRect -= offset;
|
|
|
|
PRBool overlap = aRect->IntersectRect(clipRect, *aRect);
|
2000-04-13 21:56:27 +00:00
|
|
|
if (!overlap) {
|
2004-03-11 00:32:01 +00:00
|
|
|
break;
|
2000-04-13 21:56:27 +00:00
|
|
|
}
|
2004-03-11 00:32:01 +00:00
|
|
|
}
|
|
|
|
const nsRect* r = parentView->GetClipChildrenToRect();
|
|
|
|
if (r && !aFollowPlaceholders) {
|
|
|
|
// Get the parent's clip rect into the initial aView's coordinates
|
|
|
|
nsRect clipRect = *r;
|
|
|
|
clipRect -= offset;
|
|
|
|
PRBool overlap = aRect->IntersectRect(clipRect, *aRect);
|
|
|
|
if (!overlap) {
|
|
|
|
break;
|
2003-02-25 02:38:38 +00:00
|
|
|
}
|
2000-04-13 21:56:27 +00:00
|
|
|
}
|
|
|
|
|
2004-03-11 00:32:01 +00:00
|
|
|
aView = parentView;
|
2002-06-04 04:55:04 +00:00
|
|
|
lastViewIsFloating = parentIsFloating;
|
2000-04-13 21:56:27 +00:00
|
|
|
}
|
2004-03-11 00:32:01 +00:00
|
|
|
|
|
|
|
return foundPlaceholders;
|
2000-04-13 21:56:27 +00:00
|
|
|
}
|
|
|
|
|
2004-03-11 00:32:01 +00:00
|
|
|
nsRect nsView::GetClippedRect()
|
|
|
|
{
|
|
|
|
nsRect clip = GetDimensions();
|
|
|
|
PRBool foundPlaceholders = ApplyClipRect(this, &clip, PR_FALSE);
|
|
|
|
if (foundPlaceholders && !clip.IsEmpty()) {
|
|
|
|
ApplyClipRect(this, &clip, PR_TRUE);
|
|
|
|
}
|
|
|
|
return clip;
|
|
|
|
}
|