app/src/main/java/com/ea/groupbuilder/RnActivity.java - master - nea/androidGroupBuilder

app/src/main/java/com/ea/groupbuilder/RnActivity.java
757 строк34 KB
Группа Автоморфизмов отлажено 23_04_2026
23 апр 2026, 17:08
23 апр 2026, 17:084513276
package com.ea.groupbuilder;

import static java.lang.Math.PI;
import static java.lang.Math.abs;
import static java.lang.Math.cos;
import static java.lang.Math.sin;

import android.content.Intent;
import android.database.Cursor;
import android.graphics.Color;
import android.opengl.Matrix;
import android.os.Bundle;

import android.os.PersistableBundle;
import android.util.DisplayMetrics;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.WindowManager;

import java.util.ArrayList;
import java.util.List;
import androidx.annotation.NonNull;
import androidx.appcompat.app.AppCompatActivity;
import androidx.core.view.MotionEventCompat;

import com.google.android.material.floatingactionbutton.FloatingActionButton;

public class RnActivity extends SurfaceHolderActivity  {
    // визуалитзация группы
    private final static String TAG = "GRUGRA_RN";
    final static private boolean DISPLAYLOG = false;
    private int ciklFlg = 0;        // Отобразить циклы
    private int dim;    // = faktSubsLen
    private int colorRej = 6;   // номер раскраски

    private classSpaceN spaceN; // объект размещение на канве


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
//        Log.d(TAG, "=== onCreate RnActivity" );
        f_set();
        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
    }
    protected void onStop( )   {
        super.onStop() ;
//        Log.d(TAG, "=== onStop RnActivity " + " valDataRect.size= "+ valDataRect.size() + " valDataLines.size()= " + valDataLines.size());
        mApp.activityRn = null;
    }
    protected void onDestroy( ) {
        super.onDestroy();
//        Log.d(TAG, "=== onDestroy RnActivity"  + " valDataRect.size= "+ valDataRect.size() + " valDataLines.size()= " + valDataLines.size());
        mApp.activityRn = null;
    }
    protected void onStart(){
        super.onStart();
//        Log.d(TAG, "=== onStart RnActivity"  + " valDataRect.size= "+ valDataRect.size() + " valDataLines.size()= " + valDataLines.size());
        mApp.activityRn = this;
    }

    @Override
    public void f_set() {
        // выполняется 1 раз
        super.f_set();
        setTitle("Визуализация группы (элементы группы как точки в Rn)");
        dbH.f_getParm(1, 8, 0);
        dim = DbHelper.faktSubsLen;      // 3
        spaceN = new classSpaceN(dim);
        spaceN.f_setAxes(0);

       if (DISPLAYLOG)
           Log.e(TAG, "f_set RnActivity faktSubsLen = " + DbHelper.faktSubsLen + " dim = " + dim + " valDataRect.size= "+ valDataRect.size() + " valDataLines.size()= " + valDataLines.size());


       view.setOnTouchListener (
               new View.OnTouchListener() {
                   @Override
                   public boolean onTouch(View v, MotionEvent event) {
                       if (! IsCreat)
                           return false;
                       final ViewConfiguration conf = ViewConfiguration.get(view.getContext()); // ViewConfiguration.get(mActivy); // системные параметры  для  DblCklick
                       final int DOUBLE_TAP_TIMEOUT = ViewConfiguration.getDoubleTapTimeout();
                       final int doubleTapSlop = conf.getScaledDoubleTapSlop();

                       int actionCode = MotionEventCompat.getActionMasked(event);
                       int pointerIndex = MotionEventCompat.getActionIndex(event);

                       int finger = event.getPointerId(pointerIndex);
                       int pc = event.getPointerCount(); // число пальцев на экране
                       if (pc > fing.length | finger >= fing.length )
                           return false; // только FINGERCOUNT пальца
                       int ret = -1, i;

                       double distanceX, distanceY;
                       float xt = event.getX(pointerIndex), yt = event.getY(pointerIndex);
                       long time_now = event.getEventTime();
                       long deltaTime = time_now - fing[finger].mtime;
//        Log.d(TAG, "onTouch actionCode = "  + actionCode + " " + v.getId()+ " id="+ view.getId() + " xt = " + xt  + " yt = " + yt );
/*		Log.d(TAG, "onTouchEvent finger=" + finger + " actionCode="
						+ actionCode +  " xt=" + xt + " yt="
						+ yt + " e.getYPrecision()X,Y=" + event.getXPrecision() + " " + event.getYPrecision()  +
						 " deltaTime="+deltaTime+ " pc="+pc+ " pointerIndex="+pointerIndex);
*/
                       switch (actionCode) {
                           case MotionEvent.ACTION_MOVE: // 2
                               for (i = 0; i < pc; i++)	{
                                   finger = event.getPointerId(i); // номер пальца =
                                   // 0,1,...
                                   if (finger < fing.length) {
                                       xt = event.getX(i);
                                       yt = event.getY(i);
                                       fing[finger].setNow(xt, yt);
                                   }
                               }

                           if (pc == 1) {
                               finger = event.getPointerId(pointerIndex); // номер пальца
                               distanceX = event.getX() - fing[finger].OldX;
                               distanceY = event.getY() - fing[finger].OldY;
                               if (deltaTime < DOUBLE_TAP_TIMEOUT) {   // было смахивание
                                   float ln = (float) (Math.sqrt(distanceX * distanceX + distanceY * distanceY));
                                   float velocity = (float) (1000d * ln  / Math.abs(deltaTime)); // пикселей / сек
                                   if (velocity >= conf.getScaledMinimumFlingVelocity() && velocity <= conf.getScaledMaximumFlingVelocity() &&
                                           ln > sh / 10.f ) {
//	Log.d(TAG, " смахивание ");
                                       f_allClaer();
                                       ret = 0;
                                   }
                               }
                               if (ret < 0 & (distanceX != 0 || distanceY != 0)) {
                                   DisplayMetrics metrics = new DisplayMetrics(); // metrics.xdpi =  physical pixels per inch
                                   mApp.activityRn.getWindowManager().getDefaultDisplay().getMetrics(metrics);
/*
		Log.d(TAG, "mode= ACTION_MOVE (f_TouchMove) "+distanceX + " "+distanceY+ " finger="+finger+
									" old="+fing[finger].OldX + " "+fing[finger].OldY+
									" new="+fing[finger].NowX+" new="+fing[finger].NowY+
						"  metrics.xdpi="+ metrics.xdpi+" ydpi="+ metrics.ydpi
							);
*/
// вращение осей
                                   spaceN.f_TouchMove(fing[finger].OldX, fing[finger].OldY, fing[finger].NowX,  fing[finger].NowY, metrics.xdpi, metrics.ydpi);
                                   spaceN.f_setAxes(1);
                                   posCreated = 2;  // пересчитать матрицу и координаты
                               }
                           }
                           if (pc == 2) {
                               float dx0= 0f, dy0 = 0f, dx1= 0f, dy1 = 0f, sz;
                               int finger1 = event.getPointerId(0); // номер пальца = индекс в fing = 0

/*                               finger = event.getPointerId(i); // номер пальца =
                               // 0,1,...
                               if (finger < fing.length) {
                                   xt = event.getX(i);
                                   yt = event.getY(i);
                                   fing[finger].setNow(xt, yt);
*/

                                   finger = event.getPointerId(1);	// индекс в fing = 1
                               // 0,1,...
                               if (finger < fing.length & finger1 < fing.length) {
                                   dx0 += Math.abs( fing[finger].OldX - fing[finger1].OldX); // расстояние между пальцами на начало движения
                                   dy0 += Math.abs( fing[finger].OldY - fing[finger1].OldY);

                                   dx1 += Math.abs(event.getX(0)  - event.getX(1)); // после движения
                                   dy1 += Math.abs(event.getY(0)  - event.getY(1));

                                   if ((dx0*dx0 + dy0*dy0)>0) {
                                        sz = (float) Math.sqrt((dx1*dx1 + dy1*dy1)/(dx0*dx0 + dy0*dy0));
//						Log.d(TAG, "mode=f_TouchScale = "+ sz);
                                       koeffX *= sz;
                                       posCreated = 1;  // пересчитать матрицу и координаты
                                   }
                                   if (abs((dx0*dx0 + dy0*dy0) - (dx1*dx1 + dy1*dy1)) < 18) {
                                       startX += 7. * (event.getX(1)  - fing[finger].OldX );
                                       startY += 7. * (event.getY(1)  - fing[finger].OldY );
/*                                       Log.d(TAG, "mode= ACTION_MOVE (f_TouchMove) x0 "+ fing[finger1].OldX + " x1= "+event.getX(1)+
                                   "  y0 "+ fing[finger1].OldY + " y1= "+event.getX(1)+
                                                       " finger="+finger+ " finger1="+finger1+
                                               " abs = "+abs((dx0*dx0 + dy0*dy0) - (dx1*dx1 + dy1*dy1)));

                                       Log.d(TAG, "mode=f_TouchMove startX = "+ startX + " startY = " + startY);
*/
                                   }
                               }
                           }
                           for (i = 0; i < pc; i++) {
                               // сохранить новое положение пальцев
                               fing[i].setOld(fing[i].NowX, fing[i].NowY);
                               fing[i].mtime = time_now;
                           }
                           break;
                           case MotionEvent.ACTION_DOWN: // 0
/*
       Log.d(TAG, "mode=ACTION_DOWN finger="+finger+ " DOUBLE_TAP_TIMEOUT="+DOUBLE_TAP_TIMEOUT+
							" deltaTime="+deltaTime +" doubleTapSlop="+doubleTapSlop+
							" deltaX="+(fing[finger].OldX - xt) +
							" deltaY="+(fing[finger].OldY - yt)+
							" old="+fing[finger].OldX + " "+fing[finger].OldY+
							" new="+xt+" new="+yt
							);
*/
                               if (deltaTime < DOUBLE_TAP_TIMEOUT) { // && deltaTime >  DOUBLE_TAP_MIN_TIME)
                                   flagMove = ! flagMove;
                                   double deltaX = fing[finger].OldX - xt,
                                           deltaY = fing[finger].OldY - yt;
/*                                   if ((deltaX * deltaX + deltaY * deltaY) < (doubleTapSlop * doubleTapSlop)) {
         Log.d(TAG, "сделан двойной клик mode=ACTION_DOWN finger="+finger+ " DOUBLE_TAP_TIMEOUT="+DOUBLE_TAP_TIMEOUT+
                                               " deltaTime="+deltaTime +" doubleTapSlop="+doubleTapSlop+
                                               " deltaX="+(fing[finger].OldX - xt) +
                                               " deltaY="+(fing[finger].OldY - yt)+
                                               " old="+fing[finger].OldX + " "+fing[finger].OldY+
                                               " new="+xt+" new="+yt
                                       );

       //??                                f_TouchDbl(xt, yt);
                                   }
*/
                               }
                               for (i = 0; i < valDataRect.size(); i++) {
                                   dataPoint dItem = valDataRect.get(i);
                                   if (dItem.f_test( xt - startX, yt - startY )) {
                                       dItem.clickFlag = !dItem.clickFlag;
                                       if (dItem.clickFlag) {
                                           txtSoobTouch = "Выбрана " + dItem.f_getSubs() + " id = " + dItem.id + " " + dItem.f_getNameSub(flagSn);
                                       } else
                                           txtSoobTouch = "";
                                       if (DISPLAYLOG)
                                           Log.e(TAG, "onTouch id= " + dItem.id + " # " +  " dItem.clickFlag =" + dItem.clickFlag );
                                   }
                               }
                               f_putText();
                               fing[finger].setOld(xt, yt);
                               fing[finger].mtime = time_now;
                               break;
                           case MotionEvent.ACTION_POINTER_DOWN: // 5
                               fing[finger].mtime = time_now;
                               fing[finger].setOld(xt, yt);
//                               Log.e(TAG, "setOnTouchListener ACTION_POINTER_DOWN finger =  " +finger + " setOld " + xt + " " + yt + " pc = " + pc);

                               break;
                           case MotionEvent.ACTION_POINTER_UP: // 6
//					Log.d(TAG, "mode=ACTION_POINTER_UP");
                           case MotionEvent.ACTION_UP: // 1
//					Log.d(TAG, "mode=ACTION_UP");
                               break;

                           case MotionEvent.ACTION_OUTSIDE: // 4
                           case MotionEvent.ACTION_CANCEL: // 3
                               fing[finger].setNull();
//				Log.d(TAG, "mode=ACTION_CANCEL");
                               break;

                           default:
                               break;
                       }
                       v.performClick();
                       return true;
                   }
               }
       );
        f_putText();

   }

    protected void f_allClaer() {
        // перестроить все по смахиванию
       koeffX = spaceN.movAngle = 0.;
       startX = startY = 0f;
       Matrix.setIdentityM(spaceN.modelRotate, 0);
       spaceN.f_setAxes(-1);
       posCreated = 1;  // пересчитать точки и матрицу и координаты
        if (DISPLAYLOG)
            Log.e(TAG, "f_allClaer  ");
   }

    private void f_setPos(boolean toPointsWrite) {
        // установить xPos - точку на канвас в объектах точки dataSubs, должна выполняться после чтения данных и при поворотах осей
        String sqlInsLine;
        if (toPointsWrite) {
            db.execSQL("delete from points;");
            db.execSQL("UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='points';");
        }
        for (int m = 0; m < valDataRect.size(); m++) {
            float xx[] = spaceN.f_setVector(valDataRect.get(m).subs, 1);   // точка на канвасе
            valDataRect.get(m).f_setXY( xx );   // точка на канвасе

            if (toPointsWrite) { // для построения ребер:
// npp = id G для автоморф
                sqlInsLine = "insert into points (ind_point, id_element, npp,  iteration, xp, yp, zp, point_num) VALUES (" +
                        m + ", " + valDataRect.get(m).id + ", " +
                        (flagSn ? valDataRect.get(m).idSub : valDataRect.get(m).id) + ", 0, " + xx[0] + ", " + xx[1] + ", 0, '" + valDataRect.get(m).f_getNameSub(flagSn) + "');";
                db.execSQL(sqlInsLine);

//                Log.e(TAG, "f_setPos flagSn = " + flagSn + " m = " + m + " id = " + valDataRect.get(m).id + " idSub = "+ valDataRect.get(m).idSub +  " toPointsWrite = " + toPointsWrite);
            }
//            Log.e(TAG, "f_setPos m = " + m + " id = " + valDataRect.get(m).id + " sel = " + valDataRect.get(m).selectFlag);
//            Log.e(TAG, "f_setPos m = " + m + " xx = "+ xx[0] + " " + xx[1] + " valDataRect.get(m). = " +
//                    valDataRect.get(m).xPos[0] + " " +  valDataRect.get(m).xPos[1] );
        }
    }


    private boolean testKoeff = true,
            dvigFlag = true;
    protected void f_paint() {
        // собственно рисование
        if (IsCreat) {
            canvas.drawColor(Color.WHITE);
            canvas.save();
            sh = canvas.getHeight();
            sw = canvas.getWidth();
            otstup = sh * 0.07;
            dx = 0.5 * sw;
            dy = otstup + 0.5 * (sh - otstup);
            if (koeffX == 0.) {
                koeffX = dy / (1.11 * dim);  // коэф растяжения
                testKoeff = true;
            }

            int m;
            if (posCreated < 1) {
//                if (DISPLAYLOG)
//                    Log.e(TAG, "f_paint posCreated = " + posCreated + " valDataRect.size() =  " + valDataRect.size());
                runOnUiThread(new Runnable() {  // запустить прогресс бар
                    public void run() {
                        ProgressBr.setVisibility(View.VISIBLE);
                        ProgressBr.setIndeterminate(true);
                    }
                });

                f_readData();
            }
            if (posCreated < 2) {
                spaceN.f_setParm(mApp, koeffX, koeffX, dx, dy);

                if (testKoeff) {
// коррекция koeffX по факту только при сбросе и при запуске
                    int test[] = new int[dim];
                    for (m = 0; m < dim; m++)
                        test[m] = dim;

                    float[] tF = spaceN.f_setVector(test, 0);
//                    Log.e(TAG, " test = " + tF[0] + "  " + tF[1] + " sh =" + sh + " sw =" + sw + " koeffX =" + koeffX + " dx = " + dx + " dy = " + dy);
                    if (abs(tF[1]) >= 0.8 * dy) {
                        koeffX *= (dy / tF[1]);
                        koeffX *= 0.8;
                        spaceN.f_setParm(mApp, koeffX, koeffX, dx, dy);
                    }
                    testKoeff = false;
//                    Log.e(TAG, " koeffX =" + koeffX);
                }
            }

            if (menuFlg > 0) {  // выбор в всплывающем меню
                f_menuSelect();
                menuFlg = 0;
            }

            if (elemFlg > 0) {  // выбор в всплывающем меню
                f_elementSelect();
                elemFlg = 0;
            }

            if (flagMove) {
                spaceN.f_move();
                f_setPos(false);
            }

            if (posCreated < 3) {
                f_setPos(true); // заносит x,y  в объекты точки dataSubs
                if (lineCreated == 0) {
                    f_getLinesBuff(); // должна выполняться посде f_setPos()
                    lineCreated = 1;
                }
//                if (DISPLAYLOG)
//                    Log.e(TAG, "f_paint flagMove = "+ flagMove + " posCreated= "+ posCreated + " count = "+ valDataRect.size());
            }

            if (posCreated < 1) {
                runOnUiThread(new Runnable() {  // остановить прогресс бар
                    public void run() {
                        ProgressBr.setVisibility(View.INVISIBLE);
                        ProgressBr.setIndeterminate(false);
                    }
                });
            }


            posCreated = 3;

            paintZag.setARGB(255, 0, 0, 0);
            canvas.drawText(flagSn ? groupName_n : (mApp.tableNameEnd.equals("_a") ? "Автоморфизмы " : "") + mApp.groupName, 17f, sh / 20f, paintZag);

            if (axisFlg > 0) {
                spaceN.f_putAxes(canvas, paintOs, startX, startY);
            }
            if (pntFlg > 0) {
                spaceN.f_putSetka(canvas, paintSetka, startX, startY);
            }

            if (ciklFlg > 0)  {      // Отобразить циклы
                f_putCikl();
            }

// вывод точек
            dataPoint dSub;
            for (m = 0; m < valDataRect.size(); m++) {
                dSub = valDataRect.get(m);
                colorSelector.indColor = dSub.colorNum;
                colorSlt.f_setColor();
                paintPoint.setARGB(255, colorSelector.rCol, colorSelector.gCol, colorSelector.bCol);
                if (flagSn) { // выводится Sn, в этом случае выделить точки подгруппы миганием
                    if (gruppFlg > 0) {
                        if (dSub.idSub > 0) {   // выбрана точка
                            if (tnrFlag) {
                                f_paintPoint(dSub); // точка подгруппы при рисовании Sn должна мигать
                            }
                        } else {
                            f_paintPoint(dSub);
                        }

                    }
                } else { // if (flagSn)
                    if (gruppFlg > 0) {
                        f_paintPoint(dSub);
                    }
                }

// выделение по popup две маленькие черточки
                if (gruppFlg > 0) {
                    if (dSub.selectFlag) {
                        paintSubGr.setARGB(255, colorSelector.rCol, colorSelector.gCol, colorSelector.bCol);
                        canvas.drawLine(dSub.xPos[0] + startX, dSub.xPos[1] + startY, dSub.xPos[0] + 6 + startX, dSub.xPos[1] - 6 + startY, paintSubGr);
                        canvas.drawLine(dSub.xPos[0] + startX, dSub.xPos[1] + startY, dSub.xPos[0] - 6 + startX, dSub.xPos[1] - 6 + startY, paintSubGr);
                    }
                }
            }   // for (int m = 0;

 // вывод линий
            if (lineFlg >= 0) {
                f_putLines();
            }
            if (autoFlg > 0 ) {
                f_putAuto();
//                Log.e(TAG, "f_paint  autoFlg = " + autoFlg);
            }

            canvas.restore();
        }
    }

     private void f_putCikl() {
        // Отобразить циклы
        // отопрожается если dsb.clickFlag - они выводятся, иначе dSub.selectFlag, если нет и этого - на все точки
        int rj = 2, // признак чего рисовать
                k, i, i1, j,  m = valDataRect.size();
        int falsh[] = new int[dim];
        float xx1[] = {0f, 0f}, xx2[] = {0f, 0f};

        dataPoint dSub;

// определяю rj - на каких точках рисовать
        for (k = 0; k < m; k++)
            if (valDataRect.get(k).clickFlag) {
                rj = 0;
                break;
            }
        if (rj == 2)
            for (k = 0; k < m; k++)
                if (valDataRect.get(k).selectFlag) {
                    rj = 1;
                    break;
                }

// собственно рисование
        for (k = 0; k < m; k++) {
            dSub = valDataRect.get(k);
            i1 = -1;
            switch (rj) {
                case 0:
                    if (dSub.clickFlag)
                        i1 = k;
                    break;
                case 1:
                    if (dSub.selectFlag)
                        i1 = k;
                    break;
                default:
                    i1 = k;
                    break;

            }

            if (i1 >= 0) {   // рисовать для этой точки
                colorSelector.indColor = dSub.colorNum;
                colorSlt.f_setColor();
                paintZag.setARGB(255, colorSelector.rCol, colorSelector.gCol, colorSelector.bCol);
                for (i = 0; i < dim; i++) {
                    for (j = 0; j < dim; j++)   // 1-я точка отрезка цикла
                        falsh[j] = 0;
                    falsh[i] = dSub.subs[i];
                    xx1 = spaceN.f_setVector(falsh, 0);   // точка на канвасе
//         Log.e(TAG, "f_putCikl falsh1 = " + falsh[0] + " "  + falsh[1] + " "  + falsh[2] + " " //  + falsh[3] //  + " "  + sub[4]
//                            + " xx1 = " + xx1[0] + " " + xx1[1] + " i = " + i + " k = " + k + " rj = " + rj);

   // 2-я точка отрезка цикла
                    for (j = 0; j < dim; j++)
                        falsh[j] = 0;
                    falsh[dSub.subs[i] - 1] = dSub.subs[dSub.subs[i] - 1];
                    xx2 = spaceN.f_setVector(falsh, 0);
//                    Log.e(TAG, "f_putCikl falsh2 = " + falsh[0] + " "  + falsh[1] + " "  + falsh[2] + " " // + falsh[3] //  + " "  + sub[4]
//                            + " xx2 = " + xx2[0] + " " + xx2[1]  + " i = " + i );

                    canvas.drawLine(xx1[0] + startX, xx1[1] + startY, xx2[0] + startX, xx2[1] + startY, paintZag);
                }

            }
        }
    }


    private MenuItem mItemSn,    // Выделение распавших классов
            mItemAuto;  // автоморфиз

    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.menu_rn, menu);
        mItemSn = menu.findItem(R.id.action_rn_sn);
        mItemSn.setEnabled( dbH.f_testFn() );
        mItemAuto = menu.findItem(R.id.action_rn_auto);
        mItemAuto.setEnabled( ! mApp.tableNameEnd.equals("_a"));

        return super.onCreateOptionsMenu(menu);
    }

    public boolean onPrepareOptionsMenu(Menu menu) {
        mItemSn.setEnabled( dbH.f_testFn() );
        mItemAuto.setEnabled( ! mApp.tableNameEnd.equals("_a"));
        if (dbH.f_getCountRow("select _id from elements_a;") == 0)
            mItemAuto.setEnabled(false);
        return super.onPrepareOptionsMenu(menu);
    }

    public boolean onOptionsItemSelected(MenuItem item)    {
        Intent intent;
        int j;
        switch (item.getItemId())  {
            case R.id.action_grp_l_move:  // Вращать
                item.setChecked( ! item.isChecked());
                dvigFlag = flagMove = item.isChecked();
                break;

            case R.id.action_rn_axis:    // Отобразить оси
                item.setChecked( ! item.isChecked());
                axisFlg = item.isChecked() ? 1 : 0;
                break;

            case R.id.action_rn_gr:    // Отобразить группу
                item.setChecked( ! item.isChecked());
                gruppFlg = item.isChecked() ? 1 : 0;
                break;

            case R.id.action_rn_auto:    // автоморф
                item.setChecked( ! item.isChecked());
                if (item.isChecked())
                    f_setAuto();
                else {
                    autoFlg = 0;
                }

                break;

            case R.id.action_rn_sn:    // Отобразить группу Sn
                item.setChecked( ! item.isChecked());
                flagSn = item.isChecked();
                stopPotok();
                for (j = 0; j < valDataRect.size(); j++) {
                    valDataRect.get(j).clickFlag = false;
                    valDataRect.get(j).selectFlag = false;
                }
                db.execSQL("delete from temp_pe;");
                posCreated = 0;
                repaint();
                break;

            case R.id.action_rn_pnt:    // Отобразить все целочисленные точки - сетку
                item.setChecked( ! item.isChecked());
                pntFlg = item.isChecked() ? 1 : 0;
                if (item.isChecked()) {
                    intent = new Intent(RnActivity.this, ModeActivitySetka.class);
                    startActivity(intent);
                }
//                Log.e(TAG, "action_rn_pnt  pntFlg  = " + pntFlg + " size = " + valDataRect.size() );
                break;

            case R.id.action_rn_kely:    // Отобразить граф Кели
                item.setChecked( ! item.isChecked());
                lineFlg = item.isChecked() ? 0 : -1;
                posCreated = 0;
                break;

            case R.id.action_rn_cikls:    // Отобразить циклы
                item.setChecked( ! item.isChecked());
                ciklFlg = item.isChecked() ? 1 : 0;
                break;

            case R.id.action_rn_exit:
                finish();
                break;

            case R.id.action_rn_help:
                intent = new Intent(RnActivity.this, helpActivity.class);
                startActivity(intent);
                break;

// раскраска
            case R.id.action_rncol1:
                colorRej = 1;   // По итерациям
                posCreated = 0;
                break;
            case R.id.action_rncol2:
                colorRej = 2;   // По классам
                posCreated = 0;
                break;
            case R.id.action_rncol3:
                colorRej = 3;   // По цикл типу
                posCreated = 0;
                break;
            case R.id.action_rncol4:
                colorRej = 4;   // По P
                posCreated = 0;
                break;
            case R.id.action_rncol5:
                colorRej = 5;   // По порядку эл-та
                posCreated = 0;
                break;
            case R.id.action_rncol6:
                colorRej = 6;   // По Силову
                posCreated = 0;
                break;

            case R.id.action_rncol7:
                colorRej = 7;   // Четные и нечетные
                posCreated = 0;
                break;

            case R.id.action_rncol8:
                colorRej = 8;   // по стационарным точкам
                posCreated = 0;
                break;

            case R.id.action_rncol9:
                colorRej = 9;   // по числу стационарных точек
                posCreated = 0;
                break;

        }
        return super.onOptionsItemSelected(item);
    }

    private void f_readData() {
        /* чтение подстановок, создание valDataRect
          flagSn - строит все для Sn, группа как подгруппа Sn
         colorRej установливает раскраску точек
         */
        String klch, klch0 = "U", selStr = f_getSQLForReadData(colorRej);

//        if (DISPLAYLOG)
            Log.e(TAG, "f_readData  " + DbHelper.faktSubsLen + " colorRej = " + colorRej + " posCreated = " + posCreated + " flagSn = " + flagSn + " sql= " + selStr);

        int id, colorN = 0, idgr, i, j;
        String subs;

// запомнить тапнутые точки
        List<Integer> tapId = new ArrayList(); // id тапнутых точек
        List<Integer> selId = new ArrayList(); // id selectFlag точек
        for (i = 0; i < valDataRect.size(); i++) {
            if (valDataRect.get(i).clickFlag)
                tapId.add(valDataRect.get(i).id);
            if (valDataRect.get(i).selectFlag)
                selId.add(valDataRect.get(i).id);
        }


        valDataRect.clear();
        Cursor mCursor = db.rawQuery(selStr, null);
        int    ik_ = mCursor.getColumnIndex("kluch"),
               id_ = mCursor.getColumnIndex("_id"),
               ig_ = mCursor.getColumnIndex("idgr"),   // flagSn =false - null, иначе link_to_elements = id G
               is_ = mCursor.getColumnIndex("substitution");
        if (mCursor.moveToFirst()) {
            do {
                id = mCursor.getInt(id_);
                idgr = mCursor.getInt(ig_); // _id подгруппы в случае Sn
                subs = mCursor.getString(is_);  // substitution
                klch = mCursor.getString(ik_);  // ключ для раскраски
                if (klch == null)
                    klch = " ";
                if ( ! klch.equals(klch0)) {
                    colorN++;
                    klch0 = klch;
                }
                valDataRect.add(new dataPoint(classSubs, classSubs.f_toArray(subs, DbHelper.faktSubsLen), id, idgr, 0, colorN, mApp.tableNameEnd));
             } while (mCursor.moveToNext());
        }

//        Log.e(TAG, "f_readData2 menuFlg = " + menuFlg + " valDataRect.size() = " + valDataRect.size());

// тапнуть
        for (i = 0; i < valDataRect.size(); i++) {
            id = valDataRect.get(i).id;
            j = tapId.indexOf(id);
            if (j >= 0)
                valDataRect.get(i).clickFlag = true;
            j = selId.indexOf(id);
            if (j >= 0)
                valDataRect.get(i).selectFlag = true;
        }


        lineCreated = 0;
        // применить условие на вершины по menuFlg - восстановить menuFlg
//        Log.e(TAG, "f_readData0 menuFlg = " + menuFlg);

        if (menuFlg == 0) {
            if (dbH.f_getMas("select distinct id_2 || ' ' as stext from temp_pe;") > 0) {
//                Log.e(TAG, "f_readData1 selectedMas = " + DbHelper.selectedMas[0] + "  " + DbHelper.selectedMas.length);
                menuFlg = Integer.parseInt(DbHelper.selectedMas[0].trim());
            } else
                menuFlg = 0;
        }
    }



    @Override
    protected void onRestoreInstanceState(@NonNull Bundle savedInstanceState) {
        super.onRestoreInstanceState(savedInstanceState);
        savedInstanceState.get("otstup");
        savedInstanceState.get("koeffX");
//        Log.d(TAG, "onRestoreInstanceState koeffX = " + koeffX);
    }

    @Override
    public void onSaveInstanceState(@NonNull Bundle outState, @NonNull PersistableBundle outPersistentState) {
//        Log.d(TAG, "onSaveInstanceState koeffX = " + koeffX);
        outState.putDouble("otstup", otstup);
        outState.putDouble("koeffX", koeffX);
        super.onSaveInstanceState(outState, outPersistentState);
      }

}
 //-------------------------