extends AdaptiveTableDataSetObserver {
13 | /**
14 | * @return Item click listener
15 | */
16 | @Nullable
17 | OnItemClickListener getOnItemClickListener();
18 |
19 | /**
20 | * Set new item click listener
21 | *
22 | * @param onItemClickListener new item click listener
23 | */
24 | void setOnItemClickListener(@Nullable OnItemClickListener onItemClickListener);
25 |
26 | /**
27 | * @return Item long click listener
28 | */
29 | @Nullable
30 | OnItemLongClickListener getOnItemLongClickListener();
31 |
32 | /**
33 | * Set new item long click listener
34 | *
35 | * @param onItemLongClickListener new item long click listener
36 | */
37 | void setOnItemLongClickListener(@Nullable OnItemLongClickListener onItemLongClickListener);
38 |
39 | /**
40 | * Register an observer that is called when changes happen to the data used
41 | * by this adapter.
42 | *
43 | * @param observer the object that gets notified when the data set changes.
44 | */
45 | void registerDataSetObserver(@NonNull AdaptiveTableDataSetObserver observer);
46 |
47 | /**
48 | * Unregister an observer that has previously been registered with this
49 | * adapter via {@link #registerDataSetObserver}.
50 | *
51 | * @param observer the object to unregister.
52 | */
53 | void unregisterDataSetObserver(@NonNull AdaptiveTableDataSetObserver observer);
54 |
55 |
56 | /**
57 | * How many rows are in the data table represented by this Adapter.
58 | *
59 | * @return count of rows with header
60 | */
61 | int getRowCount();
62 |
63 | /**
64 | * How many columns are in the data table represented by this Adapter.
65 | *
66 | * @return count of columns with header
67 | */
68 | int getColumnCount();
69 |
70 | /**
71 | * Called when {@link AdaptiveTableLayout} needs a new ITEM {@link ViewHolder}
72 | *
73 | * @param parent The ViewGroup into which the new View will be added after it is bound to
74 | * an adapter position.
75 | * @return A new ViewHolder that holds a View of the given view type.
76 | * @see #onBindViewHolder(ViewHolder, int, int)
77 | */
78 | @NonNull
79 | VH onCreateItemViewHolder(@NonNull ViewGroup parent);
80 |
81 | /**
82 | * Called when {@link AdaptiveTableLayout} needs a new COLUMN HEADER ITEM {@link ViewHolder}
83 | *
84 | * @param parent The ViewGroup into which the new View will be added after it is bound to
85 | * an adapter position.
86 | * @return A new ViewHolder that holds a View of the given view type.
87 | * @see #onBindHeaderColumnViewHolder(ViewHolder, int)
88 | */
89 | @NonNull
90 | VH onCreateColumnHeaderViewHolder(@NonNull ViewGroup parent);
91 |
92 | /**
93 | * Called when {@link AdaptiveTableLayout} needs a new ROW HEADER ITEM {@link ViewHolder}
94 | *
95 | * @param parent The ViewGroup into which the new View will be added after it is bound to
96 | * an adapter position.
97 | * @return A new ViewHolder that holds a View of the given view type.
98 | * @see #onBindHeaderRowViewHolder(ViewHolder, int)
99 | */
100 | @NonNull
101 | VH onCreateRowHeaderViewHolder(@NonNull ViewGroup parent);
102 |
103 | /**
104 | * Called when {@link AdaptiveTableLayout} needs a new LEFT TOP HEADER ITEM {@link ViewHolder}
105 | *
106 | * @param parent The ViewGroup into which the new View will be added after it is bound to
107 | * an adapter position.
108 | * @return A new ViewHolder that holds a View of the given view type.
109 | * @see #onBindLeftTopHeaderViewHolder(ViewHolder)
110 | */
111 | @NonNull
112 | VH onCreateLeftTopHeaderViewHolder(@NonNull ViewGroup parent);
113 |
114 |
115 | /**
116 | * Called by {@link AdaptiveTableLayout} to display the data at the specified position. This method should
117 | * update the contents of the {@link ViewHolder#getItemView()} to reflect the item at the given
118 | * position.
119 | *
120 | * @param viewHolder The ITEM {@link ViewHolder} which should be updated to represent the contents of the
121 | * item at the given position in the data set.
122 | * @param row The row index of the item within the adapter's data set.
123 | * @param column The column index of the item within the adapter's data set.
124 | */
125 | void onBindViewHolder(@NonNull VH viewHolder, int row, int column);
126 |
127 | /**
128 | * Called by {@link AdaptiveTableLayout} to display the data at the specified position. This method should
129 | * update the contents of the {@link ViewHolder#getItemView()} to reflect the item at the given
130 | * position.
131 | *
132 | * @param viewHolder The COLUMN HEADER ITEM {@link ViewHolder} which should be updated to represent the contents of the
133 | * item at the given position in the data set.
134 | * @param column The column index of the item within the adapter's data set.
135 | */
136 | void onBindHeaderColumnViewHolder(@NonNull VH viewHolder, int column);
137 |
138 | /**
139 | * Called by {@link AdaptiveTableLayout} to display the data at the specified position. This method should
140 | * update the contents of the {@link ViewHolder#getItemView()} to reflect the item at the given
141 | * position.
142 | *
143 | * @param viewHolder The ROW HEADER ITEM {@link ViewHolder} which should be updated to represent the contents of the
144 | * item at the given position in the data set.
145 | * @param row The row index of the item within the adapter's data set.
146 | */
147 | void onBindHeaderRowViewHolder(@NonNull VH viewHolder, int row);
148 |
149 | /**
150 | * Called by {@link AdaptiveTableLayout} to display the data at the specified position. This method should
151 | * update the contents of the {@link ViewHolder#getItemView()} to reflect the item at the given
152 | * position.
153 | *
154 | * @param viewHolder The TOP LEFT HEADER ITEM{@link ViewHolder} which should be updated to represent the contents of the
155 | * item at the given position in the data set.
156 | */
157 | void onBindLeftTopHeaderViewHolder(@NonNull VH viewHolder);
158 |
159 |
160 | /**
161 | * Return the width of the column.
162 | *
163 | * @param column the column index.
164 | * @return The width of the column, in pixels.
165 | */
166 | int getColumnWidth(int column);
167 |
168 |
169 | /**
170 | * Return the header column height.
171 | *
172 | * @return The header height of the columns, in pixels.
173 | */
174 | int getHeaderColumnHeight();
175 |
176 | /**
177 | * Return the height of the row.
178 | *
179 | * @param row the row index.
180 | * @return The height of the row, in pixels.
181 | */
182 | int getRowHeight(int row);
183 |
184 | /**
185 | * Return the header row width.
186 | *
187 | * @return The header width of the rows, in pixels.
188 | */
189 | int getHeaderRowWidth();
190 |
191 | /**
192 | * Called when a view created by this adapter has been recycled.
193 | *
194 | *
A view is recycled when a {@link AdaptiveTableLayout} decides that it no longer
195 | * needs to be attached. This can be because it has
196 | * fallen out of visibility or a set of cached views represented by views still
197 | * attached to the parent RecyclerView. If an item view has large or expensive data
198 | * bound to it such as large bitmaps, this may be a good place to release those
199 | * resources.
200 | *
201 | * {@link AdaptiveTableLayout} calls this method right before clearing ViewHolder's internal data and
202 | * sending it to Recycler.
203 | *
204 | * @param viewHolder The {@link ViewHolder} for the view being recycled
205 | */
206 | void onViewHolderRecycled(@NonNull VH viewHolder);
207 |
208 |
209 | }
210 |
--------------------------------------------------------------------------------
/library/src/main/java/com/cleveroad/adaptivetablelayout/AdaptiveTableDataSetObserver.java:
--------------------------------------------------------------------------------
1 | package com.cleveroad.adaptivetablelayout;
2 |
3 | interface AdaptiveTableDataSetObserver {
4 | /**
5 | * Notify any registered observers that the data set has changed.
6 | * If you change the size of the data set, you must call {@link AdaptiveTableDataSetObserver#notifyLayoutChanged()} instead
7 | */
8 | void notifyDataSetChanged();
9 |
10 | /**
11 | * You must call this when something has changed which has invalidated the layout of this view
12 | * or the size of the data set was changed
13 | */
14 | void notifyLayoutChanged();
15 |
16 | /**
17 | * Notify any registered observers that the item at
18 | * (rowIndex;columnIndex) has changed.
19 | *
20 | * @param rowIndex the row index
21 | * @param columnIndex the column index
22 | */
23 | void notifyItemChanged(int rowIndex, int columnIndex);
24 |
25 | /**
26 | * Notify any registered observers that the row with rowIndex has changed.
27 | *
28 | * @param rowIndex the row index
29 | */
30 | void notifyRowChanged(int rowIndex);
31 |
32 | /**
33 | * Notify any registered observers that the column with columnIndex has changed.
34 | *
35 | * @param columnIndex the column index
36 | */
37 | void notifyColumnChanged(int columnIndex);
38 |
39 |
40 | }
41 |
--------------------------------------------------------------------------------
/library/src/main/java/com/cleveroad/adaptivetablelayout/AdaptiveTableLayoutSettings.java:
--------------------------------------------------------------------------------
1 | package com.cleveroad.adaptivetablelayout;
2 |
3 | /**
4 | * Settings keeper class.
5 | */
6 | class AdaptiveTableLayoutSettings {
7 |
8 | /**
9 | * Layout width
10 | */
11 | private int mLayoutWidth;
12 | /**
13 | * Layout height
14 | */
15 | private int mLayoutHeight;
16 |
17 | private boolean mIsHeaderFixed;
18 |
19 | private int mCellMargin;
20 |
21 | /**
22 | * if true - value of row header fixed to the row. Fixed to the data
23 | * if false - fixed to the number of row. Fixed to the row' number from 0 to n.
24 | */
25 | private boolean mSolidRowHeader;
26 |
27 | /**
28 | * If true, then the table can be edited, otherwise it is impossible
29 | */
30 | private boolean mDragAndDropEnabled;
31 |
32 |
33 | AdaptiveTableLayoutSettings() {
34 | }
35 |
36 | int getLayoutWidth() {
37 | return mLayoutWidth;
38 | }
39 |
40 | AdaptiveTableLayoutSettings setLayoutWidth(int layoutWidth) {
41 | mLayoutWidth = layoutWidth;
42 | return this;
43 | }
44 |
45 | int getLayoutHeight() {
46 | return mLayoutHeight;
47 | }
48 |
49 | AdaptiveTableLayoutSettings setLayoutHeight(int layoutHeight) {
50 | mLayoutHeight = layoutHeight;
51 | return this;
52 | }
53 |
54 | public boolean isHeaderFixed() {
55 | return mIsHeaderFixed;
56 | }
57 |
58 | public AdaptiveTableLayoutSettings setHeaderFixed(boolean headerFixed) {
59 | mIsHeaderFixed = headerFixed;
60 | return this;
61 | }
62 |
63 | public int getCellMargin() {
64 | return mCellMargin;
65 | }
66 |
67 | public AdaptiveTableLayoutSettings setCellMargin(int cellMargin) {
68 | mCellMargin = cellMargin;
69 | return this;
70 | }
71 |
72 | public boolean isSolidRowHeader() {
73 | return mSolidRowHeader;
74 | }
75 |
76 | public AdaptiveTableLayoutSettings setSolidRowHeader(boolean solidRowHeader) {
77 | mSolidRowHeader = solidRowHeader;
78 | return this;
79 | }
80 |
81 | public boolean isDragAndDropEnabled() {
82 | return mDragAndDropEnabled;
83 | }
84 |
85 | public void setDragAndDropEnabled(boolean dragAndDropEnabled) {
86 | mDragAndDropEnabled = dragAndDropEnabled;
87 | }
88 | }
89 |
--------------------------------------------------------------------------------
/library/src/main/java/com/cleveroad/adaptivetablelayout/AdaptiveTableManagerRTL.java:
--------------------------------------------------------------------------------
1 | package com.cleveroad.adaptivetablelayout;
2 |
3 | import android.annotation.TargetApi;
4 | import android.os.Build;
5 |
6 | /**
7 | * same as {@link AdaptiveTableManager}, but support rtl direction
8 | */
9 | @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR1)
10 | class AdaptiveTableManagerRTL extends AdaptiveTableManager {
11 |
12 | private LayoutDirectionHelper mLayoutDirectionHelper;
13 |
14 | AdaptiveTableManagerRTL(LayoutDirectionHelper layoutDirectionHelper) {
15 | mLayoutDirectionHelper = layoutDirectionHelper;
16 | }
17 |
18 | @Override
19 | int getColumnByXWithShift(int x, int shiftEveryStep) {
20 | if (!mLayoutDirectionHelper.isRTL()) {
21 | return super.getColumnByXWithShift(x, shiftEveryStep);
22 | } else {
23 | checkForInit();
24 | int sum = 0;
25 | if (x <= sum) {
26 | return 0;
27 | }
28 | for (int count = getColumnWidths().length, i = 0; i < count; i++) {
29 | int nextSum = sum + getColumnWidths()[i] + shiftEveryStep;
30 | if (x > sum && x < nextSum) {
31 | return i;
32 | } else if (x < nextSum) {
33 | return i - 1;
34 | }
35 | sum = nextSum;
36 | }
37 | return getColumnWidths().length - 1;
38 | }
39 | }
40 | }
41 |
--------------------------------------------------------------------------------
/library/src/main/java/com/cleveroad/adaptivetablelayout/AdaptiveTableState.java:
--------------------------------------------------------------------------------
1 | package com.cleveroad.adaptivetablelayout;
2 |
3 | /**
4 | * Layout state holder.
5 | */
6 | class AdaptiveTableState {
7 |
8 | static final int NO_DRAGGING_POSITION = -1;
9 | /**
10 | * Current scroll position.
11 | */
12 | private int mScrollX;
13 | private int mScrollY;
14 |
15 | /**
16 | * Dragging row flag
17 | */
18 | private boolean mIsRowDragging;
19 |
20 | /**
21 | * Dragging column flag
22 | */
23 | private boolean mIsColumnDragging;
24 |
25 | /**
26 | * Dragging column index
27 | */
28 | private int mColumnDraggingIndex;
29 | /**
30 | * Dragging row index
31 | */
32 | private int mRowDraggingIndex;
33 |
34 |
35 | int getScrollX() {
36 | return mScrollX;
37 | }
38 |
39 | void setScrollX(int scrollX) {
40 | mScrollX = scrollX;
41 | }
42 |
43 | int getScrollY() {
44 | return mScrollY;
45 | }
46 |
47 | void setScrollY(int scrollY) {
48 | mScrollY = scrollY;
49 | }
50 |
51 | boolean isRowDragging() {
52 | return mIsRowDragging;
53 | }
54 |
55 | void setRowDragging(boolean rowDragging, int rowIndex) {
56 | mIsRowDragging = rowDragging;
57 | mRowDraggingIndex = rowIndex;
58 | }
59 |
60 | boolean isColumnDragging() {
61 | return mIsColumnDragging;
62 | }
63 |
64 | void setColumnDragging(boolean columnDragging, int columnIndex) {
65 | mIsColumnDragging = columnDragging;
66 | mColumnDraggingIndex = columnIndex;
67 | }
68 |
69 | boolean isDragging() {
70 | return mIsColumnDragging || mIsRowDragging;
71 | }
72 |
73 | int getColumnDraggingIndex() {
74 | return mColumnDraggingIndex;
75 | }
76 |
77 | int getRowDraggingIndex() {
78 | return mRowDraggingIndex;
79 | }
80 | }
81 |
--------------------------------------------------------------------------------
/library/src/main/java/com/cleveroad/adaptivetablelayout/BaseDataAdaptiveTableLayoutAdapter.java:
--------------------------------------------------------------------------------
1 | package com.cleveroad.adaptivetablelayout;
2 |
3 | public abstract class BaseDataAdaptiveTableLayoutAdapter extends LinkedAdaptiveTableAdapter implements
4 | DataAdaptiveTableLayoutAdapter {
5 |
6 | /**
7 | * @return data matrix
8 | */
9 | protected abstract Object[][] getItems();
10 |
11 | /**
12 | * @return row's headers array
13 | */
14 | protected abstract Object[] getRowHeaders();
15 |
16 | /**
17 | * @return column's headers array
18 | */
19 | protected abstract Object[] getColumnHeaders();
20 |
21 | @Override
22 | public void changeColumns(int columnIndex, int columnToIndex) {
23 | // switch data
24 | switchTwoColumns(columnIndex, columnToIndex);
25 | // switch headers
26 | switchTwoColumnHeaders(columnIndex, columnToIndex);
27 | }
28 |
29 | /**
30 | * Switch 2 columns with data
31 | *
32 | * @param columnIndex column from
33 | * @param columnToIndex column to
34 | */
35 | void switchTwoColumns(int columnIndex, int columnToIndex) {
36 | for (int i = 0; i < getRowCount() - 1; i++) {
37 | Object cellData = getItems()[i][columnToIndex];
38 | getItems()[i][columnToIndex] = getItems()[i][columnIndex];
39 | getItems()[i][columnIndex] = cellData;
40 | }
41 | }
42 |
43 | /**
44 | * Switch 2 columns headers with data
45 | *
46 | * @param columnIndex column header from
47 | * @param columnToIndex column header to
48 | */
49 | void switchTwoColumnHeaders(int columnIndex, int columnToIndex) {
50 | Object cellData = getColumnHeaders()[columnToIndex];
51 | getColumnHeaders()[columnToIndex] = getColumnHeaders()[columnIndex];
52 | getColumnHeaders()[columnIndex] = cellData;
53 | }
54 |
55 | @Override
56 | public void changeRows(int rowIndex, int rowToIndex, boolean solidRowHeader) {
57 | // switch data
58 | switchTwoRows(rowIndex, rowToIndex);
59 | if (solidRowHeader) {
60 | // switch headers
61 | switchTwoRowHeaders(rowIndex, rowToIndex);
62 | }
63 | }
64 |
65 | /**
66 | * Switch 2 rows with data
67 | *
68 | * @param rowIndex row from
69 | * @param rowToIndex row to
70 | */
71 | void switchTwoRows(int rowIndex, int rowToIndex) {
72 | for (int i = 0; i < getItems().length; i++) {
73 | Object cellData = getItems()[rowToIndex][i];
74 | getItems()[rowToIndex][i] = getItems()[rowIndex][i];
75 | getItems()[rowIndex][i] = cellData;
76 | }
77 | }
78 |
79 | /**
80 | * Switch 2 rows headers with data
81 | *
82 | * @param rowIndex row header from
83 | * @param rowToIndex row header to
84 | */
85 | void switchTwoRowHeaders(int rowIndex, int rowToIndex) {
86 | Object cellData = getRowHeaders()[rowToIndex];
87 | getRowHeaders()[rowToIndex] = getRowHeaders()[rowIndex];
88 | getRowHeaders()[rowIndex] = cellData;
89 | }
90 | }
91 |
--------------------------------------------------------------------------------
/library/src/main/java/com/cleveroad/adaptivetablelayout/DataAdaptiveTableLayoutAdapter.java:
--------------------------------------------------------------------------------
1 | package com.cleveroad.adaptivetablelayout;
2 |
3 | import android.os.Bundle;
4 | import android.support.annotation.NonNull;
5 |
6 | interface DataAdaptiveTableLayoutAdapter extends AdaptiveTableAdapter {
7 | /**
8 | * Method calls when need to need to switch 2 columns with each other in the data matrix
9 | *
10 | * @param columnIndex column from
11 | * @param columnToIndex column to
12 | */
13 | void changeColumns(int columnIndex, int columnToIndex);
14 |
15 | /**
16 | * Method calls when need to need to switch 2 rows with each other in the data matrix
17 | *
18 | * @param rowIndex row from
19 | * @param rowToIndex row to
20 | * @param solidRowHeader fixed to the data or to the row number.
21 | */
22 | void changeRows(int rowIndex, int rowToIndex, boolean solidRowHeader);
23 |
24 | void onSaveInstanceState(@NonNull Bundle bundle);
25 |
26 | void onRestoreInstanceState(@NonNull Bundle bundle);
27 | }
28 |
--------------------------------------------------------------------------------
/library/src/main/java/com/cleveroad/adaptivetablelayout/DataSetObserverProxy.java:
--------------------------------------------------------------------------------
1 | package com.cleveroad.adaptivetablelayout;
2 |
3 | class DataSetObserverProxy implements AdaptiveTableDataSetObserver {
4 | private final AdaptiveTableAdapter mAdaptiveTableAdapter;
5 |
6 | DataSetObserverProxy(AdaptiveTableAdapter adaptiveTableAdapter) {
7 | mAdaptiveTableAdapter = adaptiveTableAdapter;
8 | }
9 |
10 | @Override
11 | public void notifyDataSetChanged() {
12 | mAdaptiveTableAdapter.notifyDataSetChanged();
13 | }
14 |
15 | @Override
16 | public void notifyLayoutChanged() {
17 | mAdaptiveTableAdapter.notifyLayoutChanged();
18 | }
19 |
20 | @Override
21 | public void notifyItemChanged(int rowIndex, int columnIndex) {
22 | mAdaptiveTableAdapter.notifyItemChanged(rowIndex, columnIndex);
23 | }
24 |
25 | @Override
26 | public void notifyRowChanged(int rowIndex) {
27 | mAdaptiveTableAdapter.notifyRowChanged(rowIndex);
28 | }
29 |
30 | @Override
31 | public void notifyColumnChanged(int columnIndex) {
32 | mAdaptiveTableAdapter.notifyColumnChanged(columnIndex);
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/library/src/main/java/com/cleveroad/adaptivetablelayout/DragAndDropPoints.java:
--------------------------------------------------------------------------------
1 | package com.cleveroad.adaptivetablelayout;
2 |
3 | import android.graphics.Point;
4 |
5 | /**
6 | * Helps implement dragging feature.
7 | * Contains start, offset and end point in drag and drop mode.
8 | */
9 | class DragAndDropPoints {
10 | /**
11 | * Start dragging touch point
12 | */
13 | private final Point mStart;
14 | /**
15 | * Screen offset (touch position)
16 | */
17 | private final Point mOffset;
18 |
19 | /**
20 | * End dragging touch point
21 | */
22 | private final Point mEnd;
23 |
24 | DragAndDropPoints() {
25 | mStart = new Point();
26 | mOffset = new Point();
27 | mEnd = new Point();
28 | }
29 |
30 | Point getStart() {
31 | return mStart;
32 | }
33 |
34 | Point getOffset() {
35 | return mOffset;
36 | }
37 |
38 | Point getEnd() {
39 | return mEnd;
40 | }
41 |
42 | void setStart(int x, int y) {
43 | mStart.set(x, y);
44 | }
45 |
46 | void setOffset(int x, int y) {
47 | mOffset.set(x, y);
48 | }
49 |
50 | void setEnd(int x, int y) {
51 | mEnd.set(x, y);
52 | }
53 |
54 | }
55 |
--------------------------------------------------------------------------------
/library/src/main/java/com/cleveroad/adaptivetablelayout/DragAndDropScrollRunnable.java:
--------------------------------------------------------------------------------
1 | package com.cleveroad.adaptivetablelayout;
2 |
3 | import android.view.View;
4 |
5 | /**
6 | * Move table layout logic in dragging mode
7 | */
8 | class DragAndDropScrollRunnable implements Runnable {
9 | private View mView;
10 | private boolean isFinished;
11 |
12 | private int mDiffX;
13 | private int mDiffY;
14 |
15 | DragAndDropScrollRunnable(View view) {
16 | mView = view;
17 | isFinished = true;
18 | }
19 |
20 | synchronized void touch(int touchX, int touchY, @ScrollType int orientation) {
21 |
22 | int partOfWidth = mView.getWidth() / 4;
23 | // vertical scroll area (top, bottom)
24 | int partOfHeight = mView.getHeight() / 4;
25 |
26 |
27 | if (orientation == ScrollType.SCROLL_HORIZONTAL) {
28 | if (touchX < partOfWidth) {
29 | // if touch in left horizontal area -> scroll to left
30 | start(touchX - partOfWidth, 0);
31 | } else if (touchX > mView.getWidth() - partOfWidth) {
32 | // if touch in right horizontal area -> scroll to right
33 | start(touchX - mView.getWidth() + partOfWidth, 0);
34 | } else {
35 | // touch between scroll left and right areas.
36 | mDiffX = 0;
37 | mDiffY = 0;
38 | }
39 | } else if (orientation == ScrollType.SCROLL_VERTICAL) {
40 | if (touchY < partOfHeight) {
41 | // if touch in top vertical area -> scroll to top
42 | start(0, touchY - partOfHeight);
43 | } else if (touchY > mView.getHeight() - partOfHeight) {
44 | // if touch in bottom vertical area -> scroll to bottom
45 | start(0, touchY - mView.getHeight() + partOfHeight);
46 | } else {
47 | // touch between scroll top and bottom areas.
48 | mDiffX = 0;
49 | mDiffY = 0;
50 | }
51 | }
52 | }
53 |
54 | private synchronized void start(int diffX, int diffY) {
55 | // save start data
56 | mDiffX = diffX;
57 | mDiffY = diffY;
58 | // check if scrolling in the process
59 | if (isFinished) {
60 | // start scroll
61 | isFinished = false;
62 | mView.post(this);
63 | }
64 | }
65 |
66 | @Override
67 | public void run() {
68 | // scroll speed. Calculated by hand.
69 | int shiftDistanceX = mDiffX / 5;
70 | int shiftDistanceY = mDiffY / 5;
71 |
72 | if ((shiftDistanceX != 0 || shiftDistanceY != 0) && !isFinished) {
73 | // change state
74 | isFinished = false;
75 | // scroll view
76 | mView.scrollBy(shiftDistanceX, shiftDistanceY);
77 | // start self again
78 | mView.post(this);
79 | } else {
80 | // have no shift distance or need to finish.
81 | stop();
82 | }
83 | }
84 |
85 | synchronized void stop() {
86 | // vars to default
87 | mDiffX = 0;
88 | mDiffY = 0;
89 |
90 | // change state
91 | isFinished = true;
92 |
93 | // remove callbacks
94 | mView.removeCallbacks(this);
95 | }
96 |
97 | boolean isFinished() {
98 | return isFinished;
99 | }
100 | }
101 |
--------------------------------------------------------------------------------
/library/src/main/java/com/cleveroad/adaptivetablelayout/LayoutDirection.java:
--------------------------------------------------------------------------------
1 | package com.cleveroad.adaptivetablelayout;
2 |
3 | import android.support.annotation.IntDef;
4 |
5 | import java.lang.annotation.Retention;
6 | import java.lang.annotation.RetentionPolicy;
7 |
8 | @IntDef({
9 | LayoutDirection.LTR,
10 | LayoutDirection.RTL
11 | })
12 | /**
13 | * Type of layout directions. Same values as in android.util.LayoutDirection
14 | * This interface needed because project min API is 16
15 | */
16 | @Retention(RetentionPolicy.SOURCE)
17 | @interface LayoutDirection {
18 | /**
19 | * Top left header
20 | */
21 | int LTR = 0;
22 | /**
23 | * Vertical header
24 | */
25 | int RTL = 1;
26 | }
27 |
--------------------------------------------------------------------------------
/library/src/main/java/com/cleveroad/adaptivetablelayout/LayoutDirectionHelper.java:
--------------------------------------------------------------------------------
1 | package com.cleveroad.adaptivetablelayout;
2 |
3 | /**
4 | * Helper for convenient work with layout direction
5 | */
6 | class LayoutDirectionHelper {
7 | private int mLayoutDirection;
8 |
9 | LayoutDirectionHelper(int direction) {
10 | mLayoutDirection = direction;
11 | }
12 |
13 | private int getLayoutDirection() {
14 | return mLayoutDirection;
15 | }
16 |
17 | void setLayoutDirection(int direction) {
18 | mLayoutDirection = direction;
19 | }
20 |
21 | boolean isRTL() {
22 | return getLayoutDirection() == LayoutDirection.RTL;
23 | }
24 |
25 | }
26 |
--------------------------------------------------------------------------------
/library/src/main/java/com/cleveroad/adaptivetablelayout/LinkedAdaptiveTableAdapter.java:
--------------------------------------------------------------------------------
1 | package com.cleveroad.adaptivetablelayout;
2 |
3 | import android.support.annotation.NonNull;
4 | import android.support.annotation.Nullable;
5 |
6 | import java.util.ArrayList;
7 | import java.util.List;
8 |
9 | /**
10 | * {@inheritDoc}
11 | * Common base class of common implementation for an {@link AdaptiveTableAdapter} that
12 | * can be used in {@link AdaptiveTableLayout}.
13 | */
14 | public abstract class LinkedAdaptiveTableAdapter implements AdaptiveTableAdapter {
15 | protected boolean mIsRtl;
16 | /**
17 | * Set with observers
18 | */
19 | @NonNull
20 | private final List mAdaptiveTableDataSetObservers = new ArrayList<>();
21 |
22 | /**
23 | * Need to throw item click action
24 | */
25 | @Nullable
26 | private OnItemClickListener mOnItemClickListener;
27 |
28 | /**
29 | * Need to throw long item click action
30 | */
31 | @Nullable
32 | private OnItemLongClickListener mOnItemLongClickListener;
33 |
34 | @Override
35 | @Nullable
36 | public OnItemClickListener getOnItemClickListener() {
37 | return mOnItemClickListener;
38 | }
39 |
40 | @Override
41 | public void setOnItemClickListener(@Nullable OnItemClickListener onItemClickListener) {
42 | mOnItemClickListener = onItemClickListener;
43 | }
44 |
45 | @Override
46 | @Nullable
47 | public OnItemLongClickListener getOnItemLongClickListener() {
48 | return mOnItemLongClickListener;
49 | }
50 |
51 | @Override
52 | public void setOnItemLongClickListener(@Nullable OnItemLongClickListener onItemLongClickListener) {
53 | mOnItemLongClickListener = onItemLongClickListener;
54 | }
55 |
56 | @NonNull
57 | public List getAdaptiveTableDataSetObservers() {
58 | return mAdaptiveTableDataSetObservers;
59 | }
60 |
61 | /**
62 | * {@inheritDoc}
63 | *
64 | * @param observer the object that gets notified when the data set changes.
65 | */
66 | @Override
67 | public void registerDataSetObserver(@NonNull AdaptiveTableDataSetObserver observer) {
68 | mAdaptiveTableDataSetObservers.add(observer);
69 | }
70 |
71 | /**
72 | * {@inheritDoc}
73 | *
74 | * @param observer the object to unregister.
75 | */
76 | @Override
77 | public void unregisterDataSetObserver(@NonNull AdaptiveTableDataSetObserver observer) {
78 | mAdaptiveTableDataSetObservers.remove(observer);
79 | }
80 |
81 | /**
82 | * {@inheritDoc}
83 | */
84 | @Override
85 | public void notifyDataSetChanged() {
86 | for (AdaptiveTableDataSetObserver observer : mAdaptiveTableDataSetObservers) {
87 | observer.notifyDataSetChanged();
88 | }
89 | }
90 |
91 | /**
92 | * {@inheritDoc}
93 | *
94 | * @param rowIndex the row index
95 | * @param columnIndex the column index
96 | */
97 | @Override
98 | public void notifyItemChanged(int rowIndex, int columnIndex) {
99 | for (AdaptiveTableDataSetObserver observer : mAdaptiveTableDataSetObservers) {
100 | observer.notifyItemChanged(rowIndex, columnIndex);
101 | }
102 | }
103 |
104 | /**
105 | * {@inheritDoc}
106 | *
107 | * @param rowIndex the row index
108 | */
109 | @Override
110 | public void notifyRowChanged(int rowIndex) {
111 | for (AdaptiveTableDataSetObserver observer : mAdaptiveTableDataSetObservers) {
112 | observer.notifyRowChanged(rowIndex);
113 | }
114 | }
115 |
116 | /**
117 | * {@inheritDoc}
118 | *
119 | * @param columnIndex the column index
120 | */
121 | @Override
122 | public void notifyColumnChanged(int columnIndex) {
123 | for (AdaptiveTableDataSetObserver observer : mAdaptiveTableDataSetObservers) {
124 | observer.notifyColumnChanged(columnIndex);
125 | }
126 | }
127 |
128 | /**
129 | * {@inheritDoc}
130 | */
131 | @Override
132 | public void notifyLayoutChanged() {
133 | for (AdaptiveTableDataSetObserver observer : mAdaptiveTableDataSetObservers) {
134 | observer.notifyLayoutChanged();
135 | }
136 | }
137 |
138 | @Override
139 | public void onViewHolderRecycled(@NonNull VH viewHolder) {
140 | //do something
141 | }
142 |
143 | public boolean isRtl() {
144 | return mIsRtl;
145 | }
146 |
147 | public void setRtl(boolean rtl) {
148 | mIsRtl = rtl;
149 | }
150 | }
151 |
--------------------------------------------------------------------------------
/library/src/main/java/com/cleveroad/adaptivetablelayout/OnItemClickListener.java:
--------------------------------------------------------------------------------
1 | package com.cleveroad.adaptivetablelayout;
2 |
3 | public interface OnItemClickListener {
4 | /**
5 | * Click item callback.
6 | *
7 | * @param row clicked item row
8 | * @param column clicked item column
9 | */
10 | void onItemClick(int row, int column);
11 |
12 | /**
13 | * Click row header item callback
14 | *
15 | * @param row clicked row header
16 | */
17 | void onRowHeaderClick(int row);
18 |
19 | /**
20 | * Click column header item callback
21 | *
22 | * @param column clicked column header
23 | */
24 | void onColumnHeaderClick(int column);
25 |
26 |
27 | /**
28 | * Click left top item callback
29 | */
30 | void onLeftTopHeaderClick();
31 | }
32 |
--------------------------------------------------------------------------------
/library/src/main/java/com/cleveroad/adaptivetablelayout/OnItemLongClickListener.java:
--------------------------------------------------------------------------------
1 | package com.cleveroad.adaptivetablelayout;
2 |
3 | public interface OnItemLongClickListener {
4 | /**
5 | * Long click item callback.
6 | *
7 | * @param row clicked item row
8 | * @param column clicked item column
9 | */
10 | void onItemLongClick(int row, int column);
11 |
12 | /**
13 | * Long click left top item callback
14 | */
15 | void onLeftTopHeaderLongClick();
16 | }
17 |
--------------------------------------------------------------------------------
/library/src/main/java/com/cleveroad/adaptivetablelayout/Recycler.java:
--------------------------------------------------------------------------------
1 | package com.cleveroad.adaptivetablelayout;
2 |
3 | import android.support.annotation.NonNull;
4 | import android.support.annotation.Nullable;
5 | import android.util.SparseArray;
6 |
7 | import java.util.ArrayDeque;
8 | import java.util.Deque;
9 |
10 | /**
11 | * The Recycler facilitates reuse of mViewHolders across layouts.
12 | */
13 | class Recycler {
14 |
15 | private SparseArray> mViewHolders;
16 |
17 | /**
18 | * Constructor
19 | */
20 | @SuppressWarnings("unchecked")
21 | Recycler() {
22 | mViewHolders = new SparseArray<>(3);
23 | }
24 |
25 | /**
26 | * Add a view to the Recycler. This view may be reused in the function
27 | * {@link #popRecycledViewHolder(int)}
28 | *
29 | * @param viewHolder A viewHolder to add to the Recycler. It can no longer be used.
30 | */
31 | void pushRecycledView(@NonNull ViewHolder viewHolder) {
32 | Deque deque = mViewHolders.get(viewHolder.getItemType());
33 | if (deque == null) {
34 | deque = new ArrayDeque<>();
35 | mViewHolders.put(viewHolder.getItemType(), deque);
36 | }
37 | deque.push(viewHolder);
38 | }
39 |
40 | /**
41 | * Returns, if exists, a view of the type typeView.
42 | *
43 | * @param itemType the type of view that you want.
44 | * @return a viewHolder of the type typeView. null if
45 | * not found.
46 | */
47 | @Nullable
48 | ViewHolder popRecycledViewHolder(int itemType) {
49 | Deque deque = mViewHolders.get(itemType);
50 | return deque == null || deque.isEmpty() ? null : deque.pop();
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/library/src/main/java/com/cleveroad/adaptivetablelayout/ScrollHelper.java:
--------------------------------------------------------------------------------
1 | package com.cleveroad.adaptivetablelayout;
2 |
3 | import android.content.Context;
4 | import android.support.annotation.Nullable;
5 | import android.support.v4.view.GestureDetectorCompat;
6 | import android.view.GestureDetector;
7 | import android.view.MotionEvent;
8 |
9 |
10 | class ScrollHelper implements GestureDetector.OnGestureListener {
11 | /**
12 | * Gesture detector -> Scroll, Fling, Tap, LongPress, ...
13 | * Using when user need to scroll table
14 | */
15 | private final GestureDetectorCompat mGestureDetectorCompat;
16 |
17 | @Nullable
18 | private ScrollHelperListener mListener;
19 |
20 | ScrollHelper(Context context) {
21 | mGestureDetectorCompat = new GestureDetectorCompat(context, this);
22 | mGestureDetectorCompat.setIsLongpressEnabled(true);
23 | }
24 |
25 | void setListener(@Nullable ScrollHelperListener listener) {
26 | mListener = listener;
27 | }
28 |
29 | @Override
30 | public boolean onDown(MotionEvent e) {
31 | // catch down action
32 | return mListener == null || mListener.onDown(e);
33 | }
34 |
35 | @Override
36 | public void onShowPress(MotionEvent e) {
37 | // nothing to do
38 | }
39 |
40 | @Override
41 | public boolean onSingleTapUp(MotionEvent e) {
42 | // catch click action
43 | return mListener != null && mListener.onSingleTapUp(e);
44 | }
45 |
46 | @Override
47 | public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
48 | // catch scroll action
49 | return mListener != null && mListener.onScroll(e1, e2, distanceX, distanceY);
50 | }
51 |
52 | @Override
53 | public void onLongPress(MotionEvent e) {
54 | // catch long click action
55 | if (mListener != null) {
56 | mListener.onLongPress(e);
57 | }
58 | }
59 |
60 | @Override
61 | public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
62 | // catch fling action
63 | return mListener == null || mListener.onFling(e1, e2, velocityX, velocityY);
64 | }
65 |
66 | boolean onTouch(MotionEvent event) {
67 |
68 | if (event.getAction() == MotionEvent.ACTION_UP && mListener != null) {
69 | // stop drag and drop mode
70 | mListener.onActionUp(event);
71 | }
72 | // connect GestureDetector with our touch events
73 | return mGestureDetectorCompat.onTouchEvent(event);
74 | }
75 |
76 |
77 | interface ScrollHelperListener {
78 |
79 | boolean onDown(MotionEvent e);
80 |
81 | boolean onSingleTapUp(MotionEvent e);
82 |
83 | void onLongPress(MotionEvent e);
84 |
85 | boolean onActionUp(MotionEvent e);
86 |
87 | boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY);
88 |
89 | boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY);
90 | }
91 | }
92 |
--------------------------------------------------------------------------------
/library/src/main/java/com/cleveroad/adaptivetablelayout/ScrollType.java:
--------------------------------------------------------------------------------
1 | package com.cleveroad.adaptivetablelayout;
2 |
3 | import android.support.annotation.IntDef;
4 |
5 | import java.lang.annotation.Retention;
6 | import java.lang.annotation.RetentionPolicy;
7 |
8 | import static com.cleveroad.adaptivetablelayout.ScrollType.SCROLL_HORIZONTAL;
9 | import static com.cleveroad.adaptivetablelayout.ScrollType.SCROLL_VERTICAL;
10 |
11 | @IntDef({
12 | SCROLL_HORIZONTAL,
13 | SCROLL_VERTICAL
14 | })
15 | /**
16 | * Scroll type for drag and drop mode.
17 | */
18 | @Retention(RetentionPolicy.SOURCE)
19 | @interface ScrollType {
20 | int SCROLL_HORIZONTAL = 0;
21 | int SCROLL_VERTICAL = 1;
22 | }
23 |
--------------------------------------------------------------------------------
/library/src/main/java/com/cleveroad/adaptivetablelayout/ShadowHelper.java:
--------------------------------------------------------------------------------
1 | package com.cleveroad.adaptivetablelayout;
2 |
3 | import android.support.annotation.NonNull;
4 | import android.support.annotation.Nullable;
5 | import android.view.View;
6 | import android.view.ViewGroup;
7 |
8 | class ShadowHelper {
9 |
10 | @Nullable
11 | private View mRightShadow;
12 | @Nullable
13 | private View mLeftShadow;
14 | @Nullable
15 | private View mTopShadow;
16 | @Nullable
17 | private View mBottomShadow;
18 | @Nullable
19 | private View mColumnsHeadersShadow;
20 | @Nullable
21 | private View mRowsHeadersShadow;
22 |
23 | private LayoutDirectionHelper mLayoutDirectionHelper;
24 |
25 | ShadowHelper(LayoutDirectionHelper layoutDirectionHelper) {
26 | mLayoutDirectionHelper = layoutDirectionHelper;
27 | }
28 |
29 | @NonNull
30 | View addColumnsHeadersShadow(ViewGroup group) {
31 | if (mColumnsHeadersShadow == null) {
32 | mColumnsHeadersShadow = new View(group.getContext());
33 | mColumnsHeadersShadow.setBackgroundResource(R.drawable.shadow_bottom);
34 | group.addView(mColumnsHeadersShadow, 0);
35 | }
36 | return mColumnsHeadersShadow;
37 | }
38 |
39 | @Nullable
40 | View getColumnsHeadersShadow() {
41 | return mColumnsHeadersShadow;
42 | }
43 |
44 | @NonNull
45 | View addRowsHeadersShadow(ViewGroup group) {
46 | if (mRowsHeadersShadow == null) {
47 | mRowsHeadersShadow = new View(group.getContext());
48 | mRowsHeadersShadow.setBackgroundResource(!mLayoutDirectionHelper.isRTL()
49 | ? R.drawable.shadow_right
50 | : R.drawable.shadow_left);
51 | group.addView(mRowsHeadersShadow, 0);
52 | }
53 | return mRowsHeadersShadow;
54 | }
55 |
56 | @Nullable
57 | View getRowsHeadersShadow() {
58 | return mRowsHeadersShadow;
59 | }
60 |
61 | void removeColumnsHeadersShadow(ViewGroup group) {
62 | if (mColumnsHeadersShadow != null) {
63 | group.removeView(mColumnsHeadersShadow);
64 | mColumnsHeadersShadow = null;
65 | }
66 | }
67 |
68 | void removeRowsHeadersShadow(ViewGroup group) {
69 | if (mRowsHeadersShadow != null) {
70 | group.removeView(mRowsHeadersShadow);
71 | mRowsHeadersShadow = null;
72 | }
73 | }
74 |
75 | @NonNull
76 | View addLeftShadow(ViewGroup group) {
77 | if (mLeftShadow == null) {
78 | mLeftShadow = new View(group.getContext());
79 | mLeftShadow.setBackgroundResource(R.drawable.shadow_left);
80 | group.addView(mLeftShadow, 0);
81 | }
82 | return mLeftShadow;
83 | }
84 |
85 | @Nullable
86 | View getLeftShadow() {
87 | return mLeftShadow;
88 | }
89 |
90 | @NonNull
91 | View addRightShadow(ViewGroup group) {
92 | if (mRightShadow == null) {
93 | mRightShadow = new View(group.getContext());
94 | mRightShadow.setBackgroundResource(R.drawable.shadow_right);
95 | group.addView(mRightShadow, 0);
96 | }
97 | return mRightShadow;
98 | }
99 |
100 | @Nullable
101 | View getRightShadow() {
102 | return mRightShadow;
103 | }
104 |
105 | @NonNull
106 | View addTopShadow(ViewGroup group) {
107 | if (mTopShadow == null) {
108 | mTopShadow = new View(group.getContext());
109 | mTopShadow.setBackgroundResource(R.drawable.shadow_top);
110 | group.addView(mTopShadow, 0);
111 | }
112 | return mTopShadow;
113 | }
114 |
115 | @Nullable
116 | View getTopShadow() {
117 | return mTopShadow;
118 | }
119 |
120 | @NonNull
121 | View addBottomShadow(ViewGroup group) {
122 | if (mBottomShadow == null) {
123 | mBottomShadow = new View(group.getContext());
124 | mBottomShadow.setBackgroundResource(R.drawable.shadow_bottom);
125 | group.addView(mBottomShadow, 0);
126 | }
127 | return mBottomShadow;
128 | }
129 |
130 | @Nullable
131 | View getBottomShadow() {
132 | return mBottomShadow;
133 | }
134 |
135 | void removeAllDragAndDropShadows(ViewGroup group) {
136 | if (mLeftShadow != null) {
137 | group.removeView(mLeftShadow);
138 | mLeftShadow = null;
139 | }
140 |
141 | if (mRightShadow != null) {
142 | group.removeView(mRightShadow);
143 | mRightShadow = null;
144 | }
145 |
146 | if (mTopShadow != null) {
147 | group.removeView(mTopShadow);
148 | mTopShadow = null;
149 | }
150 |
151 | if (mBottomShadow != null) {
152 | group.removeView(mBottomShadow);
153 | mBottomShadow = null;
154 | }
155 | }
156 |
157 | void onLayoutDirectionChanged() {
158 | if (getRowsHeadersShadow() != null) {
159 | getRowsHeadersShadow().setBackgroundResource(
160 | !mLayoutDirectionHelper.isRTL()
161 | ? R.drawable.shadow_right
162 | : R.drawable.shadow_left);
163 | getRowsHeadersShadow().requestLayout();
164 | }
165 | }
166 | }
167 |
--------------------------------------------------------------------------------
/library/src/main/java/com/cleveroad/adaptivetablelayout/SmoothScrollRunnable.java:
--------------------------------------------------------------------------------
1 | package com.cleveroad.adaptivetablelayout;
2 |
3 | import android.view.View;
4 | import android.widget.Scroller;
5 |
6 | /**
7 | * Fling table layout logic
8 | * {@see http://stackoverflow.com/a/6219382/842697 }
9 | */
10 | class SmoothScrollRunnable implements Runnable {
11 | /**
12 | * Scrollable view
13 | */
14 | private final View mView;
15 | /**
16 | * Need to calculate offset.
17 | */
18 | private Scroller mScroller;
19 |
20 | private int mLastX;
21 | private int mLastY;
22 |
23 | SmoothScrollRunnable(View view) {
24 | mView = view;
25 | mScroller = new Scroller(view.getContext());
26 | }
27 |
28 | void start(int initX, int initY, int initialVelocityX, int initialVelocityY, int maxX, int maxY) {
29 | // start smooth scrolling
30 | mScroller.fling(initX, initY, initialVelocityX, initialVelocityY, 0, maxX, 0, maxY);
31 |
32 | // save new data
33 | mLastX = initX;
34 | mLastY = initY;
35 |
36 | // run self
37 | mView.post(this);
38 | }
39 |
40 | @Override
41 | public void run() {
42 | if (mScroller.isFinished()) {
43 | return;
44 | }
45 | // calculate offset
46 | boolean more = mScroller.computeScrollOffset();
47 | int x = mScroller.getCurrX();
48 | int y = mScroller.getCurrY();
49 | int diffX = mLastX - x;
50 | int diffY = mLastY - y;
51 | if (diffX != 0 || diffY != 0) {
52 | mView.scrollBy(diffX, diffY);
53 | mLastX = x;
54 | mLastY = y;
55 | }
56 |
57 | if (more) {
58 | // run self
59 | mView.post(this);
60 | }
61 | }
62 |
63 | boolean isFinished() {
64 | return mScroller.isFinished();
65 | }
66 |
67 | void forceFinished() {
68 | if (!mScroller.isFinished()) {
69 | mScroller.forceFinished(true);
70 | }
71 | }
72 | }
73 |
--------------------------------------------------------------------------------
/library/src/main/java/com/cleveroad/adaptivetablelayout/SparseMatrix.java:
--------------------------------------------------------------------------------
1 | package com.cleveroad.adaptivetablelayout;
2 |
3 | import android.support.annotation.NonNull;
4 | import android.support.annotation.Nullable;
5 | import android.support.v4.util.SparseArrayCompat;
6 |
7 | import java.util.Collection;
8 | import java.util.LinkedList;
9 |
10 | /**
11 | * Custom matrix realisation to hold Objects
12 | *
13 | * @param Object
14 | */
15 | class SparseMatrix {
16 | private final SparseArrayCompat> mData;
17 |
18 | SparseMatrix() {
19 | mData = new SparseArrayCompat<>();
20 | }
21 |
22 | /**
23 | * Put item to the matrix in row, column position.
24 | *
25 | * @param row item row position
26 | * @param column item column position
27 | * @param item Object
28 | */
29 | void put(int row, int column, @NonNull TObj item) {
30 | SparseArrayCompat array = mData.get(row);
31 | if (array == null) {
32 | array = new SparseArrayCompat<>();
33 | array.put(column, item);
34 | mData.put(row, array);
35 | } else {
36 | array.put(column, item);
37 | }
38 | }
39 |
40 | /**
41 | * Get Object from matrix by row and column.
42 | *
43 | * @param row item row position
44 | * @param column item column position
45 | * @return Object in row, column position in the matrix
46 | */
47 | @Nullable
48 | TObj get(int row, int column) {
49 | SparseArrayCompat array = mData.get(row);
50 | return array == null ? null : array.get(column);
51 | }
52 |
53 | /**
54 | * Get all row's items
55 | *
56 | * @param row row index
57 | * @return Collection with row's Objects
58 | */
59 | @NonNull
60 | Collection getRowItems(int row) {
61 | Collection result = new LinkedList<>();
62 | SparseArrayCompat array = mData.get(row);
63 | for (int count = array.size(), i = 0; i < count; i++) {
64 | int key = array.keyAt(i);
65 | TObj columnObj = array.get(key);
66 | if (columnObj != null) {
67 | result.add(columnObj);
68 | }
69 |
70 | }
71 | return result;
72 | }
73 |
74 | /**
75 | * Get all column's items
76 | *
77 | * @param column column index
78 | * @return Collection with column's Objects
79 | */
80 | @NonNull
81 | Collection getColumnItems(int column) {
82 | Collection result = new LinkedList<>();
83 | for (int count = mData.size(), i = 0; i < count; i++) {
84 | int key = mData.keyAt(i);
85 | TObj columnObj = mData.get(key).get(column);
86 | if (columnObj != null) {
87 | result.add(columnObj);
88 | }
89 |
90 | }
91 | return result;
92 | }
93 |
94 | /**
95 | * Get all matrix's items
96 | *
97 | * @return Collection with column's Objects
98 | */
99 | @NonNull
100 | Collection getAll() {
101 | Collection result = new LinkedList<>();
102 | for (int countR = mData.size(), i = 0; i < countR; i++) {
103 | int rowKey = mData.keyAt(i);
104 | SparseArrayCompat columns = mData.get(rowKey);
105 | for (int countC = columns.size(), j = 0; j < countC; j++) {
106 | int key = columns.keyAt(j);
107 | result.add(columns.get(key));
108 | }
109 | }
110 | return result;
111 | }
112 |
113 | /**
114 | * Remove item in row, column position int the matrix
115 | *
116 | * @param row item row position
117 | * @param column item column position
118 | */
119 | void remove(int row, int column) {
120 | SparseArrayCompat array = mData.get(row);
121 | if (array != null) {
122 | array.remove(column);
123 | }
124 | }
125 | }
126 |
--------------------------------------------------------------------------------
/library/src/main/java/com/cleveroad/adaptivetablelayout/ViewHolder.java:
--------------------------------------------------------------------------------
1 | package com.cleveroad.adaptivetablelayout;
2 |
3 | import android.support.annotation.NonNull;
4 | import android.view.View;
5 |
6 | /**
7 | * A {@link ViewHolder} describes an item view and metadata about its place within the {@link AdaptiveTableLayout}.
8 | */
9 | interface ViewHolder {
10 | /**
11 | * @return item represents the item of the {@link AdaptiveTableLayout}
12 | */
13 | @NonNull
14 | View getItemView();
15 |
16 | /**
17 | * @return the type of the View
18 | */
19 | int getItemType();
20 |
21 | /**
22 | * @param itemType is the type of the View
23 | */
24 | void setItemType(int itemType);
25 |
26 | /**
27 | * @return the row index.
28 | */
29 | int getRowIndex();
30 |
31 | /**
32 | * @param rowIndex the row index.
33 | */
34 | void setRowIndex(int rowIndex);
35 |
36 | /**
37 | * @return the column index.
38 | */
39 | int getColumnIndex();
40 |
41 | /**
42 | * @param columnIndex the column index.
43 | */
44 | void setColumnIndex(int columnIndex);
45 |
46 |
47 | /**
48 | * @return dragging flag
49 | */
50 | boolean isDragging();
51 |
52 | /**
53 | * @param isDragging dragging param
54 | */
55 | void setIsDragging(boolean isDragging);
56 | }
57 |
--------------------------------------------------------------------------------
/library/src/main/java/com/cleveroad/adaptivetablelayout/ViewHolderImpl.java:
--------------------------------------------------------------------------------
1 | package com.cleveroad.adaptivetablelayout;
2 |
3 | import android.support.annotation.NonNull;
4 | import android.view.View;
5 |
6 | /**
7 | * {@inheritDoc}
8 | */
9 | public abstract class ViewHolderImpl implements ViewHolder {
10 | /**
11 | * Holder view
12 | */
13 | private final View mItemView;
14 | /**
15 | * ViewHolder's table row index
16 | */
17 | private int mRowIndex;
18 | /**
19 | * ViewHolder's table column index
20 | */
21 | private int mColIndex;
22 | /**
23 | * ViewHolder's table item type param
24 | */
25 | private int mItemType;
26 | /**
27 | * ViewHolder's dragging flag
28 | */
29 | private boolean mIsDragging;
30 |
31 | public ViewHolderImpl(@NonNull View itemView) {
32 | mItemView = itemView;
33 | }
34 |
35 | @NonNull
36 | @Override
37 | public View getItemView() {
38 | return mItemView;
39 | }
40 |
41 | @Override
42 | public int getRowIndex() {
43 | return mRowIndex;
44 | }
45 |
46 | @Override
47 | public void setRowIndex(int rowIndex) {
48 | mRowIndex = rowIndex;
49 | }
50 |
51 | @Override
52 | public int getColumnIndex() {
53 | return mColIndex;
54 | }
55 |
56 | @Override
57 | public void setColumnIndex(int columnIndex) {
58 | mColIndex = columnIndex;
59 | }
60 |
61 | @Override
62 | public int getItemType() {
63 | return mItemType;
64 | }
65 |
66 | @Override
67 | public void setItemType(int itemType) {
68 | mItemType = itemType;
69 | }
70 |
71 | @Override
72 | public int hashCode() {
73 | int result = mItemView.hashCode();
74 | result = 31 * result + mRowIndex;
75 | result = 31 * result + mColIndex;
76 | result = 31 * result + mItemType;
77 | result = 31 * result + (mIsDragging ? 1 : 0);
78 | return result;
79 | }
80 |
81 | @Override
82 | public boolean equals(Object obj) {
83 | if (!(obj instanceof ViewHolder)) {
84 | return false;
85 | }
86 | ViewHolder vh = (ViewHolder) obj;
87 | return vh.getColumnIndex() == this.getColumnIndex() && vh.getRowIndex() == this.getRowIndex();
88 | }
89 |
90 | @Override
91 | public boolean isDragging() {
92 | return mIsDragging;
93 | }
94 |
95 | @Override
96 | public void setIsDragging(boolean isDragging) {
97 | mIsDragging = isDragging;
98 | }
99 | }
100 |
--------------------------------------------------------------------------------
/library/src/main/java/com/cleveroad/adaptivetablelayout/ViewHolderType.java:
--------------------------------------------------------------------------------
1 | package com.cleveroad.adaptivetablelayout;
2 |
3 | import android.support.annotation.IntDef;
4 |
5 | import java.lang.annotation.Retention;
6 | import java.lang.annotation.RetentionPolicy;
7 |
8 | @IntDef({
9 | ViewHolderType.FIRST_HEADER,
10 | ViewHolderType.ROW_HEADER,
11 | ViewHolderType.COLUMN_HEADER,
12 | ViewHolderType.ITEM
13 | })
14 | /**
15 | * Type of adapter's ViewHolders
16 | */
17 | @Retention(RetentionPolicy.SOURCE)
18 | @interface ViewHolderType {
19 | /**
20 | * Top left header
21 | */
22 | int FIRST_HEADER = 0;
23 | /**
24 | * Vertical header
25 | */
26 | int ROW_HEADER = 1;
27 | /**
28 | * Horizontal header
29 | */
30 | int COLUMN_HEADER = 2;
31 | /**
32 | * Normal scrollable item
33 | */
34 | int ITEM = 3;
35 | }
36 |
--------------------------------------------------------------------------------
/library/src/main/res/drawable/shadow_bottom.xml:
--------------------------------------------------------------------------------
1 |
2 |
4 |
5 |
9 |
10 |
11 |
--------------------------------------------------------------------------------
/library/src/main/res/drawable/shadow_left.xml:
--------------------------------------------------------------------------------
1 |
2 |
4 |
5 |
9 |
10 |
11 |
--------------------------------------------------------------------------------
/library/src/main/res/drawable/shadow_right.xml:
--------------------------------------------------------------------------------
1 |
2 |
4 |
5 |
9 |
10 |
11 |
--------------------------------------------------------------------------------
/library/src/main/res/drawable/shadow_top.xml:
--------------------------------------------------------------------------------
1 |
2 |
4 |
5 |
9 |
10 |
11 |
--------------------------------------------------------------------------------
/library/src/main/res/values/attrs.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
--------------------------------------------------------------------------------
/library/src/main/res/values/colors.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 | #40000000
4 | #00000000
5 |
6 |
7 |
--------------------------------------------------------------------------------
/library/src/main/res/values/dimens.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
--------------------------------------------------------------------------------
/library/src/main/res/values/ids.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
