<para>...</para>
<para>Default value: 0</para>
</sect4>
+ <sect4 id="anchorlefttop">
+ <title>lefttop</title>
+ <para>Indicate to which corner of the Layout the top-left-hand corner of this anchor is attached, in case of resizing. Possible values are 'lefttop', 'leftbottom', 'righttop' and 'rightbottom'.</para>
+ <para>Note that there is no "rightbottom" attribute for the anchors (contrarily to normal controls), because an anchor is not resizable (even when the anchor is not ponctual and follows a Bezier curve).</para>
+ <para>Default value: lefttop</para>
+ </sect4>
<sect4 id="anchorpriority">
<title>priority</title>
<para>Priority of anchor (see the previous description).</para>
#include "cmd_resize.hpp"
#include "../src/generic_layout.hpp"
+#include "../src/window_manager.hpp"
#include "../src/vlcproc.hpp"
-CmdResize::CmdResize( intf_thread_t *pIntf, GenericLayout &rLayout, int width,
- int height ):
- CmdGeneric( pIntf ), m_rLayout( rLayout ), m_width( width ),
- m_height( height )
+CmdResize::CmdResize( intf_thread_t *pIntf, const WindowManager &rWindowManager,
+ GenericLayout &rLayout, int width, int height ):
+ CmdGeneric( pIntf ), m_rWindowManager( rWindowManager ),
+ m_rLayout( rLayout ), m_width( width ), m_height( height )
{
}
void CmdResize::execute()
{
// Resize the layout
- m_rLayout.resize( m_width, m_height );
+ m_rWindowManager.resize( m_rLayout, m_width, m_height );
}
#include "cmd_generic.hpp"
+class WindowManager;
class GenericLayout;
{
public:
/// Resize the given layout
- CmdResize( intf_thread_t *pIntf, GenericLayout &rLayout, int width,
- int height );
+ CmdResize( intf_thread_t *pIntf, const WindowManager &rWindowManager,
+ GenericLayout &rLayout, int width, int height );
virtual ~CmdResize() {}
/// This method does the real job of the command
virtual string getType() const { return "resize"; }
private:
+ const WindowManager &m_rWindowManager;
GenericLayout &m_rLayout;
int m_width, m_height;
};
#include "../commands/cmd_resize.hpp"
-CtrlResize::CtrlResize( intf_thread_t *pIntf, CtrlFlat &rCtrl,
- GenericLayout &rLayout, const UString &rHelp,
- VarBool *pVisible, Direction_t direction ):
- CtrlFlat( pIntf, rHelp, pVisible ), m_fsm( pIntf ), m_rCtrl( rCtrl ),
+CtrlResize::CtrlResize( intf_thread_t *pIntf, WindowManager &rWindowManager,
+ CtrlFlat &rCtrl, GenericLayout &rLayout,
+ const UString &rHelp, VarBool *pVisible,
+ WindowManager::Direction_t direction ):
+ CtrlFlat( pIntf, rHelp, pVisible ), m_fsm( pIntf ),
+ m_rWindowManager( rWindowManager ), m_rCtrl( rCtrl ),
m_rLayout( rLayout ), m_direction( direction ), m_cmdOutStill( this ),
m_cmdStillOut( this ),
m_cmdStillStill( this ),
}
-void CtrlResize::changeCursor( Direction_t direction ) const
+void CtrlResize::changeCursor( WindowManager::Direction_t direction ) const
{
OSFactory *pOsFactory = OSFactory::instance( getIntf() );
- if( direction == kResizeSE )
+ if( direction == WindowManager::kResizeSE )
pOsFactory->changeCursor( OSFactory::kResizeNWSE );
- else if( direction == kResizeS )
+ else if( direction == WindowManager::kResizeS )
pOsFactory->changeCursor( OSFactory::kResizeNS );
- else if( direction == kResizeE )
+ else if( direction == WindowManager::kResizeE )
pOsFactory->changeCursor( OSFactory::kResizeWE );
- else if( direction == kNone )
+ else if( direction == WindowManager::kNone )
pOsFactory->changeCursor( OSFactory::kDefaultArrow );
}
void CtrlResize::CmdStillOut::execute()
{
- m_pParent->changeCursor( kNone );
+ m_pParent->changeCursor( WindowManager::kNone );
}
m_pParent->m_width = m_pParent->m_rLayout.getWidth();
m_pParent->m_height = m_pParent->m_rLayout.getHeight();
+
+ m_pParent->m_rWindowManager.startResize( m_pParent->m_rLayout,
+ m_pParent->m_direction);
}
m_pParent->changeCursor( m_pParent->m_direction );
m_pParent->releaseMouse();
+
+ m_pParent->m_rWindowManager.stopResize();
}
m_pParent->changeCursor( m_pParent->m_direction );
int newWidth = m_pParent->m_width;
+ newWidth += pEvtMotion->getXPos() - m_pParent->m_xPos;
int newHeight = m_pParent->m_height;
- if( m_pParent->m_direction != kResizeS )
- newWidth += pEvtMotion->getXPos() - m_pParent->m_xPos;
- if( m_pParent->m_direction != kResizeE )
- newHeight += pEvtMotion->getYPos() - m_pParent->m_yPos;
+ newHeight += pEvtMotion->getYPos() - m_pParent->m_yPos;
- // Create a resize command
+ // Create a resize command, instead of calling the window manager directly.
+ // Thanks to this trick, the duplicate resizing commands will be trashed
+ // in the asynchronous queue, thus making resizing faster
CmdGeneric *pCmd = new CmdResize( m_pParent->getIntf(),
+ m_pParent->m_rWindowManager,
m_pParent->m_rLayout,
newWidth, newHeight );
// Push the command in the asynchronous command queue
- AsyncQueue *pQueue = AsyncQueue::instance( m_pParent->getIntf() );
+ AsyncQueue *pQueue = AsyncQueue::instance( getIntf() );
pQueue->push( CmdGenericPtr( pCmd ) );
}
#include "ctrl_flat.hpp"
#include "../commands/cmd_generic.hpp"
+#include "../src/window_manager.hpp"
#include "../utils/fsm.hpp"
+class WindowManager;
+
/// Control decorator for resizing windows
class CtrlResize: public CtrlFlat
{
public:
- enum Direction_t
- {
- kResizeE, // East
- kResizeSE, // South-East
- kResizeS, // South
- kNone // Reserved for internal use
- };
-
- CtrlResize( intf_thread_t *pIntf, CtrlFlat &rCtrl,
- GenericLayout &rLayout, const UString &rHelp,
- VarBool *pVisible, Direction_t direction );
+ CtrlResize( intf_thread_t *pIntf, WindowManager &rWindowManager,
+ CtrlFlat &rCtrl, GenericLayout &rLayout,
+ const UString &rHelp, VarBool *pVisible,
+ WindowManager::Direction_t direction );
virtual ~CtrlResize() {}
/// Handle an event
private:
FSM m_fsm;
+ /// Window manager
+ WindowManager &m_rWindowManager;
/// Decorated CtrlFlat
CtrlFlat &m_rCtrl;
/// The layout resized by this control
/// Position of the click that started the resizing
int m_xPos, m_yPos;
/// Direction of the resizing
- Direction_t m_direction;
+ WindowManager::Direction_t m_direction;
/// Change the cursor, based on the given direction
- void changeCursor( Direction_t direction ) const;
+ void changeCursor( WindowManager::Direction_t direction ) const;
/// Callback objects
DEFINE_CALLBACK( CtrlResize, OutStill )
#include "../src/vout_window.hpp"
#include "../src/os_graphics.hpp"
#include "../src/vlcproc.hpp"
+#include "../src/window_manager.hpp"
#include "../commands/async_queue.hpp"
#include "../commands/cmd_resize.hpp"
int newHeight = ((VarBox&)rVoutSize).getHeight() + m_yShift;
// Create a resize command
- CmdGeneric *pCmd = new CmdResize( getIntf(), m_rLayout, newWidth,
- newHeight );
+ // FIXME: this way of getting the window manager kind of sucks
+ WindowManager &rWindowManager =
+ getIntf()->p_sys->p_theme->getWindowManager();
+ rWindowManager.startResize( m_rLayout, WindowManager::kResizeSE );
+ CmdGeneric *pCmd = new CmdResize( getIntf(), rWindowManager,
+ m_rLayout, newWidth, newHeight );
// Push the command in the asynchronous command queue
AsyncQueue *pQueue = AsyncQueue::instance( getIntf() );
pQueue->push( CmdGenericPtr( pCmd ) );
+
+ // FIXME: this should be a command too
+ rWindowManager.stopResize();
}
#include "../src/generic_layout.hpp"
#include "../src/popup.hpp"
#include "../src/theme.hpp"
+#include "../src/window_manager.hpp"
#include "../commands/cmd_generic.hpp"
#include "../controls/ctrl_button.hpp"
#include "../controls/ctrl_checkbox.hpp"
}
m_pTheme->m_curves.push_back( BezierPtr( pCurve ) );
- Anchor *pAnc = new Anchor( getIntf(), rData.m_xPos, rData.m_yPos,
- rData.m_range, rData.m_priority,
+ // Compute the position of the anchor
+ const Position pos = makePosition( rData.m_leftTop, rData.m_leftTop,
+ rData.m_xPos, rData.m_yPos,
+ pCurve->getWidth(),
+ pCurve->getHeight(), *pLayout );
+
+ Anchor *pAnc = new Anchor( getIntf(), pos, rData.m_range, rData.m_priority,
*pCurve, *pLayout );
pLayout->addAnchor( pAnc );
}
}
else if( rData.m_actionId == "resizeS" )
{
- CtrlResize *pResize = new CtrlResize( getIntf(), *pImage, *pLayout,
+ CtrlResize *pResize = new CtrlResize( getIntf(),
+ m_pTheme->getWindowManager(), *pImage, *pLayout,
UString( getIntf(), rData.m_help.c_str() ), pVisible,
- CtrlResize::kResizeS );
+ WindowManager::kResizeS );
pLayout->addControl( pResize, pos, rData.m_layer );
}
else if( rData.m_actionId == "resizeE" )
{
- CtrlResize *pResize = new CtrlResize( getIntf(), *pImage, *pLayout,
+ CtrlResize *pResize = new CtrlResize( getIntf(),
+ m_pTheme->getWindowManager(), *pImage, *pLayout,
UString( getIntf(), rData.m_help.c_str() ), pVisible,
- CtrlResize::kResizeE );
+ WindowManager::kResizeE );
pLayout->addControl( pResize, pos, rData.m_layer );
}
else if( rData.m_actionId == "resizeSE" )
{
- CtrlResize *pResize = new CtrlResize( getIntf(), *pImage, *pLayout,
+ CtrlResize *pResize = new CtrlResize( getIntf(),
+ m_pTheme->getWindowManager(), *pImage, *pLayout,
UString( getIntf(), rData.m_help.c_str() ), pVisible,
- CtrlResize::kResizeSE );
+ WindowManager::kResizeSE );
pLayout->addControl( pResize, pos, rData.m_layer );
}
else
MenuSeparator pos:int popupId:string
Window id:string xPos:int yPos:int visible:bool dragDrop:bool playOnDrop:bool
Layout id:string width:int height:int minWidth:int maxWidth:int minHeight:int maxHeight:int windowId:string
-Anchor xPos:int yPos:int range:int priority:int points:string layoutId:string
+Anchor xPos:int yPos:int leftTop:string range:int priority:int points:string layoutId:string
Button id:string xPos:int yPos:int leftTop:string rightBottom:string visible:string upId:string downId:string overId:string actionId:string tooltip:string help:string layer:int windowId:string layoutId:string
Checkbox id:string xPos:int yPos:int leftTop:string rightBottom:string visible:string up1Id:string down1Id:string over1Id:string up2Id:string down2Id:string over2Id:string state:string action1:string action2:string tooltip1:string tooltip2:string help:string layer:int windowId:string layoutId:string
Image id:string xPos:int yPos:int leftTop:string rightBottom:string visible:string bmpId:string actionId:string action2Id:string resize:string help:string layer:int windowId:string layoutId:string
/// Type definition
struct Anchor
{
- Anchor( int xPos, int yPos, int range, int priority, const string & points, const string & layoutId ):
-m_xPos( xPos ), m_yPos( yPos ), m_range( range ), m_priority( priority ), m_points( points ), m_layoutId( layoutId ) {}
+ Anchor( int xPos, int yPos, const string & leftTop, int range, int priority, const string & points, const string & layoutId ):
+m_xPos( xPos ), m_yPos( yPos ), m_leftTop( leftTop ), m_range( range ), m_priority( priority ), m_points( points ), m_layoutId( layoutId ) {}
int m_xPos;
int m_yPos;
+ string m_leftTop;
int m_range;
int m_priority;
string m_points;
RequireDefault( "priority" );
CheckDefault( "x", "0" );
CheckDefault( "y", "0" );
+ CheckDefault( "lefttop", "lefttop" );
CheckDefault( "points", "(0,0)" );
CheckDefault( "range", "10" );
const BuilderData::Anchor anchor( atoi( attr["x"] ) + m_xOffset,
- atoi( attr["y"] ) + m_yOffset, atoi( attr["range"] ),
- atoi( attr["priority"] ), attr["points"], m_curLayoutId );
+ atoi( attr["y"] ) + m_yOffset, attr["lefttop"],
+ atoi( attr["range"] ), atoi( attr["priority"] ),
+ attr["points"], m_curLayoutId );
m_pData->m_listAnchor.push_back( anchor );
}
#include "skin_common.hpp"
#include "generic_layout.hpp"
#include "../utils/bezier.hpp"
+#include "../utils/position.hpp"
/// Class for the windows anchors
class Anchor: public SkinObject
{
public:
- Anchor( intf_thread_t *pIntf, int xPos, int yPos, int range,
+ Anchor( intf_thread_t *pIntf, const Position &rPosition, int range,
int priority, const Bezier &rCurve, GenericLayout &rLayout ):
- SkinObject( pIntf ), m_xPos( xPos ), m_yPos( yPos ),
+ SkinObject( pIntf ), m_position( rPosition ),
m_rCurve( rCurve ), m_range( range ), m_priority( priority ),
m_rLayout( rLayout ) {}
virtual ~Anchor() {}
- /// Return true if the given anchor is hanged by this one
- /// Two conditions are required:
- /// - the other anchor must be in position of anchoring (as defined
- /// by canHang())
- /// - the priority of the other anchor must be lower than this one's
+ /**
+ * Return true if the given anchor is hanged by this one
+ * Two conditions are required:
+ * - the other anchor must be in position of anchoring (as defined
+ * by canHang())
+ * - the priority of the other anchor must be lower than this one's
+ */
bool isHanging( const Anchor &rOther ) const;
- /// Return true if the other anchor, moved by the (xOffset, yOffset)
- /// vector, is "hangable" by this one (i.e. if it is in its range of
- /// action), else return false.
- /// When the function returns true, the xOffset and yOffset parameters
- /// are modified to indicate the position that the other anchor would
- /// take if hanged by this one (this position is calculated to minimize
- /// the difference with the old xOffset and yOffset, so that the window
- /// doesn't "jump" in a strange way).
+ /**
+ * Return true if the other anchor, moved by the (xOffset, yOffset)
+ * vector, is "hangable" by this one (i.e. if it is in its range of
+ * action), else return false.
+ * When the function returns true, the xOffset and yOffset parameters
+ * are modified to indicate the position that the other anchor would
+ * take if hanged by this one (this position is calculated to minimize
+ * the difference with the old xOffset and yOffset, so that the window
+ * doesn't "jump" in a strange way).
+ */
bool canHang( const Anchor &rOther, int &xOffset, int &yOffset ) const;
// Indicate whether this anchor is reduced to a single point
bool isPoint() const { return m_rCurve.getNbCtrlPoints() == 1; }
// Getters
- int getXPosAbs() const { return (m_xPos + m_rLayout.getLeft()); }
- int getYPosAbs() const { return (m_yPos + m_rLayout.getTop()); }
+ const Position & getPosition() const { return m_position; }
+
+ int getXPosAbs() const
+ {
+ return (m_position.getLeft() + m_rLayout.getLeft());
+ }
+
+ int getYPosAbs() const
+ {
+ return (m_position.getTop() + m_rLayout.getTop());
+ }
private:
- /// Coordinates relative to the window
- int m_xPos, m_yPos;
+ /// Position in the layout
+ Position m_position;
/// Curve of the anchor
const Bezier &m_rCurve;
/// Priority
int m_priority;
- /// Parent window
+ /// Parent layout
GenericLayout &m_rLayout;
};
void GenericLayout::resize( int width, int height )
{
- // Check boundaries
- if( width < m_minWidth )
- {
- width = m_minWidth;
- }
- if( width > m_maxWidth )
- {
- width = m_maxWidth;
- }
- if( height < m_minHeight )
- {
- height = m_minHeight;
- }
- if( height > m_maxHeight )
- {
- height = m_maxHeight;
- }
-
- if( width == m_width && height == m_height )
- {
- return;
- }
-
// Update the window size
m_width = width;
m_height = height;
#include "os_factory.hpp"
#include "anchor.hpp"
#include "tooltip.hpp"
+#include "var_manager.hpp"
#include "../utils/position.hpp"
-#include "../src/var_manager.hpp"
WindowManager::WindowManager( intf_thread_t *pIntf ):
- SkinObject( pIntf ), m_magnet( 0 ), m_pTooltip( NULL ), m_pPopup( NULL )
+ SkinObject( pIntf ), m_magnet( 0 ), m_direction( kNone ),
+ m_pTooltip( NULL ), m_pPopup( NULL )
{
// Create and register a variable for the "on top" status
VarManager *pVarManager = VarManager::instance( getIntf() );
}
+void WindowManager::startResize( GenericLayout &rLayout, Direction_t direction )
+{
+ m_direction = direction;
+
+ // Rebuild the set of moving windows.
+ // From the resized window, we only take into account the anchors which
+ // are mobile with the current type of resizing, and that are hanging a
+ // window. The hanged windows will come will all their dependencies.
+
+ m_resizeMovingE.clear();
+ m_resizeMovingS.clear();
+ m_resizeMovingSE.clear();
+
+ WinSet_t::const_iterator itWin;
+ AncList_t::const_iterator itAnc1, itAnc2;
+ // Get the anchors of the layout
+ const AncList_t &ancList1 = rLayout.getAnchorList();
+
+ // Iterate through all the hanged windows
+ for( itWin = m_dependencies[rLayout.getWindow()].begin();
+ itWin != m_dependencies[rLayout.getWindow()].end(); itWin++ )
+ {
+ // Now, check for anchoring between the 2 windows
+ const AncList_t &ancList2 =
+ (*itWin)->getActiveLayout().getAnchorList();
+ for( itAnc1 = ancList1.begin(); itAnc1 != ancList1.end(); itAnc1++ )
+ {
+ for( itAnc2 = ancList2.begin();
+ itAnc2 != ancList2.end(); itAnc2++ )
+ {
+ if( (*itAnc1)->isHanging( **itAnc2 ) )
+ {
+ // Add the dependencies of the hanged window to one of the
+ // lists of moving windows
+ Position::Ref_t aRefPos =
+ (*itAnc1)->getPosition().getRefLeftTop();
+ if( aRefPos == Position::kRightTop )
+ buildDependSet( m_resizeMovingE, *itWin );
+ else if( aRefPos == Position::kLeftBottom )
+ buildDependSet( m_resizeMovingS, *itWin );
+ else if( aRefPos == Position::kRightBottom )
+ buildDependSet( m_resizeMovingSE, *itWin );
+ break;
+ }
+ }
+ }
+ }
+
+ // The checkAnchors() method will need to have m_movingWindows properly set
+ // so let's insert in it the contents of the other sets
+ m_movingWindows.clear();
+ m_movingWindows.insert( rLayout.getWindow() );
+ m_movingWindows.insert( m_resizeMovingE.begin(), m_resizeMovingE.end() );
+ m_movingWindows.insert( m_resizeMovingS.begin(), m_resizeMovingS.end() );
+ m_movingWindows.insert( m_resizeMovingSE.begin(), m_resizeMovingSE.end() );
+}
+
+
+void WindowManager::stopResize()
+{
+ // Nothing different from stopMove(), luckily
+ stopMove();
+}
+
+
+void WindowManager::resize( GenericLayout &rLayout,
+ int width, int height ) const
+{
+ // TODO: handle anchored windows
+ // Compute the real resizing offset
+ int xOffset = width - rLayout.getWidth();
+ int yOffset = height - rLayout.getHeight();
+
+ // Check anchoring; this can change the values of xOffset and yOffset
+ checkAnchors( rLayout.getWindow(), xOffset, yOffset );
+ if( m_direction == kResizeS )
+ xOffset = 0;
+ if( m_direction == kResizeE )
+ yOffset = 0;
+
+ int newWidth = rLayout.getWidth() + xOffset;
+ int newHeight = rLayout.getHeight() + yOffset;
+
+ // Check boundaries
+ if( newWidth < rLayout.getMinWidth() )
+ {
+ newWidth = rLayout.getMinWidth();
+ }
+ if( newWidth > rLayout.getMaxWidth() )
+ {
+ newWidth = rLayout.getMaxWidth();
+ }
+ if( newHeight < rLayout.getMinHeight() )
+ {
+ newHeight = rLayout.getMinHeight();
+ }
+ if( newHeight > rLayout.getMaxHeight() )
+ {
+ newHeight = rLayout.getMaxHeight();
+ }
+
+ if( newWidth == rLayout.getWidth() && newHeight == rLayout.getHeight() )
+ {
+ return;
+ }
+
+ // New offset, after the last corrections
+ int xNewOffset = newWidth - rLayout.getWidth();
+ int yNewOffset = newHeight - rLayout.getHeight();
+
+ // Do the actual resizing
+ rLayout.resize( newWidth, newHeight );
+
+ // Move all the anchored windows
+ WinSet_t::const_iterator it;
+ if( m_direction == kResizeE ||
+ m_direction == kResizeSE )
+ {
+ for( it = m_resizeMovingE.begin(); it != m_resizeMovingE.end(); it++ )
+ {
+ (*it)->move( (*it)->getLeft() + xNewOffset,
+ (*it)->getTop() );
+ }
+ }
+ if( m_direction == kResizeE ||
+ m_direction == kResizeSE )
+ {
+ for( it = m_resizeMovingS.begin(); it != m_resizeMovingS.end(); it++ )
+ {
+ (*it)->move( (*it)->getLeft(),
+ (*it)->getTop( )+ yNewOffset );
+ }
+ }
+ if( m_direction == kResizeE ||
+ m_direction == kResizeS ||
+ m_direction == kResizeSE )
+ {
+ for( it = m_resizeMovingSE.begin(); it != m_resizeMovingSE.end(); it++ )
+ {
+ (*it)->move( (*it)->getLeft() + xNewOffset,
+ (*it)->getTop() + yNewOffset );
+ }
+ }
+}
+
+
void WindowManager::synchVisibility() const
{
WinSet_t::const_iterator it;
{
// When the theme is opened for the first time,
// only show the window if set as visible in the XML
- if ((*it)->isVisible() || !firstTime)
+ if( (*it)->isVisible() || !firstTime )
{
(*it)->show();
}
}
else
{
- msg_Warn( getIntf(), "tooltip already created!");
+ msg_Warn( getIntf(), "tooltip already created!" );
}
}
class WindowManager: public SkinObject
{
public:
+ /// Direction of the resizing
+ enum Direction_t
+ {
+ kResizeE, // East
+ kResizeSE, // South-East
+ kResizeS, // South
+ kNone // Reserved for internal use
+ };
+
/// Constructor
WindowManager( intf_thread_t *pIntf);
/// Remove a previously registered window
void unregisterWindow( TopWindow &rWindow );
- /// Tell the window manager that a move is initiated for pWindow.
+ /// Tell the window manager that a move is initiated for rWindow
void startMove( TopWindow &rWindow );
- /// Tell the window manager that the current move ended.
+ /// Tell the window manager that the current move ended
void stopMove();
- /// Move the pWindow window to (left, top), and move all its
- /// anchored windows.
- /// If a new anchoring is detected, the windows will move accordingly.
+ /**
+ * Move the rWindow window to (left, top), and move all its
+ * anchored windows.
+ * If a new anchoring is detected, the windows will move accordingly.
+ */
void move( TopWindow &rWindow, int left, int top ) const;
+ /// Tell the window manager that a resize is initiated for rWindow
+ void startResize( GenericLayout &rLayout, Direction_t direction );
+
+ /// Tell the window manager that the current resizing ended
+ void stopResize();
+
+ /**
+ * Resize the rWindow window to (width, height), and move all its
+ * anchored windows, if some anchors are moved during the resizing.
+ * If a new anchoring is detected, the windows will move (or resize)
+ * accordingly.
+ */
+ void resize( GenericLayout &rLayout, int width, int height ) const;
+
/// Raise all the registered windows
void raiseAll() const;
/// Show all the registered windows
- void showAll(bool firstTime = false) const;
+ void showAll( bool firstTime = false ) const;
/// Hide all the registered windows
void hideAll() const;
/// Store the moving windows; this set is updated at every start of
/// move.
WinSet_t m_movingWindows;
+ /**
+ * Store the moving windows in the context of resizing
+ * These sets are updated at every start of move
+ */
+ //@{
+ WinSet_t m_resizeMovingE;
+ WinSet_t m_resizeMovingS;
+ WinSet_t m_resizeMovingSE;
+ //@}
/// Indicate whether the windows are currently on top
VariablePtr m_cVarOnTop;
/// Magnetism of the screen edges (= scope of action)
int m_alpha;
/// Alpha value of the moving windows
int m_moveAlpha;
+ /// Direction of the current resizing
+ Direction_t m_direction;
/// Tooltip
Tooltip *m_pTooltip;
/// Active popup, if any
/// Get the size of the rectangle
int getWidth() const;
int getHeight() const;
+ /// Get the reference corners
+ Ref_t getRefLeftTop() const { return m_refLeftTop; }
+ Ref_t getRefRightBottom() const { return m_refRighBottom; }
private:
/// Position and reference edge/corner
<!ATTLIST Anchor
x CDATA "0"
y CDATA "0"
+ lefttop CDATA "lefttop"
priority CDATA #REQUIRED
points CDATA "(0,0)"
range CDATA "10"
projects / vlc / commitdiff