7f19a7f1f1
Decouple the actual window from rendercontext in UserDrawEvent. Change-Id: Ic440c4e7f59fcffb7800c578146e8eb528cbb7b4
515 lines
14 KiB
C++
515 lines
14 KiB
C++
/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
|
|
/*
|
|
* This file is part of the LibreOffice project.
|
|
*
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
*
|
|
* This file incorporates work covered by the following license notice:
|
|
*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed
|
|
* with this work for additional information regarding copyright
|
|
* ownership. The ASF licenses this file to you under the Apache
|
|
* License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0 .
|
|
*/
|
|
|
|
#ifndef INCLUDED_VCL_EVENT_HXX
|
|
#define INCLUDED_VCL_EVENT_HXX
|
|
|
|
#include <tools/solar.h>
|
|
#include <vcl/dllapi.h>
|
|
#include <tools/gen.hxx>
|
|
#include <vcl/keycod.hxx>
|
|
#include <vcl/cmdevt.hxx>
|
|
#include <vcl/settings.hxx>
|
|
#include <vcl/vclptr.hxx>
|
|
#include <vcl/outdev.hxx>
|
|
#include <vcl/window.hxx>
|
|
|
|
class AllSettings;
|
|
struct IDataObject;
|
|
|
|
namespace com { namespace sun { namespace star { namespace awt {
|
|
struct KeyEvent;
|
|
struct MouseEvent;
|
|
} } } }
|
|
|
|
enum TextDirectionality {
|
|
TextDirectionality_LeftToRight_TopToBottom,
|
|
TextDirectionality_RightToLeft_TopToBottom,
|
|
TextDirectionality_TopToBottom_RightToLeft
|
|
};
|
|
|
|
class VCL_DLLPUBLIC KeyEvent
|
|
{
|
|
private:
|
|
vcl::KeyCode maKeyCode;
|
|
sal_uInt16 mnRepeat;
|
|
sal_Unicode mnCharCode;
|
|
|
|
public:
|
|
KeyEvent();
|
|
KeyEvent( sal_Unicode nChar, const vcl::KeyCode& rKeyCode,
|
|
sal_uInt16 nRepeat = 0 );
|
|
|
|
sal_Unicode GetCharCode() const { return mnCharCode; }
|
|
const vcl::KeyCode& GetKeyCode() const { return maKeyCode; }
|
|
sal_uInt16 GetRepeat() const { return mnRepeat; }
|
|
|
|
KeyEvent LogicalTextDirectionality (TextDirectionality eMode) const;
|
|
KeyEvent (const KeyEvent& rKeyEvent);
|
|
|
|
};
|
|
|
|
inline KeyEvent::KeyEvent()
|
|
{
|
|
mnCharCode = 0;
|
|
mnRepeat = 0;
|
|
}
|
|
|
|
inline KeyEvent::KeyEvent( sal_Unicode nChar, const vcl::KeyCode& rKeyCode,
|
|
sal_uInt16 nRepeat ) :
|
|
maKeyCode( rKeyCode )
|
|
|
|
{
|
|
mnCharCode = nChar;
|
|
mnRepeat = nRepeat;
|
|
}
|
|
|
|
|
|
// - MouseEvent-Types -
|
|
|
|
|
|
enum class MouseEventModifiers
|
|
{
|
|
NONE = 0,
|
|
// mouse move modifiers
|
|
SIMPLEMOVE = 0x0001,
|
|
DRAGMOVE = 0x0002,
|
|
DRAGCOPY = 0x0004,
|
|
ENTERWINDOW = 0x0010,
|
|
LEAVEWINDOW = 0x0020,
|
|
SYNTHETIC = 0x0040,
|
|
MODIFIERCHANGED = 0x0080,
|
|
// mouse up/down-button modifiers
|
|
SIMPLECLICK = 0x0100,
|
|
SELECT = 0x0200,
|
|
MULTISELECT = 0x0400,
|
|
RANGESELECT = 0x0800
|
|
};
|
|
namespace o3tl
|
|
{
|
|
template<> struct typed_flags<MouseEventModifiers> : is_typed_flags<MouseEventModifiers, 0xff7> {};
|
|
}
|
|
|
|
// Maus-Buttons
|
|
#define MOUSE_LEFT ((sal_uInt16)0x0001)
|
|
#define MOUSE_MIDDLE ((sal_uInt16)0x0002)
|
|
#define MOUSE_RIGHT ((sal_uInt16)0x0004)
|
|
|
|
|
|
// - MouseEvent -
|
|
|
|
|
|
class VCL_DLLPUBLIC MouseEvent
|
|
{
|
|
private:
|
|
Point maPos;
|
|
MouseEventModifiers mnMode;
|
|
sal_uInt16 mnClicks;
|
|
sal_uInt16 mnCode;
|
|
|
|
public:
|
|
explicit MouseEvent();
|
|
explicit MouseEvent( const Point& rPos, sal_uInt16 nClicks = 1,
|
|
MouseEventModifiers nMode = MouseEventModifiers::NONE, sal_uInt16 nButtons = 0,
|
|
sal_uInt16 nModifier = 0 );
|
|
|
|
const Point& GetPosPixel() const { return maPos; }
|
|
MouseEventModifiers GetMode() const { return mnMode; }
|
|
/** inits this vcl KeyEvent with all settings from the given awt event **/
|
|
MouseEvent( const ::com::sun::star::awt::MouseEvent& rEvent );
|
|
|
|
sal_uInt16 GetClicks() const { return mnClicks; }
|
|
|
|
bool IsEnterWindow() const
|
|
{ return bool(mnMode & MouseEventModifiers::ENTERWINDOW); }
|
|
bool IsLeaveWindow() const
|
|
{ return bool(mnMode & MouseEventModifiers::LEAVEWINDOW); }
|
|
bool IsSynthetic() const
|
|
{ return bool(mnMode & MouseEventModifiers::SYNTHETIC); }
|
|
bool IsModifierChanged() const
|
|
{ return bool(mnMode & MouseEventModifiers::MODIFIERCHANGED); }
|
|
|
|
sal_uInt16 GetButtons() const
|
|
{ return (mnCode & (MOUSE_LEFT | MOUSE_MIDDLE | MOUSE_RIGHT)); }
|
|
bool IsLeft() const
|
|
{ return ((mnCode & MOUSE_LEFT) != 0); }
|
|
bool IsMiddle() const
|
|
{ return ((mnCode & MOUSE_MIDDLE) != 0); }
|
|
bool IsRight() const
|
|
{ return ((mnCode & MOUSE_RIGHT) != 0); }
|
|
|
|
sal_uInt16 GetModifier() const
|
|
{ return (mnCode & (KEY_SHIFT | KEY_MOD1 | KEY_MOD2)); }
|
|
bool IsShift() const
|
|
{ return ((mnCode & KEY_SHIFT) != 0); }
|
|
bool IsMod1() const
|
|
{ return ((mnCode & KEY_MOD1) != 0); }
|
|
bool IsMod2() const
|
|
{ return ((mnCode & KEY_MOD2) != 0); }
|
|
bool IsMod3() const
|
|
{ return ((mnCode & KEY_MOD3) != 0); }
|
|
};
|
|
|
|
inline MouseEvent::MouseEvent()
|
|
{
|
|
mnMode = MouseEventModifiers::NONE;
|
|
mnClicks = 0;
|
|
mnCode = 0;
|
|
}
|
|
|
|
inline MouseEvent::MouseEvent( const Point& rPos, sal_uInt16 nClicks,
|
|
MouseEventModifiers nMode,
|
|
sal_uInt16 nButtons, sal_uInt16 nModifier ) :
|
|
maPos( rPos )
|
|
{
|
|
mnClicks = nClicks;
|
|
mnMode = nMode;
|
|
mnCode = nButtons | nModifier;
|
|
}
|
|
|
|
class VCL_DLLPUBLIC ZoomEvent
|
|
{
|
|
private:
|
|
Point maCenter;
|
|
float mfScale;
|
|
|
|
public:
|
|
ZoomEvent() :
|
|
mfScale( 1 )
|
|
{
|
|
}
|
|
|
|
ZoomEvent( const Point& rCenter,
|
|
float fScale ) :
|
|
maCenter( rCenter ),
|
|
mfScale( fScale )
|
|
{
|
|
}
|
|
|
|
const Point& GetCenter() const
|
|
{
|
|
return maCenter;
|
|
}
|
|
|
|
float GetScale() const
|
|
{
|
|
return mfScale;
|
|
}
|
|
};
|
|
|
|
class VCL_DLLPUBLIC ScrollEvent
|
|
{
|
|
private:
|
|
int mnXOffset;
|
|
int mnYOffset;
|
|
|
|
public:
|
|
ScrollEvent() :
|
|
mnXOffset( 0 ),
|
|
mnYOffset( 0 )
|
|
{
|
|
}
|
|
|
|
ScrollEvent( int xOffset, int yOffset ) :
|
|
mnXOffset( xOffset ),
|
|
mnYOffset( yOffset )
|
|
{
|
|
}
|
|
|
|
int GetXOffset() const
|
|
{
|
|
return mnXOffset;
|
|
}
|
|
|
|
int GetYOffset() const
|
|
{
|
|
return mnYOffset;
|
|
}
|
|
};
|
|
|
|
|
|
// - HelpEvent -
|
|
|
|
enum class HelpEventMode
|
|
{
|
|
NONE = 0x0000,
|
|
CONTEXT = 0x0001,
|
|
EXTENDED = 0x0002,
|
|
BALLOON = 0x0004,
|
|
QUICK = 0x0008
|
|
};
|
|
namespace o3tl
|
|
{
|
|
template<> struct typed_flags<HelpEventMode> : is_typed_flags<HelpEventMode, 0x0f> {};
|
|
}
|
|
|
|
class VCL_DLLPUBLIC HelpEvent
|
|
{
|
|
private:
|
|
Point maPos;
|
|
HelpEventMode mnMode;
|
|
bool mbKeyboardActivated;
|
|
|
|
public:
|
|
explicit HelpEvent();
|
|
explicit HelpEvent( HelpEventMode nHelpMode );
|
|
explicit HelpEvent( const Point& rMousePos, HelpEventMode nHelpMode );
|
|
|
|
const Point& GetMousePosPixel() const { return maPos; }
|
|
HelpEventMode GetMode() const { return mnMode; }
|
|
bool KeyboardActivated() const { return mbKeyboardActivated; }
|
|
void SetKeyboardActivated( bool bKeyboard ) { mbKeyboardActivated = bKeyboard; }
|
|
};
|
|
|
|
inline HelpEvent::HelpEvent()
|
|
{
|
|
mnMode = HelpEventMode::CONTEXT;
|
|
mbKeyboardActivated = true;
|
|
}
|
|
|
|
inline HelpEvent::HelpEvent( const Point& rMousePos, HelpEventMode nHelpMode ) :
|
|
maPos( rMousePos )
|
|
{
|
|
mnMode = nHelpMode;
|
|
mbKeyboardActivated = false;
|
|
}
|
|
|
|
inline HelpEvent::HelpEvent( HelpEventMode nHelpMode )
|
|
{
|
|
mnMode = nHelpMode;
|
|
mbKeyboardActivated = true;
|
|
}
|
|
|
|
/// Event to pass information for UserDraw() handling eg. in comboboxes.
|
|
class VCL_DLLPUBLIC UserDrawEvent
|
|
{
|
|
private:
|
|
/// Window that owns the user draw.
|
|
VclPtr<vcl::Window> mpWindow;
|
|
|
|
/// RenderContext to which we should draw - can be a VirtualDevice or anything.
|
|
VclPtr<vcl::RenderContext> mpRenderContext;
|
|
|
|
Rectangle maOutRect;
|
|
sal_uInt16 mnItemId;
|
|
sal_uInt16 mnStyle;
|
|
|
|
public:
|
|
UserDrawEvent();
|
|
UserDrawEvent(vcl::Window* pWindow, vcl::RenderContext* pRenderContext,
|
|
const Rectangle& rOutRect, sal_uInt16 nId, sal_uInt16 nStyle = 0);
|
|
|
|
vcl::Window* GetWindow() const { return mpWindow; }
|
|
vcl::RenderContext* GetRenderContext() const { return mpRenderContext; }
|
|
const Rectangle& GetRect() const { return maOutRect; }
|
|
sal_uInt16 GetItemId() const { return mnItemId; }
|
|
sal_uInt16 GetStyle() const { return mnStyle; }
|
|
};
|
|
|
|
inline UserDrawEvent::UserDrawEvent()
|
|
: mpWindow(nullptr)
|
|
, mpRenderContext(nullptr)
|
|
, mnItemId(0)
|
|
, mnStyle(0)
|
|
{
|
|
}
|
|
|
|
inline UserDrawEvent::UserDrawEvent(vcl::Window* pWindow, vcl::RenderContext* pRenderContext,
|
|
const Rectangle& rOutRect, sal_uInt16 nId, sal_uInt16 nStyle)
|
|
: mpWindow(pWindow)
|
|
, mpRenderContext(pRenderContext)
|
|
, maOutRect( rOutRect )
|
|
, mnItemId(nId)
|
|
, mnStyle(nStyle)
|
|
{
|
|
}
|
|
|
|
|
|
// - TrackingEvent -
|
|
|
|
|
|
class VCL_DLLPUBLIC TrackingEvent
|
|
{
|
|
private:
|
|
MouseEvent maMEvt;
|
|
TrackingEventFlags mnFlags;
|
|
|
|
public:
|
|
explicit TrackingEvent();
|
|
explicit TrackingEvent( const MouseEvent&,
|
|
TrackingEventFlags nTrackFlags = TrackingEventFlags::NONE );
|
|
|
|
const MouseEvent& GetMouseEvent() const { return maMEvt; }
|
|
|
|
bool IsTrackingRepeat() const
|
|
{ return bool(mnFlags & TrackingEventFlags::Repeat); }
|
|
|
|
bool IsTrackingEnded() const
|
|
{ return bool(mnFlags & TrackingEventFlags::End); }
|
|
bool IsTrackingCanceled() const
|
|
{ return bool(mnFlags & TrackingEventFlags::Cancel); }
|
|
TrackingEventFlags GetTrackingFlags() const { return mnFlags; }
|
|
};
|
|
|
|
inline TrackingEvent::TrackingEvent()
|
|
{
|
|
mnFlags = TrackingEventFlags::NONE;
|
|
}
|
|
|
|
inline TrackingEvent::TrackingEvent( const MouseEvent& rMEvt,
|
|
TrackingEventFlags nTrackFlags ) :
|
|
maMEvt( rMEvt )
|
|
{
|
|
mnFlags = nTrackFlags;
|
|
}
|
|
|
|
|
|
// - NotifyEvent -
|
|
|
|
enum class MouseNotifyEvent
|
|
{
|
|
NONE = 0,
|
|
MOUSEBUTTONDOWN = 1,
|
|
MOUSEBUTTONUP = 2,
|
|
MOUSEMOVE = 3,
|
|
KEYINPUT = 4,
|
|
KEYUP = 5,
|
|
GETFOCUS = 6,
|
|
LOSEFOCUS = 7,
|
|
COMMAND = 8,
|
|
DESTROY = 9,
|
|
INPUTENABLE = 10,
|
|
INPUTDISABLE = 11,
|
|
EXECUTEDIALOG = 100,
|
|
ENDEXECUTEDIALOG = 101
|
|
};
|
|
|
|
class VCL_DLLPUBLIC NotifyEvent
|
|
{
|
|
private:
|
|
VclPtr<vcl::Window> mpWindow;
|
|
void* mpData;
|
|
MouseNotifyEvent mnEventType;
|
|
long mnRetValue;
|
|
|
|
public:
|
|
NotifyEvent();
|
|
NotifyEvent( MouseNotifyEvent nEventType,
|
|
vcl::Window* pWindow,
|
|
const void* pEvent = NULL,
|
|
long nRet = 0 );
|
|
|
|
MouseNotifyEvent GetType() const { return mnEventType; }
|
|
vcl::Window* GetWindow() const { return mpWindow; }
|
|
void* GetData() const { return mpData; }
|
|
|
|
void SetReturnValue( long nRet ) { mnRetValue = nRet; }
|
|
long GetReturnValue() const { return mnRetValue; }
|
|
|
|
const KeyEvent* GetKeyEvent() const;
|
|
const MouseEvent* GetMouseEvent() const;
|
|
const CommandEvent* GetCommandEvent() const;
|
|
};
|
|
|
|
inline const KeyEvent* NotifyEvent::GetKeyEvent() const
|
|
{
|
|
if ( (mnEventType == MouseNotifyEvent::KEYINPUT) || (mnEventType == MouseNotifyEvent::KEYUP) )
|
|
return static_cast<const KeyEvent*>(mpData);
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
inline const MouseEvent* NotifyEvent::GetMouseEvent() const
|
|
{
|
|
if ( (mnEventType >= MouseNotifyEvent::MOUSEBUTTONDOWN) && (mnEventType <= MouseNotifyEvent::MOUSEMOVE) )
|
|
return static_cast<const MouseEvent*>(mpData);
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
inline const CommandEvent* NotifyEvent::GetCommandEvent() const
|
|
{
|
|
if ( mnEventType == MouseNotifyEvent::COMMAND )
|
|
return static_cast<const CommandEvent*>(mpData);
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
|
|
// - DataChangedEvent -
|
|
|
|
|
|
enum class DataChangedEventType {
|
|
NONE = 0,
|
|
SETTINGS = 1,
|
|
DISPLAY = 2,
|
|
FONTS = 4,
|
|
PRINTER = 5,
|
|
FONTSUBSTITUTION = 6,
|
|
USER = 10000
|
|
};
|
|
|
|
class VCL_DLLPUBLIC DataChangedEvent
|
|
{
|
|
private:
|
|
void* mpData;
|
|
AllSettingsFlags mnFlags;
|
|
DataChangedEventType mnType;
|
|
|
|
public:
|
|
explicit DataChangedEvent();
|
|
explicit DataChangedEvent( DataChangedEventType nType,
|
|
const void* pData = NULL,
|
|
AllSettingsFlags nFlags = AllSettingsFlags::NONE );
|
|
|
|
DataChangedEventType GetType() const { return mnType; }
|
|
void* GetData() const { return mpData; }
|
|
AllSettingsFlags GetFlags() const { return mnFlags; }
|
|
|
|
const AllSettings* GetOldSettings() const;
|
|
};
|
|
|
|
inline DataChangedEvent::DataChangedEvent()
|
|
{
|
|
mpData = NULL;
|
|
mnFlags = AllSettingsFlags::NONE;
|
|
mnType = DataChangedEventType::NONE;
|
|
}
|
|
|
|
inline DataChangedEvent::DataChangedEvent( DataChangedEventType nType,
|
|
const void* pData,
|
|
AllSettingsFlags nChangeFlags )
|
|
{
|
|
mpData = const_cast<void*>(pData);
|
|
mnFlags = nChangeFlags;
|
|
mnType = nType;
|
|
}
|
|
|
|
inline const AllSettings* DataChangedEvent::GetOldSettings() const
|
|
{
|
|
if ( mnType == DataChangedEventType::SETTINGS )
|
|
return static_cast<const AllSettings*>(mpData);
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
#endif // INCLUDED_VCL_EVENT_HXX
|
|
|
|
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|