void wxMouseEventsManager::OnLeftUp(wxMouseEvent& event)
{
switch ( m_state )
{
case State_Normal:
// ignore it, the mouse hasn't been pressed over any item initially
// so releasing it shouldn't do anything
event.Skip();
// skip releasing the capture below
return;
case State_Pressed:
if ( MouseHitTest(event.GetPosition()) == m_item )
{
// mouse released over the same item, so it was a click
MouseClicked(m_item);
}
break;
case State_Dragging:
MouseDragEnd(m_item, event.GetPosition());
break;
}
m_state = State_Normal;
m_item = wxNOT_FOUND;
m_win->ReleaseMouse();
}
NS_IMETHODIMP
nsScrollbarButtonFrame::HandlePress(nsPresContext* aPresContext,
nsGUIEvent* aEvent,
nsEventStatus* aEventStatus)
{
MouseClicked();
nsRepeatService::GetInstance()->Start(this);
return NS_OK;
}
void GridCellDraw(struct GridCell *ctx)
{
SDL_Rect rect = {0};
struct Camera *camera = NULL;
int mouseX = 0;
int mouseY = 0;
SDL_Rect mouseRect = {0};
camera = ctx->world->camera;
rect.x = ctx->x;
rect.y = ctx->y;
rect.w = GRIDCELL_SIZE;
rect.h = GRIDCELL_SIZE;
MousePosition(ctx->world->mouse, &mouseX, &mouseY);
CameraTranslate(camera, &mouseX, &mouseY);
//mouseRect.x = mouseX + ctx->world->camera->x;
//mouseRect.y = mouseY + ctx->world->camera->y;
mouseRect.x = mouseX;
mouseRect.y = mouseY;
mouseRect.w = 1;
mouseRect.h = 1;
if(ctx->type == 0)
{
CameraDrawImage(camera, ctx->image, ctx->x, ctx->y);
}
else
{
CameraDrawImage(camera, ctx->blockImage, ctx->x, ctx->y);
}
ctx->active = 0;
if(check_collision(rect, mouseRect) == 1)
{
ctx->active = 1;
if(MouseClicked(ctx->world->mouse) == 1)
{
ctx->type = 1;
//printf("Connections: ^%p >%p \\/%p <%p \\%p /%p \\%p /%p\n",
// ctx->top, ctx->right, ctx->bottom, ctx->left,
// ctx->topLeft, ctx->topRight, ctx->bottomRight, ctx->bottomLeft);
}
CameraDrawImage(camera, ctx->cursorImage, ctx->x, ctx->y);
}
if(_GridCellHasNeighbourActive(ctx) == 1)
{
CameraDrawImage(camera, ctx->highlightImage, ctx->x, ctx->y);
}
}
////// Private event management:
bool nuiContainer::DispatchMouseClick(const nglMouseInfo& rInfo)
{
CheckValid();
nuiAutoRef;
if (!mMouseEventEnabled || mTrashed)
return false;
bool hasgrab = HasGrab(rInfo.TouchId);
if (IsDisabled() && !hasgrab)
return false;
nglMouseInfo info(rInfo);
GlobalToLocal(info.X, info.Y);
// Get a chance to preempt the mouse event before the children get it:
if (PreMouseClicked(info))
return true;
if (IsInsideFromRoot(rInfo.X, rInfo.Y) || hasgrab)
{
if (!hasgrab)
{
IteratorPtr pIt;
for (pIt = GetLastChild(false); pIt && pIt->IsValid(); GetPreviousChild(pIt))
{
nuiWidgetPtr pItem = pIt->GetWidget();
if (pItem)
{
if (IsEnabled() && !HasGrab(rInfo.TouchId))
{
if (pItem->DispatchMouseClick(rInfo))
{
delete pIt;
return true;
}
}
}
}
delete pIt;
}
nglMouseInfo info(rInfo);
GlobalToLocal(info.X, info.Y);
if (PreClicked(info))
return true;
bool ret = MouseClicked(info);
ret |= Clicked(info);
return ret | (!mClickThru);
}
return false;
}
bool nuiWindowManager::DispatchMouseClick(const nglMouseInfo& rInfo)
{
if (!IsEnabled())
return false;
if (IsInsideFromRoot(rInfo.X, rInfo.Y))
{
if (!mWindows.empty())
{
std::list<nuiWindow*>::iterator it;
std::list<nuiWindow*>::iterator begin = mWindows.begin();
it = mWindows.end();
do
{
it--;
nuiWindow* win = *it;
if (win->IsInsideFromRoot(rInfo.X, rInfo.Y))
{
if (GetActiveWindow() != win)
ActivateWindow(win);
break;
}
} while (it!=begin);
}
IteratorPtr pIt;
for (pIt = GetLastChild(); pIt && pIt->IsValid(); GetPreviousChild(pIt))
{
nuiWidgetPtr pItem = pIt->GetWidget();
if (pItem && pItem->IsVisible() && pItem->IsEnabled())
{
if (pItem->DispatchMouseClick(rInfo))
{
delete pIt;
return true;
}
}
}
delete pIt;
nglMouseInfo info(rInfo);
GlobalToLocal(info.X, info.Y);
bool ret = MouseClicked(info);
ret |= Clicked(info);
return ret;
}
return false;
}
NS_IMETHODIMP
nsButtonBoxFrame::HandleEvent(nsPresContext* aPresContext,
nsGUIEvent* aEvent,
nsEventStatus* aEventStatus)
{
NS_ENSURE_ARG_POINTER(aEventStatus);
if (nsEventStatus_eConsumeNoDefault == *aEventStatus) {
return NS_OK;
}
switch (aEvent->message) {
case NS_KEY_DOWN:
if (NS_KEY_EVENT == aEvent->eventStructType) {
nsKeyEvent* keyEvent = (nsKeyEvent*)aEvent;
if (NS_VK_SPACE == keyEvent->keyCode) {
nsEventStateManager *esm = aPresContext->EventStateManager();
// :hover:active state
esm->SetContentState(mContent, NS_EVENT_STATE_HOVER);
esm->SetContentState(mContent, NS_EVENT_STATE_ACTIVE);
}
}
break;
// On mac, Return fires the defualt button, not the focused one.
#ifndef XP_MACOSX
case NS_KEY_PRESS:
if (NS_KEY_EVENT == aEvent->eventStructType) {
nsKeyEvent* keyEvent = (nsKeyEvent*)aEvent;
if (NS_VK_RETURN == keyEvent->keyCode) {
nsCOMPtr<nsIDOMXULButtonElement> buttonEl(do_QueryInterface(mContent));
if (buttonEl) {
MouseClicked(aPresContext, aEvent);
*aEventStatus = nsEventStatus_eConsumeNoDefault;
}
}
}
break;
#endif
case NS_KEY_UP:
if (NS_KEY_EVENT == aEvent->eventStructType) {
nsKeyEvent* keyEvent = (nsKeyEvent*)aEvent;
if (NS_VK_SPACE == keyEvent->keyCode) {
// only activate on keyup if we're already in the :hover:active state
NS_ASSERTION(mContent->IsElement(), "How do we have a non-element?");
nsEventStates buttonState = mContent->AsElement()->State();
if (buttonState.HasAllStates(NS_EVENT_STATE_ACTIVE |
NS_EVENT_STATE_HOVER)) {
// return to normal state
nsEventStateManager *esm = aPresContext->EventStateManager();
esm->SetContentState(nsnull, NS_EVENT_STATE_ACTIVE);
esm->SetContentState(nsnull, NS_EVENT_STATE_HOVER);
MouseClicked(aPresContext, aEvent);
}
}
}
break;
case NS_MOUSE_CLICK:
if (NS_IS_MOUSE_LEFT_CLICK(aEvent)) {
MouseClicked(aPresContext, aEvent);
}
break;
}
return nsBoxFrame::HandleEvent(aPresContext, aEvent, aEventStatus);
}
NS_IMETHODIMP
nsTitleBarFrame::HandleEvent(nsPresContext* aPresContext,
nsGUIEvent* aEvent,
nsEventStatus* aEventStatus)
{
NS_ENSURE_ARG_POINTER(aEventStatus);
if (nsEventStatus_eConsumeNoDefault == *aEventStatus) {
return NS_OK;
}
PRBool doDefault = PR_TRUE;
switch (aEvent->message) {
case NS_MOUSE_BUTTON_DOWN: {
if (aEvent->eventStructType == NS_MOUSE_EVENT &&
static_cast<nsMouseEvent*>(aEvent)->button ==
nsMouseEvent::eLeftButton)
{
// titlebar has no effect in non-chrome shells
nsCOMPtr<nsISupports> cont = aPresContext->GetContainer();
nsCOMPtr<nsIDocShellTreeItem> dsti = do_QueryInterface(cont);
if (dsti) {
PRInt32 type = -1;
if (NS_SUCCEEDED(dsti->GetItemType(&type)) &&
type == nsIDocShellTreeItem::typeChrome) {
// we're tracking.
mTrackingMouseMove = PR_TRUE;
// start capture.
CaptureMouseEvents(aPresContext,PR_TRUE);
// remember current mouse coordinates.
mLastPoint = aEvent->refPoint;
}
}
*aEventStatus = nsEventStatus_eConsumeNoDefault;
doDefault = PR_FALSE;
}
}
break;
case NS_MOUSE_BUTTON_UP: {
if(mTrackingMouseMove && aEvent->eventStructType == NS_MOUSE_EVENT &&
static_cast<nsMouseEvent*>(aEvent)->button ==
nsMouseEvent::eLeftButton)
{
// we're done tracking.
mTrackingMouseMove = PR_FALSE;
// end capture
CaptureMouseEvents(aPresContext,PR_FALSE);
*aEventStatus = nsEventStatus_eConsumeNoDefault;
doDefault = PR_FALSE;
}
}
break;
case NS_MOUSE_MOVE: {
if(mTrackingMouseMove)
{
nsIntPoint nsMoveBy = aEvent->refPoint - mLastPoint;
nsIFrame* parent = GetParent();
while (parent && parent->GetType() != nsGkAtoms::menuPopupFrame)
parent = parent->GetParent();
// if the titlebar is in a popup, move the popup's widget, otherwise
// move the widget associated with the window
if (parent) {
nsCOMPtr<nsIWidget> widget;
(static_cast<nsMenuPopupFrame*>(parent))->
GetWidget(getter_AddRefs(widget));
nsIntRect bounds;
widget->GetScreenBounds(bounds);
widget->Move(bounds.x + nsMoveBy.x, bounds.y + nsMoveBy.y);
}
else {
nsIPresShell* presShell = aPresContext->PresShell();
nsPIDOMWindow *window = presShell->GetDocument()->GetWindow();
if (window) {
window->MoveBy(nsMoveBy.x, nsMoveBy.y);
}
}
*aEventStatus = nsEventStatus_eConsumeNoDefault;
doDefault = PR_FALSE;
}
}
break;
case NS_MOUSE_CLICK:
if (NS_IS_MOUSE_LEFT_CLICK(aEvent))
{
MouseClicked(aPresContext, aEvent);
}
break;
}
if ( doDefault )
return nsBoxFrame::HandleEvent(aPresContext, aEvent, aEventStatus);
else
return NS_OK;
}
void TextureLabel::mousePressEvent(QMouseEvent *ev)
{
emit MouseClicked(ev);
}
void Events()
{
KeyboardClicked();
MouseClicked();
}
NS_IMETHODIMP
nsTitleBarFrame::HandleEvent(nsPresContext* 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.
CaptureMouseEvents(aPresContext,PR_TRUE);
// remember current mouse coordinates.
mLastPoint = aEvent->refPoint;
*aEventStatus = nsEventStatus_eConsumeNoDefault;
doDefault = PR_FALSE;
}
break;
case NS_MOUSE_LEFT_BUTTON_UP: {
if(mTrackingMouseMove)
{
// we're done tracking.
mTrackingMouseMove = PR_FALSE;
// end capture
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<nsIDOMWindowInternal>
window(do_QueryInterface(aPresContext->PresShell()->GetDocument()->GetScriptGlobalObject()));
if (window) {
nsPoint nsMoveBy = aEvent->refPoint - mLastPoint;
window->MoveBy(nsMoveBy.x,nsMoveBy.y);
}
*aEventStatus = nsEventStatus_eConsumeNoDefault;
doDefault = PR_FALSE;
}
}
break;
case NS_MOUSE_LEFT_CLICK:
MouseClicked(aPresContext, aEvent);
break;
}
if ( doDefault )
return nsBoxFrame::HandleEvent(aPresContext, aEvent, aEventStatus);
else
return NS_OK;
}
NS_IMETHODIMP
nsResizerFrame::HandleEvent(nsPresContext* aPresContext,
nsGUIEvent* aEvent,
nsEventStatus* aEventStatus)
{
NS_ENSURE_ARG_POINTER(aEventStatus);
if (nsEventStatus_eConsumeNoDefault == *aEventStatus) {
return NS_OK;
}
nsWeakFrame weakFrame(this);
PRBool doDefault = PR_TRUE;
switch (aEvent->message) {
case NS_MOUSE_BUTTON_DOWN: {
if (aEvent->eventStructType == NS_MOUSE_EVENT &&
static_cast<nsMouseEvent*>(aEvent)->button == nsMouseEvent::eLeftButton)
{
nsCOMPtr<nsIBaseWindow> window;
nsIPresShell* presShell = aPresContext->GetPresShell();
nsIContent* contentToResize =
GetContentToResize(presShell, getter_AddRefs(window));
if (contentToResize) {
nsIFrame* frameToResize = contentToResize->GetPrimaryFrame();
if (!frameToResize)
break;
mMouseDownRect = frameToResize->GetScreenRect();
}
else {
// ask the widget implementation to begin a resize drag if it can
Direction direction = GetDirection();
nsresult rv = aEvent->widget->BeginResizeDrag(aEvent,
direction.mHorizontal, direction.mVertical);
if (rv == NS_ERROR_NOT_IMPLEMENTED && window) {
// if there's no native resize support, we need to do window
// resizing ourselves
window->GetPositionAndSize(&mMouseDownRect.x, &mMouseDownRect.y,
&mMouseDownRect.width, &mMouseDownRect.height);
}
else {
// for native drags, don't set the fields below
doDefault = PR_FALSE;
break;
}
}
// we're tracking
mTrackingMouseMove = PR_TRUE;
// remember current mouse coordinates
mMouseDownPoint = aEvent->refPoint + aEvent->widget->WidgetToScreenOffset();
nsIPresShell::SetCapturingContent(GetContent(), CAPTURE_IGNOREALLOWED);
doDefault = PR_FALSE;
}
}
break;
case NS_MOUSE_BUTTON_UP: {
if (mTrackingMouseMove && aEvent->eventStructType == NS_MOUSE_EVENT &&
static_cast<nsMouseEvent*>(aEvent)->button == nsMouseEvent::eLeftButton)
{
// we're done tracking.
mTrackingMouseMove = PR_FALSE;
nsIPresShell::SetCapturingContent(nsnull, 0);
doDefault = PR_FALSE;
}
}
break;
case NS_MOUSE_MOVE: {
if (mTrackingMouseMove)
{
nsCOMPtr<nsIBaseWindow> window;
nsIPresShell* presShell = aPresContext->GetPresShell();
nsCOMPtr<nsIContent> contentToResize =
GetContentToResize(presShell, getter_AddRefs(window));
// check if the returned content really is a menupopup
nsMenuPopupFrame* menuPopupFrame = nsnull;
if (contentToResize) {
nsIFrame* frameToResize = contentToResize->GetPrimaryFrame();
if (frameToResize && frameToResize->GetType() == nsGkAtoms::menuPopupFrame) {
menuPopupFrame = static_cast<nsMenuPopupFrame *>(frameToResize);
}
}
// both MouseMove and direction are negative when pointing to the
// top and left, and positive when pointing to the bottom and right
// retrieve the offset of the mousemove event relative to the mousedown.
// The difference is how much the resize needs to be
nsIntPoint screenPoint(aEvent->refPoint + aEvent->widget->WidgetToScreenOffset());
nsIntPoint mouseMove(screenPoint - mMouseDownPoint);
// what direction should we go in? For content resizing, always use
// 'bottomend'. For other windows, check the dir attribute.
Direction direction;
if (window || menuPopupFrame) {
direction = GetDirection();
if (menuPopupFrame) {
menuPopupFrame->CanAdjustEdges(
(direction.mHorizontal == -1) ? NS_SIDE_LEFT : NS_SIDE_RIGHT,
(direction.mVertical == -1) ? NS_SIDE_TOP : NS_SIDE_BOTTOM, mouseMove);
}
}
else if (contentToResize) {
direction.mHorizontal =
GetStyleVisibility()->mDirection == NS_STYLE_DIRECTION_RTL ? -1 : 1;
direction.mVertical = 1;
}
else {
break; // don't do anything if there's nothing to resize
}
nsIntRect rect = mMouseDownRect;
AdjustDimensions(&rect.x, &rect.width, mouseMove.x, direction.mHorizontal);
AdjustDimensions(&rect.y, &rect.height, mouseMove.y, direction.mVertical);
// Don't allow resizing a window or a popup past the edge of the screen,
// so adjust the rectangle to fit within the available screen area.
if (window) {
nsCOMPtr<nsIScreen> screen;
nsCOMPtr<nsIScreenManager> sm(do_GetService("@mozilla.org/gfx/screenmanager;1"));
if (sm) {
nsIntRect frameRect = GetScreenRect();
sm->ScreenForRect(frameRect.x, frameRect.y, 1, 1, getter_AddRefs(screen));
if (screen) {
nsIntRect screenRect;
screen->GetRect(&screenRect.x, &screenRect.y,
&screenRect.width, &screenRect.height);
rect.IntersectRect(rect, screenRect);
}
}
}
else if (menuPopupFrame) {
nsPoint framePoint = menuPopupFrame->GetScreenRectInAppUnits().TopLeft();
nsIFrame* rootFrame = aPresContext->PresShell()->FrameManager()->GetRootFrame();
nsRect rootScreenRect = rootFrame->GetScreenRectInAppUnits();
nsRect screenRect = menuPopupFrame->GetConstraintRect(framePoint, rootScreenRect);
// round using ToInsidePixels as it's better to be a pixel too small
// than be too large. If the popup is too large it could get flipped
// to the opposite side of the anchor point while resizing.
nsIntRect screenRectPixels = screenRect.ToInsidePixels(aPresContext->AppUnitsPerDevPixel());
rect.IntersectRect(rect, screenRectPixels);
}
if (contentToResize) {
nsIntRect cssRect =
rect.ToAppUnits(aPresContext->AppUnitsPerDevPixel())
.ToInsidePixels(nsPresContext::AppUnitsPerCSSPixel());
nsAutoString widthstr, heightstr;
widthstr.AppendInt(cssRect.width);
heightstr.AppendInt(cssRect.height);
// for XUL elements, just set the width and height attributes. For
// other elements, set style.width and style.height
if (contentToResize->IsXUL()) {
nsIntRect oldRect;
nsWeakFrame weakFrame(menuPopupFrame);
if (menuPopupFrame) {
nsCOMPtr<nsIWidget> widget;
menuPopupFrame->GetWidget(getter_AddRefs(widget));
if (widget)
widget->GetScreenBounds(oldRect);
}
contentToResize->SetAttr(kNameSpaceID_None, nsGkAtoms::width, widthstr, PR_TRUE);
contentToResize->SetAttr(kNameSpaceID_None, nsGkAtoms::height, heightstr, PR_TRUE);
if (weakFrame.IsAlive() &&
(oldRect.x != rect.x || oldRect.y != rect.y)) {
// XXX This might go very wrong, since menu popups may add
// offsets (e.g. from margins) to this position, so the popup's
// widget won't end up at the desired position.
menuPopupFrame->MoveTo(rect.x, rect.y, PR_TRUE);
}
}
else {
nsCOMPtr<nsIDOMElementCSSInlineStyle> inlineStyleContent =
do_QueryInterface(contentToResize);
if (inlineStyleContent) {
widthstr += NS_LITERAL_STRING("px");
heightstr += NS_LITERAL_STRING("px");
nsCOMPtr<nsIDOMCSSStyleDeclaration> decl;
inlineStyleContent->GetStyle(getter_AddRefs(decl));
decl->SetProperty(NS_LITERAL_STRING("width"), widthstr, EmptyString());
decl->SetProperty(NS_LITERAL_STRING("height"), heightstr, EmptyString());
}
}
}
else {
window->SetPositionAndSize(rect.x, rect.y, rect.width, rect.height, PR_TRUE); // do the repaint.
}
doDefault = PR_FALSE;
}
}
break;
case NS_MOUSE_CLICK:
if (NS_IS_MOUSE_LEFT_CLICK(aEvent))
{
MouseClicked(aPresContext, aEvent);
}
break;
}
if (!doDefault)
*aEventStatus = nsEventStatus_eConsumeNoDefault;
if (doDefault && weakFrame.IsAlive())
return nsTitleBarFrame::HandleEvent(aPresContext, aEvent, aEventStatus);
else
return NS_OK;
}
NS_IMETHODIMP
nsResizerFrame::HandleEvent(nsPresContext* aPresContext,
nsGUIEvent* aEvent,
nsEventStatus* aEventStatus)
{
NS_ENSURE_ARG_POINTER(aEventStatus);
if (nsEventStatus_eConsumeNoDefault == *aEventStatus) {
return NS_OK;
}
nsWeakFrame weakFrame(this);
bool doDefault = true;
switch (aEvent->message) {
case NS_MOUSE_BUTTON_DOWN: {
if (aEvent->eventStructType == NS_MOUSE_EVENT &&
static_cast<nsMouseEvent*>(aEvent)->button == nsMouseEvent::eLeftButton)
{
nsCOMPtr<nsIBaseWindow> window;
nsIPresShell* presShell = aPresContext->GetPresShell();
nsIContent* contentToResize =
GetContentToResize(presShell, getter_AddRefs(window));
if (contentToResize) {
nsIFrame* frameToResize = contentToResize->GetPrimaryFrame();
if (!frameToResize)
break;
// cache the content rectangle for the frame to resize
// GetScreenRectInAppUnits returns the border box rectangle, so
// adjust to get the desired content rectangle.
nsRect rect = frameToResize->GetScreenRectInAppUnits();
switch (frameToResize->GetStylePosition()->mBoxSizing) {
case NS_STYLE_BOX_SIZING_CONTENT:
rect.Deflate(frameToResize->GetUsedPadding());
case NS_STYLE_BOX_SIZING_PADDING:
rect.Deflate(frameToResize->GetUsedBorder());
default:
break;
}
mMouseDownRect = rect.ToNearestPixels(aPresContext->AppUnitsPerDevPixel());
doDefault = false;
}
else {
// If there is no window, then resizing isn't allowed.
if (!window)
break;
doDefault = false;
// ask the widget implementation to begin a resize drag if it can
Direction direction = GetDirection();
nsresult rv = aEvent->widget->BeginResizeDrag(aEvent,
direction.mHorizontal, direction.mVertical);
// for native drags, don't set the fields below
if (rv != NS_ERROR_NOT_IMPLEMENTED)
break;
// if there's no native resize support, we need to do window
// resizing ourselves
window->GetPositionAndSize(&mMouseDownRect.x, &mMouseDownRect.y,
&mMouseDownRect.width, &mMouseDownRect.height);
}
// we're tracking
mTrackingMouseMove = true;
// remember current mouse coordinates
mMouseDownPoint = aEvent->refPoint + aEvent->widget->WidgetToScreenOffset();
nsIPresShell::SetCapturingContent(GetContent(), CAPTURE_IGNOREALLOWED);
}
}
break;
case NS_MOUSE_BUTTON_UP: {
if (mTrackingMouseMove && aEvent->eventStructType == NS_MOUSE_EVENT &&
static_cast<nsMouseEvent*>(aEvent)->button == nsMouseEvent::eLeftButton)
{
// we're done tracking.
mTrackingMouseMove = false;
nsIPresShell::SetCapturingContent(nsnull, 0);
doDefault = false;
}
}
break;
case NS_MOUSE_MOVE: {
if (mTrackingMouseMove)
{
nsCOMPtr<nsIBaseWindow> window;
nsIPresShell* presShell = aPresContext->GetPresShell();
nsCOMPtr<nsIContent> contentToResize =
GetContentToResize(presShell, getter_AddRefs(window));
// check if the returned content really is a menupopup
nsMenuPopupFrame* menuPopupFrame = nsnull;
if (contentToResize) {
nsIFrame* frameToResize = contentToResize->GetPrimaryFrame();
if (frameToResize && frameToResize->GetType() == nsGkAtoms::menuPopupFrame) {
menuPopupFrame = static_cast<nsMenuPopupFrame *>(frameToResize);
}
}
// both MouseMove and direction are negative when pointing to the
// top and left, and positive when pointing to the bottom and right
// retrieve the offset of the mousemove event relative to the mousedown.
// The difference is how much the resize needs to be
nsIntPoint screenPoint(aEvent->refPoint + aEvent->widget->WidgetToScreenOffset());
nsIntPoint mouseMove(screenPoint - mMouseDownPoint);
// Determine which direction to resize by checking the dir attribute.
// For windows and menus, ensure that it can be resized in that direction.
Direction direction = GetDirection();
if (window || menuPopupFrame) {
if (menuPopupFrame) {
menuPopupFrame->CanAdjustEdges(
(direction.mHorizontal == -1) ? NS_SIDE_LEFT : NS_SIDE_RIGHT,
(direction.mVertical == -1) ? NS_SIDE_TOP : NS_SIDE_BOTTOM, mouseMove);
}
}
else if (!contentToResize) {
break; // don't do anything if there's nothing to resize
}
nsIntRect rect = mMouseDownRect;
AdjustDimensions(&rect.x, &rect.width, mouseMove.x, direction.mHorizontal);
AdjustDimensions(&rect.y, &rect.height, mouseMove.y, direction.mVertical);
// Don't allow resizing a window or a popup past the edge of the screen,
// so adjust the rectangle to fit within the available screen area.
if (window) {
nsCOMPtr<nsIScreen> screen;
nsCOMPtr<nsIScreenManager> sm(do_GetService("@mozilla.org/gfx/screenmanager;1"));
if (sm) {
nsIntRect frameRect = GetScreenRect();
sm->ScreenForRect(frameRect.x, frameRect.y, 1, 1, getter_AddRefs(screen));
if (screen) {
nsIntRect screenRect;
screen->GetRect(&screenRect.x, &screenRect.y,
&screenRect.width, &screenRect.height);
rect.IntersectRect(rect, screenRect);
}
}
}
else if (menuPopupFrame) {
nsRect frameRect = menuPopupFrame->GetScreenRectInAppUnits();
nsIFrame* rootFrame = aPresContext->PresShell()->FrameManager()->GetRootFrame();
nsRect rootScreenRect = rootFrame->GetScreenRectInAppUnits();
nsRect screenRect = menuPopupFrame->GetConstraintRect(frameRect, rootScreenRect);
// round using ToInsidePixels as it's better to be a pixel too small
// than be too large. If the popup is too large it could get flipped
// to the opposite side of the anchor point while resizing.
nsIntRect screenRectPixels = screenRect.ToInsidePixels(aPresContext->AppUnitsPerDevPixel());
rect.IntersectRect(rect, screenRectPixels);
}
if (contentToResize) {
// convert the rectangle into css pixels. When changing the size in a
// direction, don't allow the new size to be less that the resizer's
// size. This ensures that content isn't resized too small as to make
// the resizer invisible.
nsRect appUnitsRect = rect.ToAppUnits(aPresContext->AppUnitsPerDevPixel());
if (appUnitsRect.width < mRect.width && mouseMove.x)
appUnitsRect.width = mRect.width;
if (appUnitsRect.height < mRect.height && mouseMove.y)
appUnitsRect.height = mRect.height;
nsIntRect cssRect = appUnitsRect.ToInsidePixels(nsPresContext::AppUnitsPerCSSPixel());
nsIntRect oldRect;
nsWeakFrame weakFrame(menuPopupFrame);
if (menuPopupFrame) {
nsCOMPtr<nsIWidget> widget = menuPopupFrame->GetWidget();
if (widget)
widget->GetScreenBounds(oldRect);
// convert the new rectangle into outer window coordinates
nsIntPoint clientOffset = widget->GetClientOffset();
rect.x -= clientOffset.x;
rect.y -= clientOffset.y;
}
SizeInfo sizeInfo, originalSizeInfo;
sizeInfo.width.AppendInt(cssRect.width);
sizeInfo.height.AppendInt(cssRect.height);
ResizeContent(contentToResize, direction, sizeInfo, &originalSizeInfo);
MaybePersistOriginalSize(contentToResize, originalSizeInfo);
if (weakFrame.IsAlive() &&
(oldRect.x != rect.x || oldRect.y != rect.y) &&
(!menuPopupFrame->IsAnchored() ||
menuPopupFrame->PopupLevel() != ePopupLevelParent)) {
menuPopupFrame->MoveTo(rect.x, rect.y, true);
}
}
else {
window->SetPositionAndSize(rect.x, rect.y, rect.width, rect.height, true); // do the repaint.
}
doDefault = false;
}
}
break;
case NS_MOUSE_CLICK:
if (NS_IS_MOUSE_LEFT_CLICK(aEvent))
{
MouseClicked(aPresContext, aEvent);
}
break;
case NS_MOUSE_DOUBLECLICK:
if (aEvent->eventStructType == NS_MOUSE_EVENT &&
static_cast<nsMouseEvent*>(aEvent)->button == nsMouseEvent::eLeftButton)
{
nsCOMPtr<nsIBaseWindow> window;
nsIPresShell* presShell = aPresContext->GetPresShell();
nsIContent* contentToResize =
GetContentToResize(presShell, getter_AddRefs(window));
if (contentToResize) {
nsIFrame* frameToResize = contentToResize->GetPrimaryFrame();
if (frameToResize && frameToResize->GetType() == nsGkAtoms::menuPopupFrame)
break; // Don't restore original sizing for menupopup frames until
// we handle screen constraints here. (Bug 357725)
RestoreOriginalSize(contentToResize);
}
}
break;
}
if (!doDefault)
*aEventStatus = nsEventStatus_eConsumeNoDefault;
if (doDefault && weakFrame.IsAlive())
return nsTitleBarFrame::HandleEvent(aPresContext, aEvent, aEventStatus);
return NS_OK;
}
NS_IMETHODIMP
nsResizerFrame::HandleEvent(nsPresContext* aPresContext,
nsGUIEvent* aEvent,
nsEventStatus* aEventStatus)
{
nsWeakFrame weakFrame(this);
PRBool doDefault = PR_TRUE;
switch (aEvent->message) {
case NS_MOUSE_BUTTON_DOWN: {
if (aEvent->eventStructType == NS_MOUSE_EVENT &&
static_cast<nsMouseEvent*>(aEvent)->button ==
nsMouseEvent::eLeftButton)
{
nsresult rv = NS_OK;
// what direction should we go in?
// convert eDirection to horizontal and vertical directions
static const PRInt8 directions[][2] = {
{-1, -1}, {0, -1}, {1, -1},
{-1, 0}, {1, 0},
{-1, 1}, {0, 1}, {1, 1}
};
// ask the widget implementation to begin a resize drag if it can
rv = aEvent->widget->BeginResizeDrag(aEvent,
directions[mDirection][0], directions[mDirection][1]);
if (rv == NS_ERROR_NOT_IMPLEMENTED) {
// there's no native resize support,
// we need to window resizing ourselves
// 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);
}
*aEventStatus = nsEventStatus_eConsumeNoDefault;
doDefault = PR_FALSE;
}
}
break;
case NS_MOUSE_BUTTON_UP: {
if(mTrackingMouseMove && aEvent->eventStructType == NS_MOUSE_EVENT &&
static_cast<nsMouseEvent*>(aEvent)->button ==
nsMouseEvent::eLeftButton)
{
// 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 window - should this be cached?
nsPIDOMWindow *domWindow =
aPresContext->PresShell()->GetDocument()->GetWindow();
NS_ENSURE_TRUE(domWindow, NS_ERROR_FAILURE);
nsCOMPtr<nsIDocShellTreeItem> docShellAsItem =
do_QueryInterface(domWindow->GetDocShell());
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_CLICK:
if (NS_IS_MOUSE_LEFT_CLICK(aEvent))
{
MouseClicked(aPresContext, aEvent);
}
break;
}
if (doDefault && weakFrame.IsAlive())
return nsTitleBarFrame::HandleEvent(aPresContext, aEvent, aEventStatus);
else
return NS_OK;
}
NS_IMETHODIMP nsScrollbarButtonFrame::Notify(nsITimer *timer)
{
MouseClicked();
return NS_OK;
}