C4MouseControl Class Reference

#include <C4MouseControl.h>

Collaboration diagram for C4MouseControl:

Public Member Functions
	C4MouseControl ()
	~C4MouseControl ()
void	Default ()
void	Clear ()
bool	Init (int32_t iPlayer)
void	Execute ()
void	HideCursor ()
void	ShowCursor ()
void	Draw (C4TargetFacet &cgo, const ZoomData &GameZoom)
void	Move (int32_t iButton, int32_t iX, int32_t iY, DWORD dwKeyFlags, bool fCenter=false)
void	DoMoveInput ()
bool	IsViewport (C4Viewport *pViewport)
void	ClearPointers (C4Object *pObj)
void	UpdateClip ()
void	SetOwnedMouse (bool fToVal)
bool	IsMouseOwned ()
bool	IsActive ()
bool	GetLastCursorPos (int32_t *x_out_gui, int32_t *y_out_gui, int32_t *x_out_game, int32_t *y_out_game) const
const char *	GetCaption ()
void	SetTooltipText (const StdStrBuf &text)
void	SetTooltipRectangle (const C4Rect &rectangle)
bool	IsDragging ()
bool	IsLeftDown ()
int32_t	GetPlayer ()

Protected Member Functions
void	UpdateFogOfWar ()
void	RightUpDragNone ()
void	ButtonUpDragScript ()
void	LeftUpDragNone ()
void	DragScript ()
void	Wheel (DWORD dwFlags)
void	RightUp ()
void	RightDown ()
void	LeftDouble ()
void	DragNone ()
void	LeftUp ()
void	LeftDown ()
void	UpdateScrolling ()
void	UpdateCursorTarget ()
int32_t	UpdateSingleSelection ()
C4Object *	GetTargetObject ()
bool	IsPassive ()
void	ScrollView (float iX, float iY, float ViewWdt, float ViewHgt)

Protected Attributes
bool	Active
bool	fMouseOwned
int32_t	Player
C4Player *	pPlayer
C4Viewport *	Viewport
int32_t	Cursor
int32_t	VpX
int32_t	VpY
float	ViewX
float	ViewY
float	GameX
float	GameY
float	GuiX
float	GuiY
C4Facet	fctViewport
C4Facet	fctViewportGame
C4Facet	fctViewportGUI
float	DownX
float	DownY
int32_t	ScrollSpeed
int32_t	Drag
bool	LeftButtonDown
bool	RightButtonDown
bool	LeftDoubleIgnoreUp
bool	ButtonDownOnSelection
bool	ControlDown
bool	ShiftDown
bool	AltDown
bool	Scrolling
bool	InitCentered
bool	FogOfWar
bool	Visible
C4ObjectList	Selection
C4Object *	DragObject
C4ID	DragID
C4Def *	DragImageDef
C4Object *	DragImageObject
StdCopyStrBuf	Caption
StdCopyStrBuf	TooltipText
int32_t	CaptionBottomY
int32_t	KeepCaption
int32_t	TimeInTooltipRectangle
C4Rect	ToolTipRectangle
C4Object *	TargetObject
C4Object *	DownTarget

Friends
class	C4Viewport

Detailed Description

Definition at line 66 of file C4MouseControl.h.

Constructor & Destructor Documentation

C4MouseControl()

C4MouseControl::C4MouseControl

(

)

Definition at line 45 of file C4MouseControl.cpp.

{
    Default();
}

References Default().

Here is the call graph for this function:

~C4MouseControl()

C4MouseControl::~C4MouseControl

(

)

Definition at line 50 of file C4MouseControl.cpp.

{
    Clear();
}

References Clear().

Here is the call graph for this function:

Member Function Documentation

ButtonUpDragScript()

void C4MouseControl::ButtonUpDragScript ( )

protected

Definition at line 753 of file C4MouseControl.cpp.

{
    // Determine drag+drop targets
    UpdateCursorTarget();
    // Finish drag
    Drag=C4MC_Drag_None;
    DragID=C4ID::None;
    DragImageObject = nullptr;
    DragImageDef = nullptr;
    C4Object *DragObject = this->DragObject;
    this->DragObject = nullptr;
    C4Object *DropObject = TargetObject;
    // drag object must exist; drop object is optional
    if (!DragObject) return;
    if (DropObject && (~DropObject->GetPropertyInt(P_MouseDrag) & C4MC_MD_DropTarget))
        DropObject = nullptr;
    // no commands if player is eliminated or doesn't exist any more
    C4Player *pPlr = ::Players.Get(Player);
    if (!pPlr || pPlr->Eliminated) return;
    // todo: Perform drag/drop validity check
    // now drag/drop is handled by script
    Game.Input.Add(CID_PlrMouseMove, C4ControlPlayerMouse::DragDrop(::Players.Get(Player), DropObject, DragObject));
}

References C4Control::Add(), C4MC_Drag_None, C4MC_MD_DropTarget, CID_PlrMouseMove, Drag, C4ControlPlayerMouse::DragDrop(), DragID, DragImageDef, DragImageObject, DragObject, C4Player::Eliminated, Game, C4PlayerList::Get(), C4PropList::GetPropertyInt(), C4Game::Input, C4ID::None, P_MouseDrag, Player, Players, TargetObject, and UpdateCursorTarget().

Referenced by LeftUp(), and RightUp().

Here is the call graph for this function:

Here is the caller graph for this function:

Clear()

void C4MouseControl::Clear

(

)

Definition at line 91 of file C4MouseControl.cpp.

{
    Active = false;
    Selection.Clear();
    UpdateClip(); // reset mouse clipping!
}

References Active, C4ObjectList::Clear(), Selection, and UpdateClip().

Referenced by C4Game::Clear(), Init(), and ~C4MouseControl().

Here is the call graph for this function:

Here is the caller graph for this function:

ClearPointers()

void C4MouseControl::ClearPointers

(

C4Object *

pObj

)

Definition at line 125 of file C4MouseControl.cpp.

{
    if (TargetObject==pObj) TargetObject=nullptr;
    if (DownTarget==pObj) DownTarget=nullptr;
    if (DragObject==pObj)
    {
        DragObject=nullptr;
        Drag=C4MC_Drag_None;
        DragImageDef=nullptr;
        DragImageObject=nullptr;
    }
    Selection.ClearPointers(pObj);
}

References C4MC_Drag_None, C4ObjectList::ClearPointers(), DownTarget, Drag, DragImageDef, DragImageObject, DragObject, Selection, and TargetObject.

Referenced by C4Game::ClearPointers().

Here is the call graph for this function:

Here is the caller graph for this function:

Default()

void C4MouseControl::Default

(

)

Definition at line 55 of file C4MouseControl.cpp.

{
    Active=false;
    Player=NO_OWNER;
    pPlayer=nullptr;
    Viewport=nullptr;
    Cursor=0;
    Caption.Clear();
    CaptionBottomY=0;
    VpX=VpY=0;
    DownX=DownY=0;
    ViewX=ViewY=0;
    GuiX=GuiY=GameX=GameY=0;
    LeftButtonDown=RightButtonDown=false;
    LeftDoubleIgnoreUp=false;
    ButtonDownOnSelection=false;
    Visible=true;
    InitCentered=false;
    FogOfWar=false;
    DragID=C4ID::None;
    DragObject=nullptr;
    KeepCaption=0;
    Drag=C4MC_Drag_None;
    Selection.Default();
    TargetObject=DownTarget=nullptr;
    ControlDown=false;
    ShiftDown=false;
    AltDown=false;
    Scrolling=false;
    ScrollSpeed=10;
    DragImageDef=nullptr;
    DragImageObject=nullptr;
    fMouseOwned = true; // default mouse owned
    fctViewport.Default();
}

References Active, AltDown, ButtonDownOnSelection, C4MC_Drag_None, Caption, CaptionBottomY, StdStrBuf::Clear(), ControlDown, Cursor, C4Facet::Default(), C4ObjectList::Default(), DownTarget, DownX, DownY, Drag, DragID, DragImageDef, DragImageObject, DragObject, fctViewport, fMouseOwned, FogOfWar, GameX, GameY, GuiX, GuiY, InitCentered, KeepCaption, LeftButtonDown, LeftDoubleIgnoreUp, NO_OWNER, C4ID::None, Player, pPlayer, RightButtonDown, Scrolling, ScrollSpeed, Selection, ShiftDown, TargetObject, Viewport, ViewX, ViewY, Visible, VpX, and VpY.

Referenced by C4MouseControl(), C4Game::Default(), and Init().

Here is the call graph for this function:

Here is the caller graph for this function:

DoMoveInput()

void C4MouseControl::DoMoveInput

(

)

Definition at line 320 of file C4MouseControl.cpp.

{
    // current mouse move to input queue
    // do sanity checks
    if (!Active || !fMouseOwned) return;
    if (!(pPlayer=::Players.Get(Player))) return;
    if (!pPlayer->ControlSet) return;
    if (!pPlayer->ControlSet->IsMouseControlAssigned(C4MC_Button_None)) return;
    pPlayer->Control.DoMouseInput(0 /* only 1 mouse supported so far */, C4MC_Button_None, GameX, GameY, GuiX, GuiY, (ControlDown && MK_CONTROL) | (ShiftDown && MK_SHIFT) | (AltDown && MK_ALT));
}

References Active, AltDown, C4MC_Button_None, C4Player::Control, ControlDown, C4Player::ControlSet, C4PlayerControl::DoMouseInput(), fMouseOwned, GameX, GameY, C4PlayerList::Get(), GuiX, GuiY, C4PlayerControlAssignmentSet::IsMouseControlAssigned(), Player, Players, pPlayer, and ShiftDown.

Referenced by C4GameControl::PrepareInput().

Here is the call graph for this function:

Here is the caller graph for this function:

DragNone()

void C4MouseControl::DragNone ( )

protected

Definition at line 638 of file C4MouseControl.cpp.

{
    // Cursor movement
    UpdateCursorTarget();
    // Update selection
    UpdateSingleSelection();
 
    // Button down: begin drag
    if ( (LeftButtonDown || RightButtonDown)
         && ((Abs(GameX-DownX)>C4MC_DragSensitivity) || (Abs(GameY-DownY)>C4MC_DragSensitivity)) )
    {
        bool fAllowDrag = true;
        // check if target object allows scripted dragging
        if (fAllowDrag && DownTarget && (!FogOfWar || (DownTarget->Category & C4D_IgnoreFoW)))
        {
            C4Object *drag_image_obj; C4Def * drag_image_def;
 
            // Drag only if MD_SOURCE is set and drag image is present
            if ( (DownTarget->GetPropertyInt(P_MouseDrag) & C4MC_MD_DragSource) &&
                  DownTarget->GetDragImage(&drag_image_obj, &drag_image_def))
            {
                Drag=C4MC_Drag_Script;
 
                if(drag_image_obj) DragImageObject = drag_image_obj;
                else DragImageDef = drag_image_def;
 
                DragObject = DownTarget;
            }
        }
 
        // dragging somewhere unhandled - mark drag process so moving over a draggable object won't start a drag
        if (Drag == C4MC_Drag_None)
        {
            Drag=C4MC_Drag_Unhandled;
        }
    }
}

References Abs(), C4D_IgnoreFoW, C4MC_Drag_None, C4MC_Drag_Script, C4MC_Drag_Unhandled, C4MC_DragSensitivity, C4MC_MD_DragSource, C4Object::Category, DownTarget, DownX, DownY, Drag, DragImageDef, DragImageObject, DragObject, FogOfWar, GameX, GameY, C4Object::GetDragImage(), C4PropList::GetPropertyInt(), LeftButtonDown, P_MouseDrag, RightButtonDown, UpdateCursorTarget(), and UpdateSingleSelection().

Referenced by Move().

Here is the call graph for this function:

Here is the caller graph for this function:

DragScript()

void C4MouseControl::DragScript ( )

protected

Definition at line 723 of file C4MouseControl.cpp.

{
    // script drag should update target and selection so selection highlight on drop target is visible
    // Cursor movement
    UpdateCursorTarget();
    // Update selection
    UpdateSingleSelection();
    Cursor=C4MC_Cursor_DragDrop;
}

References C4MC_Cursor_DragDrop, Cursor, UpdateCursorTarget(), and UpdateSingleSelection().

Referenced by Move().

Here is the call graph for this function:

Here is the caller graph for this function:

Draw()

void C4MouseControl::Draw	(	C4TargetFacet &	cgo,
		const ZoomData &	GameZoom
	)

Definition at line 331 of file C4MouseControl.cpp.

{
    int32_t iOffsetX,iOffsetY;
    float wdt = GfxR->fctMouseCursor.Wdt, hgt = GfxR->fctMouseCursor.Hgt;
    // Cursor size relative to height - does not matter with current square graphics.
    float zoom = Config.Graphics.MouseCursorSize / hgt;
    hgt *= zoom;
    wdt *= zoom;
 
    ZoomData GuiZoom;
    pDraw->GetZoom(&GuiZoom);
 
    // Hidden
    if (!Visible || !fMouseOwned) return;
 
    // Draw selection
    if (!IsPassive())
    {
        Selection.DrawSelectMark(cgo);
    }
 
    // Draw control
    switch (Drag)
    {
        //------------------------------------------------------------------------------------------
    case C4MC_Drag_None: case C4MC_Drag_Script: case C4MC_Drag_Unhandled:
        // Hotspot offset: Usually, hotspot is in center
        iOffsetX = wdt/2;
        iOffsetY = hgt/2;
        // calculate the hotspot for the scrolling cursors
        switch (Cursor)
        {
        case C4MC_Cursor_Up: iOffsetY += -hgt/2; break;
        case C4MC_Cursor_Down:iOffsetY += +hgt/2; break;
        case C4MC_Cursor_Left: iOffsetX += -wdt/2; break;
        case C4MC_Cursor_Right: iOffsetX += +wdt/2; break;
        case C4MC_Cursor_UpLeft: iOffsetX += -wdt/2; iOffsetY += -hgt/2; break;
        case C4MC_Cursor_UpRight: iOffsetX += +wdt/2; iOffsetY += -hgt/2; break;
        case C4MC_Cursor_DownLeft: iOffsetX += -wdt/2; iOffsetY += +hgt/2; break;
        case C4MC_Cursor_DownRight: iOffsetX += +wdt/2; iOffsetY += +hgt/2; break;
        }
        // Drag image
        if (DragImageObject || DragImageDef)
        {
            C4DefGraphics* pGfx;
            if(DragImageObject)
                pGfx = DragImageObject->GetGraphics();
            else
                pGfx = &DragImageDef->Graphics;
 
            // Determine image boundaries
            float ImageWdt;
            float ImageHgt;
            if (pGfx->Type == C4DefGraphics::TYPE_Bitmap)
            {
                C4Def* Def = (DragImageObject ? DragImageObject->Def : DragImageDef);
                ImageWdt = Def->PictureRect.Wdt;
                ImageHgt = Def->PictureRect.Hgt;
            }
            else if (pGfx->Type == C4DefGraphics::TYPE_Mesh)
            {
                // Note bounding box is in OGRE coordinate system
                ImageWdt = pGfx->Mesh->GetBoundingBox().y2 - pGfx->Mesh->GetBoundingBox().y1;
                ImageHgt = pGfx->Mesh->GetBoundingBox().z2 - pGfx->Mesh->GetBoundingBox().z1;
            }
            else
            {
                ImageWdt = ImageHgt = 1.0f;
            }
 
            // zoom mode: Drag in GUI or Game depending on source object
            bool fIsGameZoom = true;
            if (Drag == C4MC_Drag_Script && DragObject && (DragObject->Category & C4D_Foreground))
                fIsGameZoom = false;
            // drag image in game zoom
            float XDraw, YDraw, ZoomDraw;
            if (fIsGameZoom)
            {
                pDraw->SetZoom(GameZoom);
                XDraw = GameX; YDraw = GameY;
                ZoomDraw = 1.0f;
            }
            else
            {
                ZoomDraw = std::min(64.0f / ImageWdt, 64.0f / ImageHgt);
                XDraw = GuiX; YDraw = GuiY;
            }
 
            iOffsetX=int(ZoomDraw*ImageWdt/2);
            iOffsetY=int(ZoomDraw*ImageHgt/2);
 
            C4TargetFacet ccgo;
            ccgo.Set(cgo.Surface, XDraw + cgo.X - iOffsetX, YDraw + cgo.Y - iOffsetY, float(ImageWdt)*ZoomDraw, float(ImageHgt)*ZoomDraw);
 
            if (DragImageObject)
            {
                uint32_t ColorMod = DragImageObject->ColorMod;
                uint32_t BlitMode = DragImageObject->BlitMode;
                DragImageObject->ColorMod = (Drag == C4MC_Drag_Script) ? 0x7fffffff : (/*DragImagePhase*/false ? 0x8f7f0000 : 0x1f007f00);
                DragImageObject->BlitMode = C4GFXBLIT_MOD2;
 
                DragImageObject->DrawPicture(ccgo, false, nullptr);
 
                DragImageObject->ColorMod = ColorMod;
                DragImageObject->BlitMode = BlitMode;
            }
            else
            {
                // draw in special modulation mode
                pDraw->SetBlitMode(C4GFXBLIT_MOD2);
                // draw DragImage in red or green, according to the phase to be used
                pDraw->ActivateBlitModulation((Drag == C4MC_Drag_Script) ? 0x7fffffff : (/*DragImagePhase*/false ? 0x8f7f0000 : 0x1f007f00));
 
                DragImageDef->Draw(ccgo, false, pPlayer ? pPlayer->ColorDw : 0xff0000ff, nullptr, 0, 0, nullptr);
 
                // reset color
                pDraw->DeactivateBlitModulation();
                pDraw->SetBlitMode(0);
            }
 
            if (fIsGameZoom) pDraw->SetZoom(GuiZoom);
            // reset cursor hotspot offset for script drawing
            iOffsetX = wdt/2;
            iOffsetY = hgt/2;
        }
        // Cursor
        if ( (!DragImageDef && !DragImageObject) || (Drag == C4MC_Drag_Script))
        {
            GfxR->fctMouseCursor.DrawX(cgo.Surface, cgo.X+GuiX-iOffsetX, cgo.Y+GuiY-iOffsetY, wdt, hgt,  Cursor);
        }
        break;
        //------------------------------------------------------------------------------------------
    }
 
    // Draw caption
    if (Caption && ::pGUI)
    {
        C4TargetFacet cgoTip;
        cgoTip = static_cast<const C4Facet &>(cgo);
        C4GUI::Screen::DrawToolTip(Caption.getData(), cgoTip, cgo.X+GuiX, cgo.Y+GuiY);
    }
 
}

References C4Draw::ActivateBlitModulation(), C4Object::BlitMode, C4D_Foreground, C4GFXBLIT_MOD2, C4MC_Cursor_Down, C4MC_Cursor_DownLeft, C4MC_Cursor_DownRight, C4MC_Cursor_Left, C4MC_Cursor_Right, C4MC_Cursor_Up, C4MC_Cursor_UpLeft, C4MC_Cursor_UpRight, C4MC_Drag_None, C4MC_Drag_Script, C4MC_Drag_Unhandled, Caption, C4Object::Category, C4Player::ColorDw, C4Object::ColorMod, Config, Cursor, C4Draw::DeactivateBlitModulation(), C4Object::Def, Drag, DragImageDef, DragImageObject, DragObject, C4Def::Draw(), C4Object::DrawPicture(), C4ObjectList::DrawSelectMark(), C4GUI::Screen::DrawToolTip(), fMouseOwned, GameX, GameY, StdStrBuf::getData(), C4Object::GetGraphics(), C4Draw::GetZoom(), GfxR, C4Config::Graphics, C4Def::Graphics, GuiX, GuiY, C4Rect::Hgt, IsPassive(), C4ConfigGraphics::MouseCursorSize, pDraw, pGUI, C4Def::PictureRect, pPlayer, Selection, C4TargetFacet::Set(), C4Draw::SetBlitMode(), C4Draw::SetZoom(), C4Facet::Surface, C4DefGraphics::Type, C4DefGraphics::TYPE_Bitmap, C4DefGraphics::TYPE_Mesh, Visible, C4Rect::Wdt, C4Facet::X, and C4Facet::Y.

Referenced by C4Viewport::DrawOverlay().

Here is the call graph for this function:

Here is the caller graph for this function:

Execute()

void C4MouseControl::Execute

(

)

Definition at line 98 of file C4MouseControl.cpp.

{
 
    if (!Active || !fMouseOwned) return;
 
    // Scrolling/continuous update
    if (Scrolling || !::Game.iTick5)
    {
        WORD wKeyState=0;
        if (ControlDown) wKeyState|=MK_CONTROL;
        if (ShiftDown) wKeyState|=MK_SHIFT;
        if (AltDown) wKeyState|=MK_ALT;
        Move(C4MC_Button_None, VpX, VpY, wKeyState);
    }
}

References Active, AltDown, C4MC_Button_None, ControlDown, fMouseOwned, Game, C4Game::iTick5, Move(), Scrolling, ShiftDown, VpX, and VpY.

Referenced by C4Game::Execute().

Here is the call graph for this function:

Here is the caller graph for this function:

GetCaption()

const char * C4MouseControl::GetCaption

(

)

Definition at line 819 of file C4MouseControl.cpp.

{
    return Caption.getData();
}

References Caption, and StdStrBuf::getData().

Referenced by C4EditCursor::UpdateStatusBar().

Here is the call graph for this function:

Here is the caller graph for this function:

GetLastCursorPos()

bool C4MouseControl::GetLastCursorPos	(	int32_t *	x_out_gui,
		int32_t *	y_out_gui,
		int32_t *	x_out_game,
		int32_t *	y_out_game
	)		const

Definition at line 870 of file C4MouseControl.cpp.

{
    // safety
    if (!Active || !fMouseOwned) return false;
    // OK; assign last known pos
    *x_out_gui = GuiX; *y_out_gui = GuiY;
    *x_out_game = GameX; *y_out_game = GameY;
    return true;
}

References Active, fMouseOwned, GameX, GameY, GuiX, and GuiY.

GetPlayer()

int32_t C4MouseControl::GetPlayer ( )

inline

Definition at line 167 of file C4MouseControl.h.

{ return Player; }

References Player.

Referenced by C4ObjectMenu::IsReadOnly(), C4ScriptGuiWindow::MouseEnter(), C4MenuItem::MouseEnter(), C4MenuItem::MouseInput(), C4ScriptGuiWindow::MouseInput(), C4ScriptGuiWindow::MouseLeave(), C4ObjectMenu::OnUserClose(), and C4ScriptGuiWindow::ProcessMouseInput().

Here is the caller graph for this function:

GetTargetObject()

C4Object * C4MouseControl::GetTargetObject ( )

protected

Definition at line 838 of file C4MouseControl.cpp.

{
    // find object
    // gui object position currently wrong...will fall apart once GUIZoom is activated
    C4Object *pObj = Game.FindVisObject(ViewX, ViewY, Player, fctViewportGame, fctViewportGUI, GameX,GameY, C4D_MouseSelect, GuiX-fctViewportGUI.X, GuiY-fctViewportGUI.Y);
    if (!pObj) return nullptr;
    return pObj;
}

References C4D_MouseSelect, fctViewportGame, fctViewportGUI, C4Game::FindVisObject(), Game, GameX, GameY, GuiX, GuiY, Player, ViewX, ViewY, C4Facet::X, and C4Facet::Y.

Referenced by UpdateCursorTarget().

Here is the call graph for this function:

Here is the caller graph for this function:

HideCursor()

void C4MouseControl::HideCursor

(

)

Definition at line 814 of file C4MouseControl.cpp.

{
    Visible=false;
}

References Visible.

Referenced by C4EditCursor::SetMode().

Here is the caller graph for this function:

Init()

bool C4MouseControl::Init

(

int32_t

iPlayer

)

Definition at line 114 of file C4MouseControl.cpp.

{
    Clear();
    Default();
    Active = true;
    Player = iPlayer;
    InitCentered = false;
    UpdateClip();
    return true;
}

References Active, Clear(), Default(), InitCentered, Player, and UpdateClip().

Referenced by C4FullScreen::ViewportCheck().

Here is the call graph for this function:

Here is the caller graph for this function:

IsActive()

bool C4MouseControl::IsActive ( )

inline

Definition at line 138 of file C4MouseControl.h.

{ return !!Active; }

References Active.

Referenced by C4GUI::Screen::MouseMove().

Here is the caller graph for this function:

IsDragging()

bool C4MouseControl::IsDragging

(

)

Definition at line 865 of file C4MouseControl.cpp.

{
    return Active && Drag == C4MC_Drag_Script;
}

References Active, C4MC_Drag_Script, and Drag.

Referenced by C4Viewport::DrawMenu(), and C4GUI::Screen::MouseMove().

Here is the caller graph for this function:

IsLeftDown()

bool C4MouseControl::IsLeftDown ( )

inline

Definition at line 166 of file C4MouseControl.h.

{ return LeftButtonDown; }

References LeftButtonDown.

Referenced by C4ScriptGuiWindow::ProcessMouseInput().

Here is the caller graph for this function:

IsMouseOwned()

bool C4MouseControl::IsMouseOwned ( )

inline

Definition at line 137 of file C4MouseControl.h.

{ return fMouseOwned; }

References fMouseOwned.

Referenced by C4GUI::Screen::SetMouseInGUI().

Here is the caller graph for this function:

IsPassive()

bool C4MouseControl::IsPassive ( )

protected

Definition at line 847 of file C4MouseControl.cpp.

{
    return ::Control.isReplay() || Player<=NO_OWNER;
}

References Control, C4GameControl::isReplay(), NO_OWNER, and Player.

Referenced by Draw(), LeftUpDragNone(), Move(), RightUpDragNone(), and UpdateCursorTarget().

Here is the call graph for this function:

Here is the caller graph for this function:

IsViewport()

bool C4MouseControl::IsViewport

(

C4Viewport *

pViewport

)

Definition at line 139 of file C4MouseControl.cpp.

{
    return (Viewport==pViewport);
}

References Viewport.

Referenced by C4Viewport::DrawMenu(), C4Viewport::DrawOverlay(), and C4ViewportList::MouseMoveToViewport().

Here is the caller graph for this function:

LeftDouble()

void C4MouseControl::LeftDouble ( )

protected

Definition at line 676 of file C4MouseControl.cpp.

{
    // Update status flag
    LeftButtonDown=false;
    // Set ignore flag for next left up
    LeftDoubleIgnoreUp=true;
    // Evaluate left double by drag status (can only be C4MC_Drag_None really)
    switch (Drag)
    {
        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    case C4MC_Drag_None:
        // Double left click (might be on a target)
        break;
        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    }
}

References C4MC_Drag_None, Drag, LeftButtonDown, and LeftDoubleIgnoreUp.

Referenced by Move().

Here is the caller graph for this function:

LeftDown()

void C4MouseControl::LeftDown ( )

protected

Definition at line 604 of file C4MouseControl.cpp.

{
    // Set flag
    LeftButtonDown=true;
    // Store down values (same MoveRightDown -> use StoreDown)
    DownX=GameX; DownY=GameY;
    DownTarget=TargetObject;
}

References DownTarget, DownX, DownY, GameX, GameY, LeftButtonDown, and TargetObject.

Referenced by Move().

Here is the caller graph for this function:

LeftUp()

void C4MouseControl::LeftUp ( )

protected

Definition at line 613 of file C4MouseControl.cpp.

{
    // Ignore left up after double click
    if (LeftDoubleIgnoreUp)
    {
        LeftDoubleIgnoreUp=false;
    }
    else
    {
        // Evaluate by drag status
        switch (Drag)
        {
        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        case C4MC_Drag_Unhandled: // nobreak
        case C4MC_Drag_None: LeftUpDragNone(); break;
            // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        case C4MC_Drag_Script: ButtonUpDragScript(); break;
            // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
        }
    }
    // Update status flag
    LeftButtonDown=false;
    if(!RightButtonDown) DownTarget = nullptr;
}

References ButtonUpDragScript(), C4MC_Drag_None, C4MC_Drag_Script, C4MC_Drag_Unhandled, DownTarget, Drag, LeftButtonDown, LeftDoubleIgnoreUp, LeftUpDragNone(), and RightButtonDown.

Referenced by Move().

Here is the call graph for this function:

Here is the caller graph for this function:

LeftUpDragNone()

void C4MouseControl::LeftUpDragNone ( )

protected

Definition at line 733 of file C4MouseControl.cpp.

{
    // might be in Drag_Unknown
    Drag = C4MC_Drag_None;
    // Single left click (might be on a target)
    switch (Cursor)
    {
    case C4MC_Cursor_Select:
        // Object selection to control queue
        if (!IsPassive() && Selection.GetObject() == DownTarget)
            Game.Input.Add(CID_PlrSelect, new C4ControlPlayerSelect(Player,Selection,false));
        break;
    default:
        // done in script
        break;
    }
    // Clear selection
    Selection.Clear();
}

References C4Control::Add(), C4MC_Cursor_Select, C4MC_Drag_None, CID_PlrSelect, C4ObjectList::Clear(), Cursor, DownTarget, Drag, Game, C4ObjectList::GetObject(), C4Game::Input, IsPassive(), Player, and Selection.

Referenced by LeftUp().

Here is the call graph for this function:

Here is the caller graph for this function:

Move()

void C4MouseControl::Move	(	int32_t	iButton,
		int32_t	iX,
		int32_t	iY,
		DWORD	dwKeyFlags,
		bool	fCenter = false
	)

Definition at line 175 of file C4MouseControl.cpp.

{
    // Control state
    ControlDown=false; if (dwKeyFlags & MK_CONTROL) ControlDown=true;
    ShiftDown=false; if (dwKeyFlags & MK_SHIFT) ShiftDown=true;
    AltDown=false; if(dwKeyFlags & MK_ALT) AltDown=true;
    // Active
    if (!Active || !fMouseOwned) return;
    // Execute caption
    if (KeepCaption) KeepCaption--; else { Caption.Clear(); CaptionBottomY=0; }
    // Check player
    if (Player>NO_OWNER)
    {
        pPlayer=::Players.Get(Player);
        if (!pPlayer) { Active=false; return; }
    }
    else
        pPlayer = nullptr;
    // Check viewport
    if (!(Viewport=::Viewports.GetViewport(Player))) return;
    // get view position
    C4Rect rcViewport = Viewport->GetOutputRect();
    fctViewport.Set(nullptr, rcViewport.x, rcViewport.y, rcViewport.Wdt, rcViewport.Hgt);
    ViewX=Viewport->GetViewX(); ViewY=Viewport->GetViewY();
    fctViewportGame = Viewport->last_game_draw_cgo;
    fctViewportGUI = Viewport->last_gui_draw_cgo;
    // First time viewport attachment: center mouse
#ifdef USE_WIN32_WINDOWS
    if (!InitCentered || fCenter)
    {
        iX = Viewport->ViewWdt/2;
        iY = Viewport->ViewHgt/2;
        if (!Application.isEditor)
        {
            int32_t iMidX = Viewport->OutX + iX;
            int32_t iMidY = Viewport->OutY + iY;
            RECT rtWindow;
            if (GetWindowRect(Application.pWindow->hWindow, &rtWindow))
            {
                iMidX += rtWindow.left; iMidY += rtWindow.top;
            }
            SetCursorPos(iMidX, iMidY);
        }
        InitCentered = true;
    }
#else
    if (!InitCentered || fCenter)
    {
        iX = Viewport->ViewWdt/2;
        iY = Viewport->ViewHgt/2;
        InitCentered = true;
    }
#endif
    // passive mode: scrolling and player buttons only
    if (IsPassive())
    {
        if (iButton != C4MC_Button_Wheel)
        {
            VpX=iX; VpY=iY;
            GameX=ViewX+VpX/Viewport->Zoom; GameY=ViewY+VpY/Viewport->Zoom;
            GuiX=float(VpX)/Viewport->GetGUIZoom(); GuiY=float(VpY)/Viewport->GetGUIZoom();
        }
        UpdateScrolling();
        if (iButton == C4MC_Button_LeftDown) LeftDown();
        else if (iButton == C4MC_Button_LeftUp) LeftUp();
        else UpdateCursorTarget();
        return;
    }
 
    if (iButton != C4MC_Button_Wheel)
    {
        // Position
        VpX=iX; VpY=iY;
        GameX=ViewX+VpX/Viewport->Zoom; GameY=ViewY+VpY/Viewport->Zoom;
        GuiX=float(VpX)/Viewport->GetGUIZoom(); GuiY=float(VpY)/Viewport->GetGUIZoom();
        // Scrolling
        UpdateScrolling();
        // Fog of war
        UpdateFogOfWar();
 
        // Blocked by fog of war: evaluate button up, dragging and region controls only
        if (FogOfWar && Drag == C4MC_Drag_None)
        {
            // Left button up
            if (iButton==C4MC_Button_LeftUp)
            {
                LeftButtonDown=false;
                // End any drag
                Drag=C4MC_Drag_None;
            }
            // Right button up
            if (iButton==C4MC_Button_RightUp)
            {
                RightButtonDown=false;
            }
        }
    }
 
    // Move execution by button/drag status
    switch (iButton)
    {
        //------------------------------------------------------------------------------------------
    case C4MC_Button_None:
        switch (Drag)
        {
        case C4MC_Drag_Unhandled: break; // nothing to do
        case C4MC_Drag_None: DragNone(); break;
        case C4MC_Drag_Script: DragScript(); break;
        }
        break;
        //------------------------------------------------------------------------------------------
    case C4MC_Button_LeftDown: LeftDown(); break;
        //------------------------------------------------------------------------------------------
    case C4MC_Button_LeftUp: LeftUp(); break;
        //------------------------------------------------------------------------------------------
    case C4MC_Button_LeftDouble: LeftDouble(); break;
        //------------------------------------------------------------------------------------------
    case C4MC_Button_RightDown: RightDown(); break;
        //------------------------------------------------------------------------------------------
    case C4MC_Button_RightUp: RightUp(); break;
        //------------------------------------------------------------------------------------------
    case C4MC_Button_Wheel: Wheel(dwKeyFlags); break;
    }
 
    // are custom menus active?
    bool menuProcessed = false;
    if (pPlayer)
        // adjust by viewport X/Y because the GUI windows calculate their positions (and thus check input) based on that
        menuProcessed = ::Game.ScriptGuiRoot->MouseInput(iButton, iX, iY, dwKeyFlags);
 
    if (menuProcessed)
        Cursor = C4MC_Cursor_Select;
 
    // if not caught by a menu
    if (!menuProcessed)
        // script handling of mouse control for everything but regular movement (which is sent at control frame intervals only)
        if (iButton != C4MC_Button_None)
            // not if blocked by selection object
            if (!TargetObject)
                // safety (can't really happen in !IsPassive, but w/e
                if (pPlayer && pPlayer->ControlSet)
                    if (!menuProcessed && pPlayer->ControlSet->IsMouseControlAssigned(iButton))
                        pPlayer->Control.DoMouseInput(0 /* only 1 mouse supported so far */, iButton, GameX, GameY, GuiX, GuiY, dwKeyFlags);
}

References Active, AltDown, Application, C4MC_Button_LeftDouble, C4MC_Button_LeftDown, C4MC_Button_LeftUp, C4MC_Button_None, C4MC_Button_RightDown, C4MC_Button_RightUp, C4MC_Button_Wheel, C4MC_Cursor_Select, C4MC_Drag_None, C4MC_Drag_Script, C4MC_Drag_Unhandled, Caption, CaptionBottomY, StdStrBuf::Clear(), C4Player::Control, ControlDown, C4Player::ControlSet, Cursor, C4PlayerControl::DoMouseInput(), Drag, DragNone(), DragScript(), fctViewport, fctViewportGame, fctViewportGUI, fMouseOwned, FogOfWar, Game, GameX, GameY, C4PlayerList::Get(), C4Viewport::GetGUIZoom(), C4Viewport::GetOutputRect(), C4ViewportList::GetViewport(), C4Viewport::GetViewX(), C4Viewport::GetViewY(), GuiX, GuiY, C4Rect::Hgt, InitCentered, C4Application::isEditor, C4PlayerControlAssignmentSet::IsMouseControlAssigned(), IsPassive(), KeepCaption, C4Viewport::last_game_draw_cgo, C4Viewport::last_gui_draw_cgo, LeftButtonDown, LeftDouble(), LeftDown(), LeftUp(), NO_OWNER, C4Viewport::OutX, C4Viewport::OutY, Player, Players, pPlayer, C4AbstractApp::pWindow, RightButtonDown, RightDown(), RightUp(), C4Game::ScriptGuiRoot, C4Facet::Set(), ShiftDown, TargetObject, UpdateCursorTarget(), UpdateFogOfWar(), UpdateScrolling(), C4Viewport::ViewHgt, Viewport, Viewports, C4Viewport::ViewWdt, ViewX, ViewY, VpX, VpY, C4Rect::Wdt, Wheel(), C4Rect::x, C4Rect::y, and C4Viewport::Zoom.

Referenced by Execute(), and C4ViewportList::MouseMoveToViewport().

Here is the call graph for this function:

Here is the caller graph for this function:

RightDown()

void C4MouseControl::RightDown ( )

protected

Definition at line 693 of file C4MouseControl.cpp.

{
    // Update status flag
    RightButtonDown=true;
    // Store down values (same MoveLeftDown -> use StoreDown)
    DownX=GameX; DownY=GameY;
    DownTarget=TargetObject;
}

References DownTarget, DownX, DownY, GameX, GameY, RightButtonDown, and TargetObject.

Referenced by Move().

Here is the caller graph for this function:

RightUp()

void C4MouseControl::RightUp ( )

protected

Definition at line 702 of file C4MouseControl.cpp.

{
    // Evaluate by drag status
    switch (Drag)
    {
        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    case C4MC_Drag_Unhandled: // nobreak
    case C4MC_Drag_None: RightUpDragNone(); break;
        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    case C4MC_Drag_Script: ButtonUpDragScript(); break;
        // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    }
    // Update status flag
    RightButtonDown=false;
    if(!LeftButtonDown) DownTarget = nullptr;
}

References ButtonUpDragScript(), C4MC_Drag_None, C4MC_Drag_Script, C4MC_Drag_Unhandled, DownTarget, Drag, LeftButtonDown, RightButtonDown, and RightUpDragNone().

Referenced by Move().

Here is the call graph for this function:

Here is the caller graph for this function:

RightUpDragNone()

void C4MouseControl::RightUpDragNone ( )

protected

Definition at line 777 of file C4MouseControl.cpp.

{
 
    // might be in Drag_Unknown
    Drag = C4MC_Drag_None;
 
    // Alternative object selection
    if (Cursor==C4MC_Cursor_Select && !IsPassive() && Selection.GetObject() == DownTarget)
        { Game.Input.Add(CID_PlrSelect, new C4ControlPlayerSelect(Player,Selection,true)); }
 
    // TODO: Evaluate right click
 
}

References C4Control::Add(), C4MC_Cursor_Select, C4MC_Drag_None, CID_PlrSelect, Cursor, DownTarget, Drag, Game, C4ObjectList::GetObject(), C4Game::Input, IsPassive(), Player, and Selection.

Referenced by RightUp().

Here is the call graph for this function:

Here is the caller graph for this function:

ScrollView()

void C4MouseControl::ScrollView ( float  iX, float  iY, float  ViewWdt, float  ViewHgt  )

protected

Definition at line 852 of file C4MouseControl.cpp.

{
    // player assigned: scroll player view
    if (pPlayer)
        pPlayer->ScrollView(iX, iY, ViewWdt, ViewHgt);
    else if (Viewport)
    {
        // no player: Scroll fullscreen viewport
        Viewport->ScrollView(iX, iY);
    }
 
}

References pPlayer, C4Viewport::ScrollView(), C4Player::ScrollView(), and Viewport.

Referenced by UpdateScrolling().

Here is the call graph for this function:

Here is the caller graph for this function:

SetOwnedMouse()

void C4MouseControl::SetOwnedMouse ( bool  fToVal )

inline

Definition at line 136 of file C4MouseControl.h.

{ fMouseOwned = fToVal; }

References fMouseOwned.

Referenced by C4GUI::Screen::SetMouseInGUI().

Here is the caller graph for this function:

SetTooltipRectangle()

void C4MouseControl::SetTooltipRectangle

(

const C4Rect &

rectangle

)

Definition at line 824 of file C4MouseControl.cpp.

{
    // Set the tooltip rectangle slightly larger than originally requested.
    // The tooltip will be removed when the cursor leaves the rectangle, so make sure that the tooltip is not already disabled when the cursor moves to the border-pixel of the GUI item
    // in case the GUI item uses a different check for bounds (< vs <=) than the tooltip rectangle.
    ToolTipRectangle = C4Rect(rectangle.x - 2, rectangle.y - 2, rectangle.Wdt + 4, rectangle.Hgt + 4);
    TimeInTooltipRectangle = 0;
}

References C4Rect::Hgt, TimeInTooltipRectangle, ToolTipRectangle, C4Rect::Wdt, C4Rect::x, and C4Rect::y.

Referenced by C4ScriptGuiWindow::OnMouseIn(), and UpdateCursorTarget().

Here is the caller graph for this function:

SetTooltipText()

void C4MouseControl::SetTooltipText

(

const StdStrBuf &

text

)

Definition at line 833 of file C4MouseControl.cpp.

{
    TooltipText = text;
}

References C4ScriptGuiWindowPropertyName::text, and TooltipText.

Referenced by C4ScriptGuiWindow::OnMouseIn(), and UpdateCursorTarget().

Here is the caller graph for this function:

ShowCursor()

void C4MouseControl::ShowCursor

(

)

Definition at line 809 of file C4MouseControl.cpp.

{
    Visible=true;
}

References Visible.

Referenced by C4EditCursor::SetMode().

Here is the caller graph for this function:

UpdateClip()

void C4MouseControl::UpdateClip

(

)

Definition at line 144 of file C4MouseControl.cpp.

{
#ifdef _DEBUG
    // never in debug
    return;
#endif
#ifdef USE_WIN32_WINDOWS
    // fullscreen only
    if (Application.isEditor) return;
    // application or mouse control not active? remove any clips
    if (!Active || !Application.Active || ::pGUI->HasMouseFocus()) { ClipCursor(nullptr); return; }
    // get controlled viewport
    C4Viewport *pVP=::Viewports.GetViewport(Player);
    if (!pVP) { ClipCursor(nullptr); return; }
    // adjust size by viewport size
    RECT vpRct;
    vpRct.left=pVP->OutX; vpRct.top=pVP->OutY; vpRct.right=pVP->OutX+pVP->ViewWdt; vpRct.bottom=pVP->OutY+pVP->ViewHgt;
    // adjust by window pos
    RECT rtWindow;
    if (GetWindowRect(FullScreen.hWindow, &rtWindow))
    {
        vpRct.left += rtWindow.left; vpRct.top += rtWindow.top;
        vpRct.right += rtWindow.left; vpRct.bottom+= rtWindow.top;
    }
    ClipCursor(&vpRct);
    // and inform GUI
    ::pGUI->SetPreferredDlgRect(C4Rect(pVP->OutX, pVP->OutY, pVP->ViewWdt, pVP->ViewHgt));
#endif
    //StdWindow manages this.
}

References Active, C4AbstractApp::Active, Application, FullScreen, C4ViewportList::GetViewport(), C4GUI::Screen::HasMouseFocus(), C4Application::isEditor, C4Viewport::OutX, C4Viewport::OutY, pGUI, Player, C4GUI::Screen::SetPreferredDlgRect(), C4Viewport::ViewHgt, Viewports, and C4Viewport::ViewWdt.

Referenced by Clear(), Init(), C4Viewport::SetOutputSize(), and C4GUI::Screen::UpdateMouseFocus().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateCursorTarget()

void C4MouseControl::UpdateCursorTarget ( )

protected

Definition at line 475 of file C4MouseControl.cpp.

{
    C4Object* OldTargetObject = TargetObject;
 
    if (Scrolling)
    {
        // Scrolling: no other target
        TargetObject=nullptr;
    }
    else
    {
        // Target object
        TargetObject=GetTargetObject();
        if (TargetObject && FogOfWar && !(TargetObject->Category & C4D_IgnoreFoW)) TargetObject = nullptr;
 
        // Movement
        if (!FogOfWar && !IsPassive()) Cursor=C4MC_Cursor_Crosshair;
 
        // Target action
        if (TargetObject && !IsPassive())
        {
            // default cursor for object; also set if not in FoW
            Cursor=C4MC_Cursor_Crosshair;
 
            // select custom region. Can select an object if it does not have the MD_NoClick
            // flag set. If we are currently dragging then selection depends on it being a drop target.
            bool CanSelect;
            if(Drag == C4MC_Drag_Script)
                CanSelect = (TargetObject->GetPropertyInt(P_MouseDrag) & C4MC_MD_DropTarget) != 0;
            else
                CanSelect = (TargetObject->GetPropertyInt(P_MouseDrag) & C4MC_MD_NoClick) == 0;
 
            if ( (TargetObject->Category & C4D_MouseSelect) && CanSelect)
                Cursor=C4MC_Cursor_Select;
            else
                TargetObject = nullptr;
        }
 
        // passive cursor
        if (IsPassive())
            Cursor=C4MC_Cursor_Passive;
 
        // update tooltip information
        if (OldTargetObject != TargetObject)
        {
            C4String *newTooltip = nullptr;
            if (TargetObject && (Cursor == C4MC_Cursor_Select) && (TargetObject->Category & C4D_MouseSelect) && (newTooltip = TargetObject->GetPropertyStr(P_Tooltip)))
            {
                float objX, objY;
                TargetObject->GetViewPos(objX, objY, -fctViewportGUI.X, -fctViewportGUI.Y, fctViewportGUI);
                objX += TargetObject->Shape.x;
                objY += TargetObject->Shape.y - TargetObject->addtop();
                SetTooltipRectangle(C4Rect(objX, objY, TargetObject->Shape.Wdt, TargetObject->Shape.Hgt + TargetObject->addtop()));
                SetTooltipText(StdStrBuf(newTooltip->GetCStr()));
            }
            else
            {
                SetTooltipRectangle(C4Rect(0, 0, 0, 0));
            }
        }
 
        if (!KeepCaption
            && ToolTipRectangle.Wdt != 0
            && Inside(GuiX, ToolTipRectangle.x, ToolTipRectangle.x + ToolTipRectangle.Wdt)
            && Inside(GuiY, ToolTipRectangle.y, ToolTipRectangle.y + ToolTipRectangle.Hgt))
        {
            ++TimeInTooltipRectangle;
 
            if (TimeInTooltipRectangle >= C4MC_Tooltip_Delay)
            {
                Caption = TooltipText;
            }
        }
        else
        {
            // disable tooltip pop-up; whatever set it in the first place will set it again on the next mouse-enter
            TimeInTooltipRectangle = 0;
            ToolTipRectangle.Wdt = 0;
        }
    }
 
    // Make a script callback if the object being hovered changes
    if(!IsPassive() && OldTargetObject != TargetObject)
    {
        // TODO: This might put a heavy load on the network, depending on the number of
        // selectable objects around. If it turns out to be a problem we might want to
        // deduce these hover callbacks client-side instead.
        // Or, make sure to send this at most once per control frame.
        Game.Input.Add(CID_PlrMouseMove, C4ControlPlayerMouse::Hover(::Players.Get(Player), TargetObject, OldTargetObject, DragObject));
    }
}

References C4Control::Add(), C4Object::addtop(), C4D_IgnoreFoW, C4D_MouseSelect, C4MC_Cursor_Crosshair, C4MC_Cursor_Passive, C4MC_Cursor_Select, C4MC_Drag_Script, C4MC_MD_DropTarget, C4MC_MD_NoClick, C4MC_Tooltip_Delay, Caption, C4Object::Category, CID_PlrMouseMove, Cursor, Drag, DragObject, fctViewportGUI, FogOfWar, Game, C4PlayerList::Get(), C4String::GetCStr(), C4PropList::GetPropertyInt(), C4PropList::GetPropertyStr(), GetTargetObject(), C4Object::GetViewPos(), GuiX, GuiY, C4Rect::Hgt, C4ControlPlayerMouse::Hover(), C4Game::Input, Inside(), IsPassive(), KeepCaption, P_MouseDrag, P_Tooltip, Player, Players, Scrolling, SetTooltipRectangle(), SetTooltipText(), C4Object::Shape, TargetObject, TimeInTooltipRectangle, ToolTipRectangle, TooltipText, C4Rect::Wdt, C4Facet::X, C4Rect::x, C4Facet::Y, and C4Rect::y.

Referenced by ButtonUpDragScript(), DragNone(), DragScript(), and Move().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateFogOfWar()

void C4MouseControl::UpdateFogOfWar ( )

protected

Definition at line 791 of file C4MouseControl.cpp.

{
    // Assume no fog of war
    FogOfWar=false;
    // Check for fog of war
    // TODO: Check C4FoWRegion... should maybe be passed as a parameter?
    // pDraw->GetFoW() might not be current at this time.
    if (/*(pPlayer->fFogOfWar && !pPlayer->FoWIsVisible(int32_t(GameX),int32_t(GameY))) || */GameX<0 || GameY<0 || int32_t(GameX)>=::Landscape.GetWidth() || int32_t(GameY)>=::Landscape.GetHeight())
    {
        FogOfWar=true;
        // allow dragging, scrolling, region selection and manipulations of objects not affected by FoW
        if (!Scrolling && (!TargetObject || !(TargetObject->Category & C4D_IgnoreFoW)))
        {
            Cursor=C4MC_Cursor_Passive;
        }
    }
}

References C4D_IgnoreFoW, C4MC_Cursor_Passive, C4Object::Category, Cursor, FogOfWar, GameX, GameY, C4Landscape::GetHeight(), C4Landscape::GetWidth(), Landscape, Scrolling, and TargetObject.

Referenced by Move().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateScrolling()

void C4MouseControl::UpdateScrolling ( )

protected

Definition at line 582 of file C4MouseControl.cpp.

{
    // Assume no scrolling
    Scrolling=false;
    // No scrolling if disabled by player
    if (pPlayer) if (pPlayer->IsViewLocked()) return;
    // Scrolling on border
    if (VpX==0)
        { Cursor=C4MC_Cursor_Left; ScrollView(-ScrollSpeed/Viewport->Zoom,0,Viewport->ViewWdt/Viewport->Zoom,Viewport->ViewHgt/Viewport->Zoom); Scrolling=true; }
    if (VpY==0)
        { Cursor=C4MC_Cursor_Up; ScrollView(0,-ScrollSpeed/Viewport->Zoom,Viewport->ViewWdt/Viewport->Zoom,Viewport->ViewHgt/Viewport->Zoom); Scrolling=true; }
    if (VpX==Viewport->ViewWdt-1)
        { Cursor=C4MC_Cursor_Right; ScrollView(+ScrollSpeed/Viewport->Zoom,0,Viewport->ViewWdt/Viewport->Zoom,Viewport->ViewHgt/Viewport->Zoom); Scrolling=true; }
    if (VpY==Viewport->ViewHgt-1)
        { Cursor=C4MC_Cursor_Down; ScrollView(0,+ScrollSpeed/Viewport->Zoom,Viewport->ViewWdt/Viewport->Zoom,Viewport->ViewHgt/Viewport->Zoom); Scrolling=true; }
    // Set correct cursor
    if ((VpX==0) && (VpY==0)) Cursor=C4MC_Cursor_UpLeft;
    if ((VpX==Viewport->ViewWdt-1) && (VpY==0)) Cursor=C4MC_Cursor_UpRight;
    if ((VpX==0) && (VpY==Viewport->ViewHgt-1)) Cursor=C4MC_Cursor_DownLeft;
    if ((VpX==Viewport->ViewWdt-1) && (VpY==Viewport->ViewHgt-1)) Cursor=C4MC_Cursor_DownRight;
}

References C4MC_Cursor_Down, C4MC_Cursor_DownLeft, C4MC_Cursor_DownRight, C4MC_Cursor_Left, C4MC_Cursor_Right, C4MC_Cursor_Up, C4MC_Cursor_UpLeft, C4MC_Cursor_UpRight, Cursor, C4Player::IsViewLocked(), pPlayer, Scrolling, ScrollSpeed, ScrollView(), C4Viewport::ViewHgt, Viewport, C4Viewport::ViewWdt, VpX, VpY, and C4Viewport::Zoom.

Referenced by Move().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateSingleSelection()

int32_t C4MouseControl::UpdateSingleSelection ( )

protected

Definition at line 567 of file C4MouseControl.cpp.

{
    // Set single selection if cursor on selection object (clear prior object selection)
    if (TargetObject && (Cursor==C4MC_Cursor_Select))
        { Selection.Clear(); Selection.Add(TargetObject, C4ObjectList::stNone); }
 
    // Cursor has moved off single object (or target object) selection: clear selection
    else if (Selection.GetObject())
        if (::Players.Get(Player)->ObjectInCrew(Selection.GetObject())
            || (Selection.GetObject()->Category & C4D_MouseSelect))
            Selection.Clear();
 
    return Selection.ObjectCount();
}

References C4ObjectList::Add(), C4D_MouseSelect, C4MC_Cursor_Select, C4Object::Category, C4ObjectList::Clear(), Cursor, C4PlayerList::Get(), C4ObjectList::GetObject(), C4ObjectList::ObjectCount(), C4Player::ObjectInCrew(), Player, Players, Selection, C4ObjectList::stNone, and TargetObject.

Referenced by DragNone(), and DragScript().

Here is the call graph for this function:

Here is the caller graph for this function:

Wheel()

void C4MouseControl::Wheel ( DWORD  dwFlags )

protected

Definition at line 719 of file C4MouseControl.cpp.

{
}

Referenced by Move().

Here is the caller graph for this function:

Friends And Related Function Documentation

C4Viewport

friend class C4Viewport

friend

Definition at line 68 of file C4MouseControl.h.

Member Data Documentation

Active

bool C4MouseControl::Active

protected

Definition at line 73 of file C4MouseControl.h.

Referenced by Clear(), Default(), DoMoveInput(), Execute(), GetLastCursorPos(), Init(), IsActive(), IsDragging(), Move(), and UpdateClip().

AltDown

bool C4MouseControl::AltDown

protected

Definition at line 96 of file C4MouseControl.h.

Referenced by Default(), DoMoveInput(), Execute(), and Move().

ButtonDownOnSelection

bool C4MouseControl::ButtonDownOnSelection

protected

Definition at line 93 of file C4MouseControl.h.

Referenced by Default().

Caption

StdCopyStrBuf C4MouseControl::Caption

protected

Definition at line 112 of file C4MouseControl.h.

Referenced by Default(), Draw(), GetCaption(), Move(), and UpdateCursorTarget().

CaptionBottomY

int32_t C4MouseControl::CaptionBottomY

protected

Definition at line 115 of file C4MouseControl.h.

Referenced by Default(), and Move().

ControlDown

bool C4MouseControl::ControlDown

protected

Definition at line 94 of file C4MouseControl.h.

Referenced by Default(), DoMoveInput(), Execute(), and Move().

Cursor

int32_t C4MouseControl::Cursor

protected

Definition at line 79 of file C4MouseControl.h.

Referenced by Default(), DragScript(), Draw(), LeftUpDragNone(), Move(), RightUpDragNone(), UpdateCursorTarget(), UpdateFogOfWar(), UpdateScrolling(), and UpdateSingleSelection().

DownTarget

C4Object* C4MouseControl::DownTarget

protected

Definition at line 122 of file C4MouseControl.h.

Referenced by ClearPointers(), Default(), DragNone(), LeftDown(), LeftUp(), LeftUpDragNone(), RightDown(), RightUp(), and RightUpDragNone().

DownX

float C4MouseControl::DownX

protected

Definition at line 87 of file C4MouseControl.h.

Referenced by Default(), DragNone(), LeftDown(), and RightDown().

DownY

float C4MouseControl::DownY

protected

Definition at line 87 of file C4MouseControl.h.

Referenced by Default(), DragNone(), LeftDown(), and RightDown().

Drag

int32_t C4MouseControl::Drag

protected

Definition at line 90 of file C4MouseControl.h.

Referenced by ButtonUpDragScript(), ClearPointers(), Default(), DragNone(), Draw(), IsDragging(), LeftDouble(), LeftUp(), LeftUpDragNone(), Move(), RightUp(), RightUpDragNone(), and UpdateCursorTarget().

DragID

C4ID C4MouseControl::DragID

protected

Definition at line 105 of file C4MouseControl.h.

Referenced by ButtonUpDragScript(), and Default().

DragImageDef

C4Def* C4MouseControl::DragImageDef

protected

Definition at line 106 of file C4MouseControl.h.

Referenced by ButtonUpDragScript(), ClearPointers(), Default(), DragNone(), and Draw().

DragImageObject

C4Object* C4MouseControl::DragImageObject

protected

Definition at line 107 of file C4MouseControl.h.

Referenced by ButtonUpDragScript(), ClearPointers(), Default(), DragNone(), and Draw().

DragObject

C4Object* C4MouseControl::DragObject

protected

Definition at line 104 of file C4MouseControl.h.

Referenced by ButtonUpDragScript(), ClearPointers(), Default(), DragNone(), Draw(), and UpdateCursorTarget().

fctViewport

C4Facet C4MouseControl::fctViewport

protected

Definition at line 85 of file C4MouseControl.h.

Referenced by Default(), and Move().

fctViewportGame

C4Facet C4MouseControl::fctViewportGame

protected

Definition at line 85 of file C4MouseControl.h.

Referenced by GetTargetObject(), and Move().

fctViewportGUI

C4Facet C4MouseControl::fctViewportGUI

protected

Definition at line 85 of file C4MouseControl.h.

Referenced by GetTargetObject(), Move(), and UpdateCursorTarget().

fMouseOwned

bool C4MouseControl::fMouseOwned

protected

Definition at line 74 of file C4MouseControl.h.

Referenced by Default(), DoMoveInput(), Draw(), Execute(), GetLastCursorPos(), IsMouseOwned(), Move(), and SetOwnedMouse().

FogOfWar

bool C4MouseControl::FogOfWar

protected

Definition at line 99 of file C4MouseControl.h.

Referenced by Default(), DragNone(), Move(), UpdateCursorTarget(), and UpdateFogOfWar().

GameX

float C4MouseControl::GameX

protected

Definition at line 83 of file C4MouseControl.h.

Referenced by Default(), DoMoveInput(), DragNone(), Draw(), GetLastCursorPos(), GetTargetObject(), LeftDown(), Move(), RightDown(), and UpdateFogOfWar().

GameY

float C4MouseControl::GameY

protected

Definition at line 83 of file C4MouseControl.h.

Referenced by Default(), DoMoveInput(), DragNone(), Draw(), GetLastCursorPos(), GetTargetObject(), LeftDown(), Move(), RightDown(), and UpdateFogOfWar().

GuiX

float C4MouseControl::GuiX

protected

Definition at line 84 of file C4MouseControl.h.

Referenced by Default(), DoMoveInput(), Draw(), GetLastCursorPos(), GetTargetObject(), Move(), and UpdateCursorTarget().

GuiY

float C4MouseControl::GuiY

protected

Definition at line 84 of file C4MouseControl.h.

Referenced by Default(), DoMoveInput(), Draw(), GetLastCursorPos(), GetTargetObject(), Move(), and UpdateCursorTarget().

InitCentered

bool C4MouseControl::InitCentered

protected

Definition at line 98 of file C4MouseControl.h.

Referenced by C4Viewport::AdjustPosition(), Default(), Init(), and Move().

KeepCaption

int32_t C4MouseControl::KeepCaption

protected

Definition at line 116 of file C4MouseControl.h.

Referenced by Default(), Move(), and UpdateCursorTarget().

LeftButtonDown

bool C4MouseControl::LeftButtonDown

protected

Definition at line 92 of file C4MouseControl.h.

Referenced by Default(), DragNone(), IsLeftDown(), LeftDouble(), LeftDown(), LeftUp(), Move(), and RightUp().

LeftDoubleIgnoreUp

bool C4MouseControl::LeftDoubleIgnoreUp

protected

Definition at line 92 of file C4MouseControl.h.

Referenced by Default(), LeftDouble(), and LeftUp().

Player

int32_t C4MouseControl::Player

protected

Definition at line 75 of file C4MouseControl.h.

Referenced by ButtonUpDragScript(), Default(), DoMoveInput(), GetPlayer(), GetTargetObject(), Init(), IsPassive(), LeftUpDragNone(), Move(), RightUpDragNone(), UpdateClip(), UpdateCursorTarget(), and UpdateSingleSelection().

pPlayer

C4Player* C4MouseControl::pPlayer

protected

Definition at line 76 of file C4MouseControl.h.

Referenced by Default(), DoMoveInput(), Draw(), Move(), ScrollView(), and UpdateScrolling().

RightButtonDown

bool C4MouseControl::RightButtonDown

protected

Definition at line 92 of file C4MouseControl.h.

Referenced by Default(), DragNone(), LeftUp(), Move(), RightDown(), and RightUp().

Scrolling

bool C4MouseControl::Scrolling

protected

Definition at line 97 of file C4MouseControl.h.

Referenced by Default(), Execute(), UpdateCursorTarget(), UpdateFogOfWar(), and UpdateScrolling().

ScrollSpeed

int32_t C4MouseControl::ScrollSpeed

protected

Definition at line 89 of file C4MouseControl.h.

Referenced by Default(), and UpdateScrolling().

Selection

C4ObjectList C4MouseControl::Selection

protected

Definition at line 102 of file C4MouseControl.h.

Referenced by Clear(), ClearPointers(), Default(), Draw(), LeftUpDragNone(), RightUpDragNone(), and UpdateSingleSelection().

ShiftDown

bool C4MouseControl::ShiftDown

protected

Definition at line 95 of file C4MouseControl.h.

Referenced by Default(), DoMoveInput(), Execute(), and Move().

TargetObject

C4Object* C4MouseControl::TargetObject

protected

Definition at line 121 of file C4MouseControl.h.

Referenced by ButtonUpDragScript(), ClearPointers(), Default(), LeftDown(), Move(), RightDown(), UpdateCursorTarget(), UpdateFogOfWar(), and UpdateSingleSelection().

TimeInTooltipRectangle

int32_t C4MouseControl::TimeInTooltipRectangle

protected

Definition at line 117 of file C4MouseControl.h.

Referenced by SetTooltipRectangle(), and UpdateCursorTarget().

ToolTipRectangle

C4Rect C4MouseControl::ToolTipRectangle

protected

Definition at line 118 of file C4MouseControl.h.

Referenced by SetTooltipRectangle(), and UpdateCursorTarget().

TooltipText

StdCopyStrBuf C4MouseControl::TooltipText

protected

Definition at line 114 of file C4MouseControl.h.

Referenced by SetTooltipText(), and UpdateCursorTarget().

Viewport

C4Viewport* C4MouseControl::Viewport

protected

Definition at line 77 of file C4MouseControl.h.

Referenced by Default(), IsViewport(), Move(), ScrollView(), and UpdateScrolling().

ViewX

float C4MouseControl::ViewX

protected

Definition at line 82 of file C4MouseControl.h.

Referenced by Default(), GetTargetObject(), and Move().

ViewY

float C4MouseControl::ViewY

protected

Definition at line 82 of file C4MouseControl.h.

Referenced by Default(), GetTargetObject(), and Move().

Visible

bool C4MouseControl::Visible

protected

Definition at line 100 of file C4MouseControl.h.

Referenced by Default(), Draw(), HideCursor(), and ShowCursor().

VpX

int32_t C4MouseControl::VpX

protected

Definition at line 81 of file C4MouseControl.h.

Referenced by C4Viewport::AdjustPosition(), Default(), Execute(), Move(), and UpdateScrolling().

VpY

int32_t C4MouseControl::VpY

protected

Definition at line 81 of file C4MouseControl.h.

Referenced by C4Viewport::AdjustPosition(), Default(), Execute(), Move(), and UpdateScrolling().

---

The documentation for this class was generated from the following files:

• C4MouseControl.h
• C4MouseControl.cpp