Merge tag 'v1.0.55' of https://github.com/Etar-Group/Etar-Calendar into lineage-23.2

	defaultConfig {

		minSdk = 23

		targetSdk = 36

		versionCode = 54

		versionName = "1.0.54"

		versionCode = 55

		versionName = "1.0.55"

		applicationId = "ws.xsoh.etar"

		testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"

	}

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Calendar;

import java.util.Comparator;

import java.util.Formatter;

import java.util.Locale;

import java.util.regex.Matcher;

        selectionArea.right = selectionArea.left + cellWidth;

        final ArrayList<Event> events = mEvents;

        // Sort events by column, so they are drawn in order of column. This

        // leads to events with the higher column number being drawn last, which

        // ensures proper z-sorting when multiple events overlap.

        events.sort(Comparator.comparingInt(Event::getColumn));

        int numEvents = events.size();

        EventGeometry geometry = mEventGeometry;

            if (r.top > viewEndY || r.bottom < mViewStartY) {

                continue;

            }

            StaticLayout layout = getEventLayout(mLayouts, i, event, eventTextPaint, r);

            // TODO: not sure why we are 4 pixels off

            drawEventText(layout, r, canvas, mViewStartY + 4, mViewStartY + mViewHeight

        // If there are any events in the selected region, then assign the

        // closest one to mSelectedEvent.

        if (!mSelectedEvents.isEmpty()) {

        if (mSelectedEvents.size() > 0) {

            int len = mSelectedEvents.size();

            Event closestEvent = null;

            float minDist = mViewWidth + mViewHeight; // some large distance

            float maxCol = -99999;

            for (int index = 0; index < len; index++) {

                Event ev = mSelectedEvents.get(index);

                // dist will yield 0.0 for all events overlapping each other.

                // In order to select the correct one we use the topmost event (i.e. the one with

                // the highest col value!

                float dist = geometry.pointToEvent(x, y, ev);

                float col  = ev.getColumn();

                if (dist <= minDist && col > maxCol) {

                if (dist < minDist) {

                    minDist = dist;

                    closestEvent = ev;

                    maxCol = col;

                }

            }

            setSelectedEvent(closestEvent);

    private float mMinuteHeight;

    // How many pixels is each column set off from the

    // very left of column 0?

    // This is used to enable stacked parallel events.

    private static final float mPerColMargin  = 32;

    private float mHourGap;

    private float mMinEventHeight;

        }

        int col = event.getColumn();

        int maxCols = event.getMaxColumns();

        int startHour = startTime / 60;

        int endHour = endTime / 60;

            event.bottom = event.top + mMinEventHeight;

        }

        event.left = left + (col) * mPerColMargin;

        event.right = left + cellWidth - mCellMargin;

        float colWidth = (float) (cellWidth - (maxCols + 1) * mCellMargin) / (float) maxCols;

        event.left = left + col * (colWidth + mCellMargin);

        event.right = event.left + colWidth;

        return true;

    }

    private static final String WHERE_CALENDARS_VISIBLE = Calendars.VISIBLE + "=1";

    private static final String INSTANCES_SORT_ORDER = Instances.START_DAY + ","

            + Instances.START_MINUTE + "," + Instances.TITLE;

    private static final int WEEKS_BUFFER = 6;

    private static final int WEEKS_BUFFER = 1;

    // How long to wait after scroll stops before starting the loader

    // Using scroll duration because scroll state changes don't update

    // correctly when a scroll is triggered programmatically.

    private CreateEventDialogFragment mEventDialog;

    private CursorLoader mLoader;

    private Uri mEventUri;

    private volatile boolean mShouldLoad = true;

    private final Runnable mUpdateLoader = new Runnable() {

        @Override

        public void run() {

            synchronized (this) {

                if (mLoader == null) {

                if (!mShouldLoad || mLoader == null) {

                    return;

                }

                // Stop any previous loads while we update the uri

                            | DateUtils.FORMAT_SHOW_YEAR, null, null);

        }

    }

    @Override

    public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {

        super.onScroll(view, firstVisibleItem, visibleItemCount, totalItemCount);

        synchronized (mUpdateLoader) {

            mHandler.removeCallbacks(mUpdateLoader);

            mHandler.postDelayed(mUpdateLoader, LOADER_DELAY);

        }

    }

    @Override

    public void onScrollStateChanged(AbsListView view, int scrollState) {

        synchronized (mUpdateLoader) {

            if (scrollState != OnScrollListener.SCROLL_STATE_IDLE) {

                mDesiredDay.set(System.currentTimeMillis());

                mShouldLoad = false;

                stopLoader();

                mDesiredDay.set(System.currentTimeMillis());

            } else {

                mHandler.removeCallbacks(mUpdateLoader);

                mHandler.postDelayed(mUpdateLoader, 0);

                mShouldLoad = true;

                mHandler.postDelayed(mUpdateLoader, LOADER_DELAY);

            }

        }

        if (scrollState == OnScrollListener.SCROLL_STATE_TOUCH_SCROLL) {

- Opravena UTC chyba v goto

- Načtení událostí při posouvání v režimu měsíce

- Přidány hromadné události

- Přidáno oprávnění WRITE_SYNC_SETTINGS pro zabránění duplikaci kalendáře při přepnutí synchronizace

- Opravy chyb