dbaccess/source/ui/inc/JoinTableView.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19 #ifndef INCLUDED_DBACCESS_SOURCE_UI_INC_JOINTABLEVIEW_HXX
  20 #define INCLUDED_DBACCESS_SOURCE_UI_INC_JOINTABLEVIEW_HXX
  21
  22 #include <vcl/window.hxx>
  23 #include <vcl/timer.hxx>
  24 #include <vcl/idle.hxx>
  25 #include <vcl/scrbar.hxx>
  26 #include <vcl/vclptr.hxx>
  27 #include <svtools/transfer.hxx>
  28
  29 #include "callbacks.hxx"
  30 #include "TableConnectionData.hxx"
  31 #include "TableWindowData.hxx"
  32
  33 #include <map>
  34 #include <vector>
  35
  36 struct AcceptDropEvent;
  37 struct ExecuteDropEvent;
  38 class SfxUndoAction;
  39
  40 namespace dbaui
  41 {
  42     class OTableConnection;
  43     class OTableWindow;
  44     struct OJoinExchangeData;
  45     class OJoinDesignView;
  46     class OTableWindowData;
  47     class OJoinDesignViewAccess;
  48
  49     // this class conatins only the scrollbars to avoid that
  50     // the tablewindows clip the scrollbars
  51     class OJoinTableView;
  52     class OScrollWindowHelper : public vcl::Window
  53     {
  54         VclPtr<ScrollBar>          m_aHScrollBar;
  55         VclPtr<ScrollBar>          m_aVScrollBar;
  56         VclPtr<vcl::Window>        m_pCornerWindow;
  57         VclPtr<OJoinTableView>     m_pTableView;
  58
  59     protected:
  60         virtual void Resize() override;
  61
  62     public:
  63         OScrollWindowHelper( vcl::Window* pParent);
  64         virtual ~OScrollWindowHelper();
  65         virtual void dispose() override;
  66
  67         void setTableView(OJoinTableView* _pTableView);
  68
  69         void resetRange(const Point& _aSize);
  70
  71         // own methods
  72         ScrollBar& GetHScrollBar() { return *m_aHScrollBar.get(); }
  73         ScrollBar& GetVScrollBar() { return *m_aVScrollBar.get(); }
  74     };
  75
  76
  77     class OJoinTableView : public vcl::Window,
  78                            public IDragTransferableListener,
  79                            public DropTargetHelper
  80     {
  81         friend class OJoinMoveTabWinUndoAct;
  82
  83     public:
  84         typedef std::map<OUString, VclPtr<OTableWindow> > OTableWindowMap;
  85
  86     private:
  87         OTableWindowMap     m_aTableMap;
  88         ::std::vector<VclPtr<OTableConnection> >    m_vTableConnection;
  89
  90         Idle                m_aDragScrollIdle;
  91         Rectangle           m_aDragRect;
  92         Rectangle           m_aSizingRect;
  93         Point               m_aDragOffset;
  94         Point               m_aScrollOffset;
  95         Point               m_ptPrevDraggingPos;
  96         Size                m_aOutputSize;
  97
  98
  99         VclPtr<OTableWindow>           m_pDragWin;
 100         VclPtr<OTableWindow>           m_pSizingWin;
 101         VclPtr<OTableConnection>       m_pSelectedConn;
 102
 103
 104         bool                    m_bTrackingInitiallyMoved;
 105
 106         DECL_LINK_TYPED(OnDragScrollTimer, Idle*, void);
 107
 108     protected:
 109         VclPtr<OTableWindow>               m_pLastFocusTabWin;
 110         VclPtr<OJoinDesignView>            m_pView;
 111         OJoinDesignViewAccess*      m_pAccessible;
 112
 113     public:
 114         OJoinTableView( vcl::Window* pParent, OJoinDesignView* pView );
 115         virtual ~OJoinTableView();
 116         virtual void dispose() override;
 117
 118         // window override
 119         virtual void StateChanged( StateChangedType nStateChange ) override;
 120         virtual void GetFocus() override;
 121         virtual void LoseFocus() override;
 122         virtual void KeyInput( const KeyEvent& rEvt ) override;
 123         // Accessibility
 124         virtual css::uno::Reference< css::accessibility::XAccessible > CreateAccessible() override;
 125
 126         // own methods
 127         ScrollBar& GetHScrollBar() { return static_cast<OScrollWindowHelper*>(GetParent())->GetHScrollBar(); }
 128         ScrollBar& GetVScrollBar() { return static_cast<OScrollWindowHelper*>(GetParent())->GetVScrollBar(); }
 129         DECL_LINK_TYPED( ScrollHdl, ScrollBar*, void );
 130
 131         void DrawConnections(vcl::RenderContext& rRenderContext, const Rectangle& rRect);
 132         void InvalidateConnections();
 133
 134         void BeginChildMove( OTableWindow* pTabWin, const Point& rMousePos );
 135         void BeginChildSizing( OTableWindow* pTabWin, const Pointer& rPointer );
 136
 137         void NotifyTitleClicked( OTableWindow* pTabWin, const Point& rMousePos );
 138
 139         virtual void AddTabWin(const OUString& _rComposedName, const OUString& rWinName, bool bNewTable = false);
 140         virtual void RemoveTabWin( OTableWindow* pTabWin );
 141
 142         // hide all TabWins (does NOT delete them; they are put in an UNDO action)
 143         void HideTabWins();
 144
 145         virtual void AddConnection(const OJoinExchangeData& jxdSource, const OJoinExchangeData& jxdDest) = 0;
 146
 147         /** RemoveConnection allows to remove connections from join table view
 148
 149             it implies that the same as addConnection
 150
 151             @param  rConnection the connection which should be removed
 152             @param  bDelete     when true then the connection will be deleted
 153
 154             @return an iterator to next valid connection, so it can be used in any loop
 155         */
 156         virtual bool RemoveConnection(VclPtr<OTableConnection>& rConnection, bool bDelete);
 157
 158         /** allows to add new connections to join table view
 159
 160             it implies an invalidation of the features ID_BROWSER_ADDTABLE and
 161             SID_RELATION_ADD_RELATION also the modified flag will be set to true
 162
 163             @param  _pConnection the connection which should be added
 164             @param  _bAddData    when true then the data should also be appended
 165         */
 166         void addConnection(OTableConnection* _pConnection,bool _bAddData = true);
 167
 168         bool ScrollPane( long nDelta, bool bHoriz, bool bPaintScrollBars );
 169         sal_uLong GetTabWinCount();
 170         const Point& GetScrollOffset() const { return m_aScrollOffset; }
 171
 172         OJoinDesignView* getDesignView() const { return m_pView; }
 173         OTableWindow* GetTabWindow( const OUString& rName );
 174
 175         VclPtr<OTableConnection>& GetSelectedConn() { return m_pSelectedConn; }
 176         /** @note NULL is explicitly allowed (then no-op) */
 177         void DeselectConn(OTableConnection* pConn);
 178         void SelectConn(OTableConnection* pConn);
 179
 180         OTableWindowMap& GetTabWinMap() { return m_aTableMap; }
 181
 182         /** gives a read only access to the connection vector
 183         */
 184         const ::std::vector<VclPtr<OTableConnection> >& getTableConnections() const { return m_vTableConnection; }
 185
 186         bool ExistsAConn(const OTableWindow* pFromWin) const;
 187
 188         /** search for all connections of a table
 189
 190             @param  _pFromWin   the table for which connections should be found
 191             @return an iterator which can be used to travel all connections of the table
 192         */
 193         ::std::vector<VclPtr<OTableConnection> >::const_iterator getTableConnections(const OTableWindow* _pFromWin) const;
 194
 195         /** how many connection belongs to single table
 196
 197             @param  _pFromWin the table for which connections should be found
 198             @return the count of connections which belongs to this table
 199         */
 200         sal_Int32 getConnectionCount(const OTableWindow* _pFromWin) const;
 201
 202         OTableConnection* GetTabConn(const OTableWindow* pLhs,const OTableWindow* pRhs,bool _bSupressCrossOrNaturalJoin = false,const OTableConnection* _rpFirstAfter = nullptr) const;
 203
 204         /** clear the window map and connection vector without destroying it
 205
 206             that means that the data of the windows and connection will be
 207             untouched
 208          */
 209         void clearLayoutInformation();
 210
 211         /** set the focus to that tab win which most recently had it
 212             (or to the first available one) **/
 213         void GrabTabWinFocus();
 214
 215         /** take all WinData and ConnData from the document and create the
 216             corresponding Wins and Conns */
 217         virtual void ReSync() { }
 218
 219         /** Hart deletion
 220
 221             That means that all Conns and Wins are deleted from their respective
 222             lists and the corresponding Datas removed from the document */
 223         virtual void ClearAll();
 224
 225         /** @note used by AddTabDlg to see if more tables can be added */
 226         virtual bool IsAddAllowed();
 227         virtual bool PreNotify(NotifyEvent& rNEvt) override;
 228
 229         // DnD stuff
 230         virtual sal_Int8 AcceptDrop( const AcceptDropEvent& rEvt ) override;
 231         virtual sal_Int8 ExecuteDrop( const ExecuteDropEvent& rEvt ) override;
 232
 233         /** @note can be used for special ui handling after d&d */
 234         virtual void lookForUiActivities();
 235
 236         /** Hook that is called after moving/resizing TabWins
 237
 238             The position is 'virtual': the container has a virtual area of
 239             which only a part - changeable by scroll bar - is visible.
 240             Therefore: ptOldPosition is always positive, even if it represents
 241             a point with a negative physical ordinate above the visible area
 242
 243             @note The standard implementation just passes the new data to the
 244                   Wins
 245          */
 246         void TabWinMoved(OTableWindow* ptWhich, const Point& ptOldPosition);
 247
 248         void TabWinSized(OTableWindow* ptWhich, const Point& ptOldPosition, const Size& szOldSize);
 249
 250         void modified();
 251
 252         /** check if the given window is visible.
 253
 254             @param _rPoint  The Point to check
 255             @param _rSize   The Size to be check as well
 256             @return true if the area is visible, false otherwise
 257         */
 258         bool isMovementAllowed(const Point& _rPoint,const Size& _rSize);
 259
 260         const Size& getRealOutputSize() const { return m_aOutputSize; }
 261
 262         virtual void EnsureVisible(const OTableWindow* _pWin);
 263         void EnsureVisible(const Point& _rPoint,const Size& _rSize);
 264
 265         TTableWindowData::value_type createTableWindowData(const OUString& _rComposedName
 266                                             ,const OUString& _sTableName
 267                                             ,const OUString& _rWinName);
 268
 269     protected:
 270         virtual void MouseButtonUp( const MouseEvent& rEvt ) override;
 271         virtual void MouseButtonDown( const MouseEvent& rEvt ) override;
 272         virtual void Tracking( const TrackingEvent& rTEvt ) override;
 273         virtual void Paint( vcl::RenderContext& rRenderContext, const Rectangle& rRect ) override;
 274         virtual void ConnDoubleClicked(VclPtr<OTableConnection>& rConnection);
 275         void SetDefaultTabWinPosSize( OTableWindow* pTabWin );
 276         virtual void DataChanged( const DataChangedEvent& rDCEvt ) override;
 277
 278         virtual void Resize() override;
 279
 280         virtual void dragFinished( ) override;
 281         /// @note here the physical position (that can be changed while
 282         ///     resizing) is used, as no scrolling can take place while resizing
 283         virtual void Command(const CommandEvent& rEvt) override;
 284
 285         virtual OTableWindowData* CreateImpl(const OUString& _rComposedName
 286                                             ,const OUString& _sTableName
 287                                             ,const OUString& _rWinName);
 288
 289         /** factory method to create table windows
 290
 291             @param _pData The data corresponding to the window.
 292             @return The new TableWindow
 293         */
 294         virtual VclPtr<OTableWindow> createWindow(const TTableWindowData::value_type& _pData) = 0;
 295
 296         /** determines whether the classes Init method should accept a query
 297             name, or only table names */
 298         virtual bool allowQueries() const;
 299
 300         /** called when init fails at the tablewindowdata because the m_xTable
 301             object could not provide columns, but no exception was thrown.
 302             Expected to throw. */
 303         virtual void onNoColumns_throw();
 304
 305         virtual bool supressCrossNaturalJoin(const TTableConnectionData::value_type& _pData) const;
 306
 307     private:
 308         void InitColors();
 309         void ScrollWhileDragging();
 310
 311         /** opens the context menu to delete a connection
 312             @param _aPos the position where the popup menu should appear
 313             @param _pSelConnection the connection which should be deleted
 314         */
 315         void executePopup(const Point& _aPos, VclPtr<OTableConnection>& rSelConnection);
 316
 317         /** invalidates this window without children and set the controller
 318             modified
 319             @param _pAction a possible undo action to add at the controller
 320         */
 321         void invalidateAndModify(SfxUndoAction *_pAction=nullptr);
 322
 323     private:
 324         using Window::Scroll;
 325     };
 326 }
 327 #endif
 328
 329 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */