378 lines
9.6 KiB
C++
378 lines
9.6 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* ***** BEGIN LICENSE BLOCK *****
|
|
* Version: NPL 1.1/GPL 2.0/LGPL 2.1
|
|
*
|
|
* 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 Communicator client code.
|
|
*
|
|
* The Initial Developer of the Original Code is
|
|
* Netscape Communications Corporation.
|
|
* Portions created by the Initial Developer are Copyright (C) 1998
|
|
* the Initial Developer. All Rights Reserved.
|
|
*
|
|
* Contributor(s):
|
|
* Original Author: Eric J. Burley (ericb@neoplanet.com)
|
|
*
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
* either 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"),
|
|
* 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
|
|
* use your version of this file under the terms of the NPL, indicate your
|
|
* 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
|
|
* the terms of any one of the NPL, the GPL or the LGPL.
|
|
*
|
|
* ***** END LICENSE BLOCK ***** */
|
|
|
|
#include "nsCOMPtr.h"
|
|
#include "nsResizerFrame.h"
|
|
#include "nsIContent.h"
|
|
#include "nsIDocument.h"
|
|
#include "nsIDOMXULDocument.h"
|
|
#include "nsIDOMNodeList.h"
|
|
#include "nsHTMLAtoms.h"
|
|
#include "nsINameSpaceManager.h"
|
|
|
|
#include "nsIWidget.h"
|
|
#include "nsIPresContext.h"
|
|
#include "nsIDocShell.h"
|
|
#include "nsIDocShellTreeItem.h"
|
|
#include "nsIDocShellTreeOwner.h"
|
|
#include "nsIBaseWindow.h"
|
|
#include "nsIScriptGlobalObject.h"
|
|
#include "nsIViewManager.h"
|
|
#include "nsXULAtoms.h"
|
|
#include "nsGUIEvent.h"
|
|
|
|
//
|
|
// NS_NewXULButtonFrame
|
|
//
|
|
// Creates a new Button frame and returns it in |aNewFrame|
|
|
//
|
|
nsresult
|
|
NS_NewResizerFrame( nsIPresShell* aPresShell, nsIFrame** aNewFrame )
|
|
{
|
|
NS_PRECONDITION(aNewFrame, "null OUT ptr");
|
|
if (nsnull == aNewFrame) {
|
|
return NS_ERROR_NULL_POINTER;
|
|
}
|
|
nsTitleBarFrame* it = new (aPresShell) nsResizerFrame(aPresShell);
|
|
if (nsnull == it)
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
// it->SetFlags(aFlags);
|
|
*aNewFrame = it;
|
|
return NS_OK;
|
|
|
|
} // NS_NewTitleBarFrame
|
|
|
|
nsResizerFrame::nsResizerFrame(nsIPresShell* aPresShell)
|
|
:nsTitleBarFrame(aPresShell)
|
|
{
|
|
mDirection = topleft; // by default...
|
|
}
|
|
|
|
NS_IMETHODIMP nsResizerFrame::Init(nsIPresContext* aPresContext,
|
|
nsIContent* aContent,
|
|
nsIFrame* aParent,
|
|
nsStyleContext* aContext,
|
|
nsIFrame* asPrevInFlow)
|
|
{
|
|
nsresult rv = nsTitleBarFrame::Init(aPresContext, aContent, aParent, aContext, asPrevInFlow);
|
|
|
|
GetInitialDirection(mDirection);
|
|
|
|
return rv;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsResizerFrame::HandleEvent(nsIPresContext* aPresContext,
|
|
nsGUIEvent* aEvent,
|
|
nsEventStatus* aEventStatus)
|
|
{
|
|
PRBool doDefault = PR_TRUE;
|
|
|
|
switch (aEvent->message) {
|
|
|
|
case NS_MOUSE_LEFT_BUTTON_DOWN: {
|
|
|
|
// we're tracking.
|
|
mTrackingMouseMove = PR_TRUE;
|
|
|
|
// start capture.
|
|
aEvent->widget->CaptureMouse(PR_TRUE);
|
|
CaptureMouseEvents(aPresContext,PR_TRUE);
|
|
|
|
|
|
|
|
// remember current mouse coordinates.
|
|
mLastPoint = aEvent->refPoint;
|
|
aEvent->widget->GetScreenBounds(mWidgetRect);
|
|
|
|
nsRect bounds;
|
|
aEvent->widget->GetBounds(bounds);
|
|
|
|
*aEventStatus = nsEventStatus_eConsumeNoDefault;
|
|
doDefault = PR_FALSE;
|
|
}
|
|
break;
|
|
|
|
|
|
case NS_MOUSE_LEFT_BUTTON_UP: {
|
|
|
|
if(mTrackingMouseMove)
|
|
{
|
|
// we're done tracking.
|
|
mTrackingMouseMove = PR_FALSE;
|
|
|
|
// end capture
|
|
aEvent->widget->CaptureMouse(PR_FALSE);
|
|
CaptureMouseEvents(aPresContext,PR_FALSE);
|
|
|
|
*aEventStatus = nsEventStatus_eConsumeNoDefault;
|
|
doDefault = PR_FALSE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case NS_MOUSE_MOVE: {
|
|
if(mTrackingMouseMove)
|
|
{
|
|
// get the document and the global script object - should this be cached?
|
|
nsCOMPtr<nsIPresShell> presShell;
|
|
aPresContext->GetShell(getter_AddRefs(presShell));
|
|
nsCOMPtr<nsIDocument> document;
|
|
presShell->GetDocument(getter_AddRefs(document));
|
|
nsCOMPtr<nsIScriptGlobalObject> scriptGlobalObject;
|
|
document->GetScriptGlobalObject(getter_AddRefs(scriptGlobalObject));
|
|
NS_ENSURE_TRUE(scriptGlobalObject, NS_ERROR_FAILURE);
|
|
|
|
nsCOMPtr<nsIDocShell> docShell;
|
|
scriptGlobalObject->GetDocShell(getter_AddRefs(docShell));
|
|
|
|
nsCOMPtr<nsIDocShellTreeItem> docShellAsItem(do_QueryInterface(docShell));
|
|
NS_ENSURE_TRUE(docShellAsItem, NS_ERROR_FAILURE);
|
|
|
|
nsCOMPtr<nsIDocShellTreeOwner> treeOwner;
|
|
docShellAsItem->GetTreeOwner(getter_AddRefs(treeOwner));
|
|
|
|
nsCOMPtr<nsIBaseWindow> window(do_QueryInterface(treeOwner));
|
|
|
|
if (!window) {
|
|
return NS_OK;
|
|
}
|
|
|
|
nsPoint nsMoveBy(0,0),nsSizeBy(0,0);
|
|
nsPoint nsMouseMove(aEvent->refPoint - mLastPoint);
|
|
|
|
|
|
switch(mDirection)
|
|
{
|
|
case topleft:
|
|
nsMoveBy = nsMouseMove;
|
|
nsSizeBy -= nsMouseMove;
|
|
break;
|
|
case top:
|
|
nsMoveBy.y = nsMouseMove.y;
|
|
nsSizeBy.y = - nsMouseMove.y;
|
|
break;
|
|
case topright:
|
|
nsMoveBy.y = nsMouseMove.y;
|
|
nsSizeBy.x = nsMouseMove.x;
|
|
mLastPoint.x += nsMouseMove.x;
|
|
nsSizeBy.y = -nsMouseMove.y;
|
|
break;
|
|
case left:
|
|
nsMoveBy.x = nsMouseMove.x;
|
|
nsSizeBy.x = -nsMouseMove.x;
|
|
break;
|
|
case right:
|
|
nsSizeBy.x = nsMouseMove.x;
|
|
mLastPoint.x += nsMouseMove.x;
|
|
break;
|
|
case bottomleft:
|
|
nsMoveBy.x = nsMouseMove.x;
|
|
nsSizeBy.y = nsMouseMove.y;
|
|
nsSizeBy.x = -nsMouseMove.x;
|
|
mLastPoint.y += nsMouseMove.y;
|
|
break;
|
|
case bottom:
|
|
nsSizeBy.y = nsMouseMove.y;
|
|
mLastPoint.y += nsMouseMove.y;
|
|
break;
|
|
case bottomright:
|
|
nsSizeBy = nsMouseMove;
|
|
mLastPoint += nsMouseMove;
|
|
break;
|
|
}
|
|
|
|
|
|
|
|
PRInt32 x,y,cx,cy;
|
|
window->GetPositionAndSize(&x,&y,&cx,&cy);
|
|
|
|
x+=nsMoveBy.x;
|
|
y+=nsMoveBy.y;
|
|
cx+=nsSizeBy.x;
|
|
cy+=nsSizeBy.y;
|
|
|
|
window->SetPositionAndSize(x,y,cx,cy,PR_TRUE); // do the repaint.
|
|
|
|
/*
|
|
if(nsSizeBy.x || nsSizeBy.y)
|
|
{
|
|
window->ResizeBy(nsSizeBy.x,nsSizeBy.y);
|
|
}
|
|
|
|
if(nsMoveBy.x || nsMoveBy.y)
|
|
{
|
|
window->MoveBy(nsMoveBy.x,nsMoveBy.y);
|
|
} */
|
|
|
|
|
|
|
|
*aEventStatus = nsEventStatus_eConsumeNoDefault;
|
|
|
|
doDefault = PR_FALSE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
|
|
|
|
case NS_MOUSE_LEFT_CLICK:
|
|
MouseClicked(aPresContext);
|
|
break;
|
|
}
|
|
|
|
if ( doDefault )
|
|
return nsTitleBarFrame::HandleEvent(aPresContext, aEvent, aEventStatus);
|
|
else
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
|
|
/* returns true if aText represented a valid direction
|
|
*/
|
|
PRBool
|
|
nsResizerFrame::EvalDirection(nsAutoString& aText,eDirection& aDir)
|
|
{
|
|
PRBool aResult = PR_TRUE;
|
|
|
|
if( aText.EqualsIgnoreCase("topleft") )
|
|
{
|
|
aDir = topleft;
|
|
}
|
|
else if( aText.EqualsIgnoreCase("top") )
|
|
{
|
|
aDir = top;
|
|
}
|
|
else if( aText.EqualsIgnoreCase("topright") )
|
|
{
|
|
aDir = topright;
|
|
}
|
|
else if( aText.EqualsIgnoreCase("left") )
|
|
{
|
|
aDir = left;
|
|
}
|
|
else if( aText.EqualsIgnoreCase("right") )
|
|
{
|
|
aDir = right;
|
|
}
|
|
else if( aText.EqualsIgnoreCase("bottomleft") )
|
|
{
|
|
aDir = bottomleft;
|
|
}
|
|
else if( aText.EqualsIgnoreCase("bottom") )
|
|
{
|
|
aDir = bottom;
|
|
}
|
|
else if( aText.EqualsIgnoreCase("bottomright") )
|
|
{
|
|
aDir = bottomright;
|
|
}
|
|
else
|
|
{
|
|
aResult = PR_FALSE;
|
|
}
|
|
|
|
return aResult;
|
|
}
|
|
|
|
|
|
/* Returns true if it was set.
|
|
*/
|
|
PRBool
|
|
nsResizerFrame::GetInitialDirection(eDirection& aDirection)
|
|
{
|
|
// see what kind of resizer we are.
|
|
nsAutoString value;
|
|
|
|
nsCOMPtr<nsIContent> content;
|
|
GetContentOf(getter_AddRefs(content));
|
|
|
|
if (!content)
|
|
return PR_FALSE;
|
|
|
|
if (NS_CONTENT_ATTR_HAS_VALUE == content->GetAttr(kNameSpaceID_None, nsXULAtoms::dir, value))
|
|
{
|
|
return EvalDirection(value,aDirection);
|
|
}
|
|
|
|
return PR_FALSE;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP
|
|
nsResizerFrame::AttributeChanged(nsIPresContext* aPresContext,
|
|
nsIContent* aChild,
|
|
PRInt32 aNameSpaceID,
|
|
nsIAtom* aAttribute,
|
|
PRInt32 aModType,
|
|
PRInt32 aHint)
|
|
{
|
|
nsresult rv = nsTitleBarFrame::AttributeChanged(aPresContext, aChild,
|
|
aNameSpaceID, aAttribute, aModType, aHint);
|
|
|
|
if (aAttribute == nsXULAtoms::dir )
|
|
{
|
|
|
|
GetInitialDirection(mDirection);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
|
|
|
|
void
|
|
nsResizerFrame::MouseClicked (nsIPresContext* aPresContext)
|
|
{
|
|
// Execute the oncommand event handler.
|
|
nsEventStatus status = nsEventStatus_eIgnore;
|
|
nsMouseEvent event;
|
|
event.eventStructType = NS_EVENT;
|
|
event.message = NS_XUL_COMMAND;
|
|
event.isShift = PR_FALSE;
|
|
event.isControl = PR_FALSE;
|
|
event.isAlt = PR_FALSE;
|
|
event.isMeta = PR_FALSE;
|
|
event.clickCount = 0;
|
|
event.widget = nsnull;
|
|
mContent->HandleDOMEvent(aPresContext, &event, nsnull, NS_EVENT_FLAG_INIT, &status);
|
|
}
|