;;====================================================================================================;;
;;                                                                    	                              ;;
;; DRENUM.LSP - Программа автонумерации/ренумерации следующих элементов                               ;;
;;              TEXT, MTEXT, ACAD_TABLE, MULTILEADER (мультивыносок) и ATTRIBUTES (атрибутов).        ;;
;;              Имеется два независимых счётчика с независимыми инкрементами, префикс и два суффикса. ;;
;;                                                                                                    ;;
;; sbgPDPrefixOne                     - переменная первого суффикса                                   ;; 
;; sbgPDStartOne                      - переменная стартового значения первого счётчика               ;; 
;; sbgPDStepOne                       - переменная стартового значения первого инкремента             ;; 
;; sbgPDSufixOne                      - переменная значения первого суффикса                          ;; 
;; sbgPDStartDuble                    - переменная стартового значения второго счётчика               ;; 
;; sbgPDStepDuble                     - переменная стартового значения второго инкремента             ;; 
;; sbgPDSufixDuble                    - переменная значения второго суффикса                          ;; 
;; sbgPDTypeRun                       - переменная значения количества работающих счётчиков           ;; 
;; sbgPDCurString                     - переменная для сбора текстовой строки                         ;; 
;; sbgPDCurText                       - переменная для хранения имени объекта                         ;; 
;; sbgPDStopCalcOne                   - переменная разрешающая работу первого счётчика                ;; 
;; sbgPDStopCalcDuble                 - переменная разрешающая работу второго счётчика                ;;
;; sbgPDTableMode                     - переменная разрешающая работу в режим "таблицы"               ;;
;; sbgPDFunctionMissed                - переменная разрешения работы функции при "промахивании"       ;;
;; sbgPDHandle                        - переменная имени созданного файла                             ;;  
;; sbgPDFile                          - переменная пути к создаваемому файлу диалога                  ;; 
;; sbgPDAllCoordinate                 - переменная содержащая "сырые" координаты с буфера             ;; 
;; sbgPDCoordinateForSsget            - переменная содержащая список обработанных координат           ;; 
;; sbgPDTempTableNameSelectCell       - переменная имени таблицы в vla формате                        ;;
;; sbgPDTempRowSelectCell             - переменная номера строки                                      ;;
;; sbgPDTtempColumnSelectCell         - переменная номера столбца                                     ;;
;; sbgPDTempPointOfSelectCell         - переменная координаты ячейки таблицы                          ;;
;; sbgPD_temp_ssget_select_all_tables - переменная списка выбранных таблиц                            ;;
;; sbgPDOldEcho                       - переменная хранения предыдущего значения переменной "cmdecho" ;;
;;                                                                                                    ;;
;;                                                                                                    ;;
;;                                                                                                    ;;  
;;  Все переменные с дополнительным префиксом "dlc" это имена ключей и имён                           ;;
;;  диалогов из файла диалога расположенного по адресу "DCL_dialogs/drenum.DCL"                       ;;
;;                                                                                                    ;;
;;====================================================================================================;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;Функция вызова программы ренумератора;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defun C:DRENUM ( / sbgPDHandle sbgPDAllCoordinate sbgPDCoordinateForSsget ) ;                                                                                                
                    
  (vl-load-com)
  ;; стартовая настройка переменной sbgPDTypeRun
  (if (null sbgPDTypeRun) (setq sbgPDTypeRun 1) ) ; если нет значений, то заполняем её ставя значение 1 счётчика
  ;; создаём временный файл диалога и загружаем диалог в кад
  (setq sbgPDFile (strcat (vl-string-right-trim
       "\\"
       (vla-get-tempfilepath
         (vla-get-files
           (vla-get-preferences (vlax-get-acad-object))
           ) ;_ end of vla-get-files
         ) ;_ end of vla-get-tempfilepath
       ) ;_ end of vl-string-right-trim
           "\\drenum.dcl"
           ) ;_ end of strcat
  sbgPDHandle (open sbgPDFile "w")
  ) ;_ end of setq
  (foreach item
     '("//*******************************************************************************************************************                                                                       "
"//**************************Начало диалога dcl_drenum_all************************************************************                                                                       "
"//*******************************************************************************************************************                                                                       "
"                                                                                                                                                                                            "
"                                                                                                                                                                                            "
"dcl_drenum_all: dialog {label = \"  ---=={ Ренумератор}==---   \"; children_alignment = centered; children_fixed_width = false; initial_focus = \"dclSbgPDPrefixOne\" ; // начало диалога   "  
"                                                                                                                                                                                            "
"                                                                                                                                                                                            "
"      : boxed_column { label = \"Настройки ренумератора\" ; children_fixed_width = false; children_alignment = right; fixed_width = true; width = 45;  // начало boxed_column               "
"                                                                                                                                                                                            "
"        : concatenation {children_fixed_width = true;  alignment = left; children_alignment = centered ; fixed_width = true; width = 40;                                                    "
"          : text {label = \"Первый префикс:\"; alignment = left; fixed_width = true; width = 30;}   // текстовое поле                                                                       "
"          : edit_box {key = \"dclSbgPDPrefixOne\"; edit_width=20; value = \"\"; fixed_width = true; width = 20; alignment = right;  }      // редактируемое текстовое поле                  "
"        } // конец concatenation                                                                                                                                                            "
"                                                                                                                                                                                            "
"        : concatenation {children_fixed_width = true;  alignment = left; children_alignment = centered ; fixed_width = true; width = 40;                                                    "
"          : text {label = \"Первый стартовый номер:\"; alignment = left; fixed_width = true; width = 30; key = \"dclSbgPDStartOneLabel\"; }   // текстовое поле                                                               "
"          : edit_box {key = \"dclSbgPDStartOne\"; edit_width=20; value = \"1\"; fixed_width = true; width = 20; alignment = right;  }      // редактируемое текстовое поле                  "  
"        } // конец concatenation                                                                                                                                                            "
"                                                                                                                                                                                            "
"        : concatenation {children_fixed_width = true;  alignment = left; children_alignment = centered ; fixed_width = true; width = 40;                                                    "
"          : text {label = \"Первый инкремент:\"; alignment = left; fixed_width = true; width = 30; key = \"dclSbgPDStepOneLabel\"; }   // текстовое поле                                                                     "
"          : edit_box {key = \"dclSbgPDStepOne\"; edit_width=20; value = \"1\"; fixed_width = true; width = 20; alignment = right;  }      // редактируемое текстовое поле                   "  
"        } // конец concatenation                                                                                                                                                            "
"                                                                                                                                                                                            "
"        : concatenation {children_fixed_width = true;  alignment = left; children_alignment = centered ; fixed_width = true; width = 40;                                                    "
"          : text {label = \"Первый суффикс:\"; alignment = left; fixed_width = true; width = 30;}   // текстовое поле                                                                       "
"          : edit_box {key = \"dclSbgPDSufixOne\"; edit_width=20; value = \"\"; fixed_width = true; width = 20; alignment = right;  }      // редактируемое текстовое поле                   "
"        } // конец concatenation                                                                                                                                                            "
"                                                                                                                                                                                            "
"        : concatenation {children_fixed_width = true;  alignment = left; children_alignment = centered ; fixed_width = true; width = 40;                                                    "
"          : text {label = \"Второй стартовый номер:\"; alignment = left; fixed_width = true; width = 30; key = \"dclSbgPDStartDubleLabel\"; }   // текстовое поле                           " 
"          : edit_box {key = \"dclSbgPDStartDuble\"; edit_width=20; value = \"2\"; fixed_width = true; width = 20; alignment = right;  }      // редактируемое текстовое поле                "  
"        } // конец concatenation                                                                                                                                                            "
"                                                                                                                                                                                            "
"        : concatenation {children_fixed_width = true;  alignment = left; children_alignment = centered ; fixed_width = true; width = 40;                                                    "
"          : text {label = \"Второй инкремент:\"; alignment = left; fixed_width = true; width = 30; key = \"dclSbgPDStepDubleLabel\";}   // текстовое поле                                   " 
"          : edit_box {key = \"dclSbgPDStepDuble\"; edit_width=20; value = \"2\"; fixed_width = true; width = 20; alignment = right;  }      // редактируемое текстовое поле                 "  
"        } // конец concatenation                                                                                                                                                            "
"                                                                                                                                                                                            "
"        : concatenation {children_fixed_width = true;  alignment = left; children_alignment = centered ; fixed_width = true; width = 40;                                                    "
"          : text {label = \"Второй суффикс:\"; alignment = left; fixed_width = true; width = 30; key = \"dclSbgPDSufixDubleLabel\";}   // текстовое поле                                    " 
"          : edit_box {key = \"dclSbgPDSufixDuble\"; edit_width=20; value = \"\"; fixed_width = true; width = 20; alignment = right;  }      // редактируемое текстовое поле                 "
"        } // конец concatenation                                                                                                                                                            "
"                                                                                                                                                                                            "
"                                                                                                                                                                                            "
"        : spacer{height=0.1;} // вставка пустой строки                                                                                                                                      "
"                                                                                                                                                                                            "
"        : boxed_column {                                                                                                                                                                    "
"           : boxed_radio_row { label = \"Количество счётчиков\";                                                                                                                            "
"              : radio_button {label = \" 0\"; key = \"dclSbgPDTypeRun0\"; value = \"0\"; alignment = centered; }                                                                            "
"              : radio_button {label = \" 1\"; key = \"dclSbgPDTypeRun1\"; value = \"1\"; alignment = centered; }                                                                            "
"              : radio_button {label = \" 2\"; key = \"dclSbgPDTypeRun2\"; value = \"0\"; alignment = centered; }                                                                            "
"        : spacer{height=0.5;} // вставка пустой строки                                                                                                                                      "
"        } // конец boxed_radio_row                                                                                                                                                          "
"        : spacer{height=0.5;} // вставка пустой строки                                                                                                                                      "
"          : toggle {label = \"Блокировать первый счётчик\"; key = \"dclSbgPDStopCalcOne\"; value = \"0\"; alignment = centered; }                                                           "
"          : toggle {label = \"Блокировать второй счётчик\"; key = \"dclSbgPDStopCalcDuble\"; value = \"0\"; alignment = centered; }                                                         "    
"          : toggle {label = \"Режим обработки таблиц\"; key = \"dclSbgPDTableMode\"; value = \"0\"; alignment = centered; }                                                                 "
"          : toggle {label = \"Включить декремент если мимо\"; key = \"dclSbgPDFunctionMissed\" ; value = \"1\"; alignment = centered; }                                                     "
"        } // конец boxed_column                                                                                                                                                             "
"                                                                                                                                                                                            "
"      } // конец boxed_column                                                                                                                                                               "
"                                                                                                                                                                                            "
"    ok_cancel ;   // добавление кнопок ОК и Отмена                                                                                                                                          "
"                                                                                                                                                                                            "
"}  // окончание диалога dcl_drenum_all                                                                                                                                                      "
"                                                                                                                                                                                            "
"                                                                                                                                                                                            "
"                                                                                                                                                                                            "
"//*******************************************************************************************************************                                                                       "
"//**************************Конец диалога dcl_drenum_all*************************************************************                                                                       "
"//*******************************************************************************************************************                                                                       "
"                                                                                                                                                                                            "
"//*******************************************************************************************************************                                                                       "
"//**************************Начало диалога dcl_drenum_help***********************************************************                                                                       "
"//*******************************************************************************************************************                                                                       "
"                                                                                                                                                                                            "
"dcl_drenum_help : dialog { key = \"dclSbgPDHelpTitle\";  label = \"  ---=={ DRENUM HELP }==---  \" ;                                                                                        "
"  spacer; : text  { label = \" --------------------------=={ Клавиши управления ренумератором }==---------------------------   \" ; }                                                       "
"  spacer;                                                                                                                                                                                   "
"  : row { fixed_width = true; alignment = centered;                                                                                                                                         "
"    : column {                                                                                                                                                                              "
"       : text { label = \"[\"     ; }                                                                                                                                                       "
"       : text { label = \"[\"     ; }                                                                                                                                                       "
"       : text { label = \"[\"     ; }                                                                                                                                                       "
"       : text { label = \"[\"     ; }                                                                                                                                                       "
"       : text { label = \"[\"     ; }                                                                                                                                                       "
"       : text { label = \"[\"     ; }                                                                                                                                                       "
"       : text { label = \"[\"     ; }                                                                                                                                                       "
"       : text { label = \"[\"     ; }                                                                                                                                                       "
"       : text { label = \"[\"     ; }                                                                                                                                                       "
"       : text { label = \"[\"     ; }                                                                                                                                                       "
"       : text { label = \"[\"     ; }                                                                                                                                                       "
"       : text { label = \"[\"     ; }                                                                                                                                                       "
"       : text { label = \"[\"     ; }                                                                                                                                                       "
"    }                                                                                                                                                                                       "
"    : column {                                                                                                                                                                              "
"       : text { label = \"-\"     ; }                                                                                                                                                       "
"       : text { label = \"+\"     ; }                                                                                                                                                       "
"       : text { label = \"9\"     ; }                                                                                                                                                       "
"       : text { label = \"0\"     ; }                                                                                                                                                       "
"       : text { label = \"(\"     ; }                                                                                                                                                       "
"       : text { label = \")\"     ; }                                                                                                                                                       "
"       : text { label = \"1\"     ; }                                                                                                                                                       "
"       : text { label = \"2\"     ; }                                                                                                                                                       "
"       : text { label = \"3\"     ; }                                                                                                                                                       "
"       : text { label = \"4\"     ; }                                                                                                                                                       "
"       : text { label = \"5\"     ; }                                                                                                                                                       "
"       : text { label = \"H\"     ; }                                                                                                                                                       "
"       : text { label = \"ПКМ\"   ; }                                                                                                                                                       "
"    }                                                                                                                                                                                       "
"    : column {                                                                                                                                                                              "
"       : text { label = \"]\"     ; }                                                                                                                                                       "
"       : text { label = \"]\"     ; }                                                                                                                                                       "
"       : text { label = \"]\"     ; }                                                                                                                                                       "
"       : text { label = \"]\"     ; }                                                                                                                                                       "
"       : text { label = \"]\"     ; }                                                                                                                                                       "
"       : text { label = \"]\"     ; }                                                                                                                                                       "
"       : text { label = \"]\"     ; }                                                                                                                                                       "
"       : text { label = \"]\"     ; }                                                                                                                                                       "
"       : text { label = \"]\"     ; }                                                                                                                                                       "
"       : text { label = \"]\"     ; }                                                                                                                                                       "
"       : text { label = \"]\"     ; }                                                                                                                                                       "
"       : text { label = \"]\"     ; }                                                                                                                                                       "
"       : text { label = \"]\"     ; }                                                                                                                                                       "
"    }                                                                                                                                                                                       "
"    spacer;                                                                                                                                                                                 "
"    : column {                                                                                                                                                                              "
"      : text { label = \"Отрицательное инкрементирование обоих счётчиков. \"   ; }                                                                                                          "
"      : text { label = \"Положительное инкрементирование обоих счётчиков. \"   ; }                                                                                                          "
"      : text { label = \"Отрицательное инкрементирование первого счётчика.\"   ; }                                                                                                          "
"      : text { label = \"Положительное инкрементирование первого счётчика.\"   ; }                                                                                                          "
"      : text { label = \"Отрицательное инкрементирование второго счётчика.\"   ; }                                                                                                          "
"      : text { label = \"Положительное инкрементирование второго счётчика.\"   ; }                                                                                                          "
"      : text { label = \"Блокировать/разблокировать первый счётчик.       \"   ; }                                                                                                          "
"      : text { label = \"Блокировать/разблокировать второй счётчик.       \"   ; }                                                                                                          "
"      : text { label = \"Вызвать диалог ввода/изменения значений.         \"   ; }                                                                                                          "
"      : text { label = \"Включить/выключить режим работы с таблицами.     \"   ; }                                                                                                          "
"      : text { label = \"Включить/выключить декремент при промахивании    \"   ; }                                                                                                          "
"      : text { label = \"Вызвать окно помощи.                             \"   ; }                                                                                                          "
"      : text { label = \"Выход из программы по нажатию правой кнопки мыши.\"   ; }                                                                                                          "
"    }                                                                                                                                                                                       "
"  }                                                                                                                                                                                         "
"  spacer_1;                                                                                                                                                                                 "
"  : text { label = \"  --------------------------=={ Клавиши управления ренумератором }==---------------------------  \" ; }                                                                "
"  spacer_1; ok_only;                                                                                                                                                                        "
"}                                                                                                                                                                                           "
"                                                                                                                                                                                            "
"//*******************************************************************************************************************                                                                       "
"//**************************Конец диалога dcl_drenum_all*************************************************************                                                                       "
"//*******************************************************************************************************************                                                                       "
"                                                                                                                                                                                            ")
    (write-line item sbgPDHandle)
    ) ;_ end of foreach
  (close sbgPDHandle)
  (SBGPDMAINSTARTWINDOWS)             ;| вызываем функцию вызова основного окна ввода значений |;
  (if (= sbgPDIDStatus 1)  (progn     ;| если диалог закрылся кнопкой "ОК" |;
  (while (= sbgPDIDStatus 1)                            ;| то начинаем "слушать" входящие сообщения от системы в цикле |;
       (progn
          (setq gr1 (grread t 15 2)           ;| принимает от системы сигнал в формате (5 (270.4564 356.3341)) или (2 100) где 5 - просто водим мышкой, 3 - нажата мышка (клик), 2 - нажата клавиатура и код клавиши в нумерации ASCII. |;
                    sbgPDAllCoordinate gr1    ;| для дальнейшей обработки копируем значение полученное из буфера |;
                    gr2 (cadr gr1)            ;| получаем второе содержимое ввода, при вводе с клавиатуры там будет номер введённого символа. |;
                    gr1 (car  gr1)            ;| получаем код пришедшего события, нас интересуют номера 2 и 3 |;
             )            
      (if (= 3 gr1) (progn       ;| если произошло нажатие кнопки мыши, то  |;
                           (setq sbgPDCoordinateForSsget (list (car(cadr sbgPDAllCoordinate)) (cadr(cadr sbgPDAllCoordinate)))) ;| перерабатываем координаты в удобоваримые для команды netselp |;                             
                           (if (= sbgPDTableMode 1)
                                (progn
                                (GET_NUMBER_CELL_TABLE sbgPDCoordinateForSsget) ; вызываем функцию обработки таблицы и если там всё хорошо то получаем координаты таблицы
                                (CALCULATION_AND_ASSIGNMENT) ;| вызываем саму функцию ренумератора |;          
                                ) ; end progn
                                (progn                         
                                     (setq sbgPDCurText (car(nentselp (list (nth 0 sbgPDCoordinateForSsget)(nth 1 sbgPDCoordinateForSsget)) )) ) ;| если там что то есть, то получаем имя объекта и присваиваем его значение переменной |; 
                                     (CALCULATION_AND_ASSIGNMENT) ;| вызываем саму функцию ренумератора |;
                                ) ; end progn  
                           ) ; end if                                                         
                    ) ; end progn
      ) ; enf if  ; если мышь движется, то мы просто вызываем ренум функцию   ;;;; (or (= 5 gr1) (= 3 gr1)) старый формат
      (if (= 2 gr1) (progn      ;| если произошло нажатие кнопки клавиатуры, то мы сверяемся со списком и если есть то обрабатываем значения |;
                          (cond
                                (   (member gr2 '(043 061))                          ;| смотрим есть ли в переменной gr2 код клавиши "+" или "=" |;
                                    (if (>= sbgPDTypeRun 1) (progn                   ;| если включён хотя бы один из счётчиков |;                                    
                                                                  (setq 
                                                                       tempSbgPDStopCalcOne sbgPDStopCalcOne       ;| запоминаем значение переменных  |;
                                                                       tempsbgPDStopCalcDuble sbgPDStopCalcDuble
                                                                       sbgPDStopCalcOne  0                         ;| присваиваем значения, разрешающих работу |;
                                                                       sbgPDStopCalcDuble 0
                                                                  ) ; end setq
                                                                  (CALCULATION_PLUS_FOR_RENUM)                     ;| считаем в плюс весь счётчик |;
                                                                  (setq 
                                                                       sbgPDStopCalcOne tempSbgPDStopCalcOne       ;| возвращаем предыдущие значения |;
                                                                       sbgPDStopCalcDuble tempsbgPDStopCalcDuble 
                                                                  ) ; end setq
                                                                  (PRINT_STANDART_TEKST_FOR_CONSOLE)               ;| печатаем текст в консоли |;
                                                            ) ; end progn
                                    ) ; end if
                                )
                                (   (member gr2 '(045 095))                          ;| смотрим есть ли в переменной gr2 код клавиши "-" или "_" |;
                                    (if (>= sbgPDTypeRun 1) (progn                   ;| если включён хотя бы один из счётчиков |;                                    
                                                                  (setq 
                                                                       tempSbgPDStopCalcOne sbgPDStopCalcOne       ;| запоминаем значение переменных  |;          
                                                                       tempsbgPDStopCalcDuble sbgPDStopCalcDuble                                                   
                                                                       sbgPDStopCalcOne  0                         ;| присваиваем значения, разрешающих работу |; 
                                                                       sbgPDStopCalcDuble 0
                                                                  ) ; end setq
                                                                  (CALCULATION_MINUS_FOR_RENUM)                    ;| считаем в минус |;
                                                                  (setq 
                                                                       sbgPDStopCalcOne tempSbgPDStopCalcOne       ;| возвращаем предыдущие значения |;
                                                                       sbgPDStopCalcDuble tempsbgPDStopCalcDuble 
                                                                  ) ; end setq
                                                                  (PRINT_STANDART_TEKST_FOR_CONSOLE)               ;| печатаем текст в консоли |; 
                                                            ) ; end progn      
                                    ) ; end if                                                         
                                )                                
                                (   (member gr2 '(048))                              ;| смотрим есть ли в переменной gr2 код клавиши "0" |;
                                    (if (>= sbgPDTypeRun 1) (progn                   ;| если включён хотя бы один из счётчиков |;                                     
                                                                   (setq 
                                                                       tempSbgPDStopCalcOne sbgPDStopCalcOne       ;| запоминаем значение переменных  |;          
                                                                       tempsbgPDStopCalcDuble sbgPDStopCalcDuble                                                   
                                                                       sbgPDStopCalcOne  0                         ;| присваиваем значения, разрешающих работу |; 
                                                                       sbgPDStopCalcDuble 1
                                                                  ) ; end setq
                                                                  (CALCULATION_PLUS_FOR_RENUM)                     ;| считаем в плюс весь счётчик |;
                                                                  (setq 
                                                                       sbgPDStopCalcOne tempSbgPDStopCalcOne       ;| возвращаем предыдущие значения |;
                                                                       sbgPDStopCalcDuble tempsbgPDStopCalcDuble 
                                                                  ) ; end setq
                                                                  (PRINT_STANDART_TEKST_FOR_CONSOLE)               ;| печатаем текст в консоли |;
                                                            ) ; end progn
                                    ) ; end if                                                                       
                                )
                                (   (member gr2 '(057))                              ;| смотрим есть ли в переменной gr2 код клавиши "9" |;
                                    (if (>= sbgPDTypeRun 1) (progn                   ;| если включён хотя бы один из счётчиков |;                                   
                                                                  (setq 
                                                                       tempSbgPDStopCalcOne sbgPDStopCalcOne       ;| запоминаем значение переменных  |;          
                                                                       tempsbgPDStopCalcDuble sbgPDStopCalcDuble                                                   
                                                                       sbgPDStopCalcOne  0                         ;| присваиваем значения, разрешающих работу |; 
                                                                       sbgPDStopCalcDuble 1
                                                                  ) ; end setq
                                                                  (CALCULATION_MINUS_FOR_RENUM)                    ;| считаем в минус |;
                                                                  (setq 
                                                                       sbgPDStopCalcOne tempSbgPDStopCalcOne       ;| возвращаем предыдущие значения |;
                                                                       sbgPDStopCalcDuble tempsbgPDStopCalcDuble 
                                                                  ) ; end setq
                                                                  (PRINT_STANDART_TEKST_FOR_CONSOLE)               ;| печатаем текст в консоли |;  
                                                            ) ; end progn
                                    ) ; end if                          
                                )
                                (   (member gr2 '(041))                              ;| смотрим есть ли в переменной gr2 код клавиши ")" |;
                                    (if (= sbgPDTypeRun 2) (progn                   ;| если включён второй счётчик |;                                    
                                                                (setq 
                                                                     tempSbgPDStopCalcOne sbgPDStopCalcOne       ;| запоминаем значение переменных  |;          
                                                                     tempsbgPDStopCalcDuble sbgPDStopCalcDuble                                                   
                                                                     sbgPDStopCalcOne  1                         ;| присваиваем значения, разрешающих работу |; 
                                                                     sbgPDStopCalcDuble 0
                                                                ) ; end setq
                                                                (CALCULATION_PLUS_FOR_RENUM)                     ;| считаем в плюс весь счётчик |;
                                                                (setq 
                                                                     sbgPDStopCalcOne tempSbgPDStopCalcOne       ;| возвращаем предыдущие значения |;
                                                                     sbgPDStopCalcDuble tempsbgPDStopCalcDuble 
                                                                ) ; end setq
                                                                (PRINT_STANDART_TEKST_FOR_CONSOLE)               ;| печатаем текст в консоли |;
                                                           ) ; end progn
                                    ) ; end if
                                )
                                (   (member gr2 '(040))                              ;| смотрим есть ли в переменной gr2 код клавиши "(" |;
                                    (if (= sbgPDTypeRun 2) (progn                   ;| если включён второй счётчик |;                                     
                                                                (setq 
                                                                     tempSbgPDStopCalcOne sbgPDStopCalcOne       ;| запоминаем значение переменных  |;          
                                                                     tempsbgPDStopCalcDuble sbgPDStopCalcDuble                                                   
                                                                     sbgPDStopCalcOne  1                         ;| присваиваем значения, разрешающих работу |; 
                                                                     sbgPDStopCalcDuble 0
                                                                ) ; end setq
                                                                (CALCULATION_MINUS_FOR_RENUM)                    ;| считаем в минус |;
                                                                (setq 
                                                                     sbgPDStopCalcOne tempSbgPDStopCalcOne       ;| возвращаем предыдущие значения |;
                                                                     sbgPDStopCalcDuble tempsbgPDStopCalcDuble 
                                                                ) ; end setq
                                                                (PRINT_STANDART_TEKST_FOR_CONSOLE)               ;| печатаем текст в консоли |;
                                                           ) ; end progn
                                    ) ; end if                            
                                )                                                                
                                (   (member gr2 '(033 049))                          ;| смотрим есть ли в переменной gr2 код клавиши "1" или "!" |;
                                    (if (>= sbgPDTypeRun 1) (progn                   ;| если включён хотя бы один из счётчиков |;
                                                                  (if (= sbgPDStopCalcOne 0) (progn (setq sbgPDStopCalcOne 1) (princ "\nПервый счётчик блокирован") ) (progn (setq sbgPDStopCalcOne 0) (princ "\nПервый счётчик разблокирован") ) )  ;| инвертируем значение переменной и сообщаем об этом |; 
                                                                  (PRINT_STANDART_TEKST_FOR_CONSOLE)               ;| печатаем текст в консоли |;
                                                            ) ; enf progn
                                    ) ; end if                              
                                )
                                (   (member gr2 '(034 064 050))                      ;| смотрим есть ли в переменной gr2 код клавиши "2" или """ или "@" |;
                                    (if (= sbgPDTypeRun 2) (progn                   ;| если включён второй счётчик |;
                                                                  (if (= sbgPDStopCalcDuble 0) (progn (setq sbgPDStopCalcDuble 1) (princ "\nВторой счётчик блокирован") ) (progn (setq sbgPDStopCalcDuble 0) (princ "\nВторой счётчик разблокирован") ) ) ;| инвертируем значение переменной и сообщаем об этом |; 
                                                                  (PRINT_STANDART_TEKST_FOR_CONSOLE)               ;| печатаем текст в консоли |;
                                                            ) ; enf progn
                                    ) ; end if                                                                                                                          
                                )                                                             
                                (   (member gr2 '(035 051 8470))                     ;| смотрим есть ли в переменной gr2 код клавиши "3" или "#" или "№" |;
                                    (SBGPDMAINSTARTWINDOWS)                          ;| вызываем функцию вызова основного окна ввода значений |;
                                    (PRINT_STANDART_TEKST_FOR_CONSOLE)               ;| печатаем текст в консоли |;
                                )
                                (   (member gr2 '(036 052 059))                      ;| смотрим есть ли в переменной gr2 код клавиши "4" или "$" или ";" |;
                                    (if (= sbgPDTableMode 0) (progn (setq sbgPDTableMode 1) (princ "\nВключен режим работы с таблицами") ) (progn (setq sbgPDTableMode 0) (princ "\nВыключен режим работы с таблицами") ) ) ;| инвертируем значение переменной и сообщаем об этом |;
                                    (PRINT_STANDART_TEKST_FOR_CONSOLE)               ;| печатаем текст в консоли |;
                                )    
                                (   (member gr2 '(037 053))                          ;| смотрим есть ли в переменной gr2 код клавиши "5" или "%" |;
                                    (if (>= sbgPDTypeRun 1) (progn                   ;| если включён хотя бы один из счётчиков |;
                                                                  (if (= sbgPDFunctionMissed 0) (progn (setq sbgPDFunctionMissed 1) (princ "\nВключен режим декремент") ) (progn (setq sbgPDFunctionMissed 0) (princ "\nВыключен режим декремент") ) ) ;| инвертируем значение переменной и сообщаем об этом |;
                                                                  (PRINT_STANDART_TEKST_FOR_CONSOLE)               ;| печатаем текст в консоли |;
                                                            ) ; enf progn
                                    ) ; end if                                                                                                                                      
                                )                                                          
                                (   (member gr2 '(072 104 1056 1088))                ;| смотрим есть ли в переменной gr2 код клавиши "H" или "h" или "Р" "р" |; 
                                    (SBGPDHELPWINDOWS)                               ;| вызываем функцию вызова окна помощи |;
                                )                                                                
                                (   t   )
                          ) ; end cond
                    ) ; end progn
      ) ; end if
      (if (= 25 gr1) (setq sbgPDIDStatus 0) )  ;| если ПКМ то на выход |; 
    
                      ) ; end progn
       ) ; end while 
) ; end progn
) ; end if
  (princ)
) ; окончание функции DRENUM  


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;Функция самого цикла счёта и присвоения;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defun CALCULATION_AND_ASSIGNMENT ()
    (CALCULATION_STRING_FOR_RENUM) ; подготовим текст          
    (if (= sbgPDTableMode 1)  
        (progn   ;| если режим таблицы |;
           (if sbgPDTempTableNameSelectCell ; если не пусто, то 
               (progn          ;| если ячейка, то присваиваем и увеличиваем счётчик |;
                   (vla-setText sbgPDTempTableNameSelectCell sbgPDTempRowSelectCell sbgPDTtempColumnSelectCell sbgPDCurString ) ;| присваиваем выбранной ячейке созданный текст и готовим следующий |;
                   (CALCULATION_PLUS_FOR_RENUM)         ;| считаем в плюс |; 
                   (PRINT_STANDART_TEKST_FOR_CONSOLE)   ;| печатаем текст в консоль |;
               ) ; end progn
               (progn   ;| если пусто, то ругаемся и уменьшаем счётчик, если разрешено |;
                   (princ "\n<!> Ячейка таблицы не обнаружена <!>") ;| ругаемся |;
                   (if (= sbgPDFunctionMissed 1)
                        (CALCULATION_MINUS_FOR_RENUM)         ;| считаем в минус |;
                   ) ; end if
                   (PRINT_STANDART_TEKST_FOR_CONSOLE)    ;| печатаем текст в консоли |;
               ) ; end progn
           ) ; end if    
        ) ; end progn
        (progn    ;| если простой режим ренумератора |;
           (if (and sbgPDCurText 
                    (member(cdr(assoc 0(entget sbgPDCurText))) '("TEXT" "MTEXT" "ATTRIB" "MULTILEADER"))                    
               ) ;| end and |;
                     (progn                               ;| если содержит, то присваиваем и увеличиваем счётчик |;
                           (if (and (member(cdr(assoc 0(entget sbgPDCurText))) '("MULTILEADER")) (= 1 (vla-get-ContentType (VLAX-ENAME->VLA-OBJECT sbgPDCurText)) ) ) ;| если содержит необрабатываемую мультивыноску, то не обрабатываем |;
                                   (progn    ;| если содержит, то ругаемся и уменьшаем счётчик |;
                                         (princ "\n<!> Этот тип MULTILEADER не обрабатывается <!>")  ;| ругаемся |;
                                         (if (= sbgPDFunctionMissed 1)
                                            (CALCULATION_MINUS_FOR_RENUM)         ;| считаем в минус |;
                                         ) ; end if
                                         (PRINT_STANDART_TEKST_FOR_CONSOLE)    ;| печатаем текст в консоли |;
                                   ) ; end progn                                   
                                   (progn   ;| если не содержит то присваиваем и увеличиваем счётчик |;
                                         (vla-put-TextString 
                                         (vlax-ename->vla-object sbgPDCurText)sbgPDCurString) ;| присваиваем выбранному объекту созданный текст и готовим следующий |;
                                         (CALCULATION_PLUS_FOR_RENUM)         ;| считаем в плюс |;                        
                                         (PRINT_STANDART_TEKST_FOR_CONSOLE)   ;| печатаем текст в консоль |;         
                                   ) ; end progn
                           ) ; end if                                                 
                     ) ; end progn                        
                     (progn                               ;| если не содержит, то ругаемся и уменьшаем счётчик |;
                           (princ "\n<!> Это не TEXT или MTEXT или ATTRIB или MULTILEADER <!>")  ;| ругаемся |;
                           (if (= sbgPDFunctionMissed 1)
                              (CALCULATION_MINUS_FOR_RENUM)         ;| считаем в минус |;
                           ) ; end if
                           (PRINT_STANDART_TEKST_FOR_CONSOLE)    ;| печатаем текст в консоли |;
                     ) ; end progn 
           ) ; end if 
        ) ; end progn
    ) ; end if   
       
) ; end defun CALCULATION_AND_ASSIGNMENT
                                                       
                                                                                                                                              
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;Функция сбора текстовой строки sbgPDCurString ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; 

(defun CALCULATION_STRING_FOR_RENUM () 
    (setq sbgPDCurString (strcat sbgPDPrefixOne (if (>= sbgPDTypeRun 1) (itoa sbgPDStartOne) "" ) sbgPDSufixOne )) 
    (if (= sbgPDTypeRun 2) (setq sbgPDCurString (strcat sbgPDCurString (itoa sbgPDStartDuble)sbgPDSufixDuble)))
   ) ; end defun  CALCULATION_AND_ASSIGNMENT
 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;Функция положительного счёта ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; 

(defun CALCULATION_PLUS_FOR_RENUM () 
   (if (>= sbgPDTypeRun 1) (progn
                                 (if (/= sbgPDStopCalcOne 1) (setq sbgPDStartOne(+ sbgPDStepOne sbgPDStartOne)) ) 
                                 (if (= sbgPDTypeRun 2) (if (/= sbgPDStopCalcDuble 1) (setq sbgPDStartDuble(+ sbgPDStartDuble sbgPDStepDuble)) ) )
                           ) ; end progn
   ) ; end if
   ) ; end defun  CALCULATION_PLUS_FOR_RENUM
 

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;Функция отрицательного счёта ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; 

(defun CALCULATION_MINUS_FOR_RENUM () 
   (if (>= sbgPDTypeRun 1) (progn
                                 (if (/= sbgPDStopCalcOne 1) (setq sbgPDStartOne(- sbgPDStartOne sbgPDStepOne)) )
                                 (if (= sbgPDTypeRun 2) (if (/= sbgPDStopCalcDuble 1) (setq sbgPDStartDuble(- sbgPDStartDuble sbgPDStepDuble)) ) )
                           ) ; end progn   
   ) ; end if                           
   ) ; end defun  CALCULATION_MINUS_FOR_RENUM

 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;Функция печати строки консоли ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; 

(defun PRINT_STANDART_TEKST_FOR_CONSOLE () 
     (princ (strcat "\n" (if (>= sbgPDTypeRun 1) (strcat "Перв. счёт. " (if (= sbgPDStopCalcOne 1) "®" "•" ) " [<9> или <0>] старт/стоп [1]. ") "" ) (if (= sbgPDTypeRun 2) (strcat "Втор. счёт. " (if (= sbgPDStopCalcDuble 1) "®" "•" ) " [<(> или <)>] старт/стоп [2]. " ) "" ) (if (>= sbgPDTypeRun 1) "Оба счёт. [<-> или <+>]. " ""  ) "Режим таблицы " (if (= sbgPDTableMode 0) "®" "•" ) " старт/стоп [4]." (if (>= sbgPDTypeRun 1) (strcat " Режим декремент " (if (= sbgPDFunctionMissed 0) "®" "•" ) " старт/стоп [5]." ) "" ) " Помощь [H]" ) )
     (princ "\nСледующий текст будет: ")
     (CALCULATION_STRING_FOR_RENUM) 
     (princ sbgPDCurString)
   ) ; end defun  CALCULATION_MINUS_FOR_RENUM


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;Функция установки значений для action_tile "dclSbgPDTypeRun;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defun ACTION_TILE_ON_DCLSBGPDTYPERUN ()

  (if (= (get_tile "dclSbgPDTypeRun0") "1") (progn   ;| без счётчиков, гасим их |; 
                                               (mode_tile "dclSbgPDStartOneLabel" 1)   ; отключаем
                                               (mode_tile "dclSbgPDStartOne" 1)        ; отключаем
                                               (mode_tile "dclSbgPDStepOneLabel" 1)    ; отключаем
                                               (mode_tile "dclSbgPDStepOne" 1)         ; отключаем                                                
                                               (mode_tile "dclSbgPDStopCalcOne" 1)     ; отключаем                                                                                            
                                               (mode_tile "dclSbgPDFunctionMissed" 1)  ; отключаем                       
                                               (mode_tile "dclSbgPDStartDubleLabel" 1) ; отключаем
                                               (mode_tile "dclSbgPDStartDuble" 1)      ; отключаем
                                               (mode_tile "dclSbgPDStepDubleLabel" 1)  ; отключаем
                                               (mode_tile "dclSbgPDStepDuble" 1)       ; отключаем
                                               (mode_tile "dclSbgPDSufixDubleLabel" 1) ; отключаем
                                               (mode_tile "dclSbgPDSufixDuble" 1)      ; отключаем
                                               (mode_tile "dclSbgPDStopCalcDuble" 1)   ; отключаем                                                
                                           ) ; конец progn
  ) ; конец if
  (if (= (get_tile "dclSbgPDTypeRun1") "1") (progn   ;| с одним счётчиком, гасим второй |;
                                               (mode_tile "dclSbgPDStartOneLabel" 0)   ; включаем
                                               (mode_tile "dclSbgPDStartOne" 0)        ; включаем
                                               (mode_tile "dclSbgPDStepOneLabel" 0)    ; включаем
                                               (mode_tile "dclSbgPDStepOne" 0)         ; включаем
                                               (mode_tile "dclSbgPDStopCalcOne" 0)     ; включаем
                                               (mode_tile "dclSbgPDFunctionMissed" 0)  ; включаем
                                               (mode_tile "dclSbgPDStartDubleLabel" 1) ; отключаем
                                               (mode_tile "dclSbgPDStartDuble" 1)      ; отключаем
                                               (mode_tile "dclSbgPDStepDubleLabel" 1)  ; отключаем
                                               (mode_tile "dclSbgPDStepDuble" 1)       ; отключаем
                                               (mode_tile "dclSbgPDSufixDubleLabel" 1) ; отключаем
                                               (mode_tile "dclSbgPDSufixDuble" 1)      ; отключаем
                                               (mode_tile "dclSbgPDStopCalcDuble" 1)   ; отключаем
                                           ) ; конец progn
  ) ; конец if 
  (if (= (get_tile "dclSbgPDTypeRun2") "1") (progn   ;| с двумя счётчиками, зажигаем оба |;
                                                 (mode_tile "dclSbgPDStartOneLabel" 0)   ; включаем
                                                 (mode_tile "dclSbgPDStartOne" 0)        ; включаем
                                                 (mode_tile "dclSbgPDStepOneLabel" 0)    ; включаем
                                                 (mode_tile "dclSbgPDStepOne" 0)         ; включаем
                                                 (mode_tile "dclSbgPDStopCalcOne" 0)     ; включаем 
                                                 (mode_tile "dclSbgPDFunctionMissed" 0)  ; включаем                          
                                                 (mode_tile "dclSbgPDStartDubleLabel" 0) ; включаем
                                                 (mode_tile "dclSbgPDStartDuble" 0)      ; включаем
                                                 (mode_tile "dclSbgPDStepDubleLabel" 0)  ; включаем
                                                 (mode_tile "dclSbgPDStepDuble" 0)       ; включаем
                                                 (mode_tile "dclSbgPDSufixDubleLabel" 0) ; включаем
                                                 (mode_tile "dclSbgPDSufixDuble" 0)      ; включаем
                                                 (mode_tile "dclSbgPDStopCalcDuble" 0)   ; включаем
                                             ) ; конец progn
  ) ; конец if 

 (setq sbgPDTypeRun (cond
                          ((= (atoi (get_tile "dclSbgPDTypeRun0")) 1)
                          0
                          )
                          ((= (atoi (get_tile "dclSbgPDTypeRun1")) 1)
                          1
                          )
                          ((= (atoi (get_tile "dclSbgPDTypeRun2")) 1)
                          2
                          )
                     ) ; end cond
  ) ; end setq

(princ)
) ; end defun ACTION_TILE_ON_DCLSBGPDTYPERUN 


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;Функция записи значений для программы ренумератора;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

( defun SBGPDREADVAR ()
   (vl-load-com)
  (setq sbgPDPrefixOne (get_tile "dclSbgPDPrefixOne"))
  (setq sbgPDSufixOne (get_tile "dclSbgPDSufixOne")) 
  (setq sbgPDTypeRun (cond
                          ((= (atoi (get_tile "dclSbgPDTypeRun0")) 1)
                          0
                          )
                          ((= (atoi (get_tile "dclSbgPDTypeRun1")) 1)
                          1
                          )
                          ((= (atoi (get_tile "dclSbgPDTypeRun2")) 1)
                          2
                          )
                     ) ; end cond
  ) ; end setq
  (setq sbgPDStopCalcOne (atoi (get_tile "dclSbgPDStopCalcOne")))
  (setq sbgPDStopCalcDuble (atoi (get_tile "dclSbgPDStopCalcDuble")))
  (setq sbgPDTableMode (atoi (get_tile "dclSbgPDTableMode")))
  (setq sbgPDFunctionMissed (atoi (get_tile "dclSbgPDFunctionMissed")))
  (setq sbgPDStartOne (atoi (get_tile "dclSbgPDStartOne")))
  (setq sbgPDStepOne (atoi (get_tile "dclSbgPDStepOne")))   
  (setq sbgPDStartDuble (atoi (get_tile "dclSbgPDStartDuble")))
  (setq sbgPDStepDuble (atoi (get_tile "dclSbgPDStepDuble")))
  (setq sbgPDSufixDuble (get_tile "dclSbgPDSufixDuble"))        
)  ; окончание функции SBGPDREADVAR  


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;Функция вызова основного окна;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defun SBGPDMAINSTARTWINDOWS ()
 (setq sbgPDDclIdNumber (load_dialog sbgPDFile))
  (if (not (new_dialog "dcl_drenum_all" sbgPDDclIdNumber))(exit)) ; указываем имя диалога
  ;; переменная sbgPDPrefixOne
  (if (null sbgPDPrefixOne)(setq sbgPDPrefixOne "")) ; если пустая стока, то помечаем её пустой 
  (set_tile "dclSbgPDPrefixOne" sbgPDPrefixOne) ; Если устанавливался какой либо текст - то ставим его 
  (action_tile "dclSbgPDPrefixOne" "(if (= $reason 1) (progn (mode_tile \"dclSbgPDStartOne\" 2)))") ;; если нажали ентер, то прыгаем дальше   
  ;; переменная sbgPDStartOne
  (if (null sbgPDStartOne) (setq sbgPDStartOne 1)) ; если пустая стока, то заполняем её 1
  (if (/= sbgPDStartOne 1) (set_tile "dclSbgPDStartOne" (itoa sbgPDStartOne))) ; Если стартовый номер уже менялся, то возвращаем изменённое значение
  (action_tile "dclSbgPDStartOne" "(if (and (= (atoi $value) 0) (/= $value \"0\")) (progn (alert \"Буквы не допустимы в этом окне!\")(mode_tile \"dclSbgPDStartOne\" 2)) (if (= $reason 1) (progn (mode_tile \"dclSbgPDStepOne\" 2) )))") ; если нажали ентер или таб, то проверяем что это положительное число и прыгаем дальше. Иначе стоп и ждём ввода
  ;; переменная sbgPDStepOne
  (if (null sbgPDStepOne) (setq sbgPDStepOne 1)) ; если пустая стока, то заполняем её 1
  (if (/= sbgPDStepOne 1) (set_tile "dclSbgPDStepOne" (itoa sbgPDStepOne))) ; Если стартовый номер уже менялся, то возвращаем изменённое значение
  (action_tile "dclSbgPDStepOne" "(if (and (= (atoi $value) 0) (/= $value \"0\")) (progn (alert \"Буквы не допустимы в этом окне!\")(mode_tile \"dclSbgPDStepOne\" 2)) (if (= $reason 1) (progn (mode_tile \"dclSbgPDSufixOne\" 2) )))") ; если нажали ентер или таб, то проверяем что это положительное число и прыгаем дальше. Иначе стоп и ждём ввода
  ;; переменная sbgPDSufixOne
  (if (null sbgPDSufixOne)(setq sbgPDSufixOne "")) ; если пустая стока, то помечаем её пустой 
  (set_tile "dclSbgPDSufixOne" sbgPDSufixOne) ; Если устанавливался какой либо текст - то ставим его 
  (action_tile "dclSbgPDSufixOne" "(if (= $reason 1) (progn (if (= sbgPDTypeRun 2)(mode_tile \"dclSbgPDStartDuble\" 2)) ))") ;; если нажали ентер, то прыгаем дальше  
  ;; переменная sbgPDStartDuble
  (if (null sbgPDStartDuble) (setq sbgPDStartDuble 2)) ; если пустая стока, то заполняем её 2
  (if (/= sbgPDStartDuble 2) (set_tile "dclSbgPDStartDuble" (itoa sbgPDStartDuble))) ; Если стартовый номер уже менялся, то возвращаем изменённое значение
  (action_tile "dclSbgPDStartDuble" "(if (and (= (atoi $value) 0) (/= $value \"0\")) (progn (alert \"Буквы не допустимы в этом окне!\")(mode_tile \"dclSbgPDStartDuble\" 2)) (if (= $reason 1) (progn (mode_tile \"dclSbgPDStepDuble\" 2) )))") ; если нажали ентер или таб, то проверяем что это положительное число и прыгаем дальше. Иначе стоп и ждём ввода
  ;; переменная sbgPDStepDuble
  (if (null sbgPDStepDuble) (setq sbgPDStepDuble 2)) ; если пустая стока, то заполняем её 2
  (if (/= sbgPDStepDuble 2) (set_tile "dclSbgPDStepDuble" (itoa sbgPDStepDuble))) ; Если стартовый номер уже менялся, то возвращаем изменённое значение
  (action_tile "dclSbgPDStepDuble" "(if (and (= (atoi $value) 0) (/= $value \"0\")) (progn (alert \"Буквы не допустимы в этом окне!\")(mode_tile \"dclSbgPDStepDuble\" 2)) (if (= $reason 1) (progn (mode_tile \"dclSbgPDSufixDuble\" 2) )))") ; если нажали ентер или таб, то проверяем что это положительное число и прыгаем дальше. Иначе стоп и ждём ввода
  ;; переменная sbgPDSufixDuble
  (if (null sbgPDSufixDuble)(setq sbgPDSufixDuble "")) ; если пустая стока, то помечаем её пустой 
  (set_tile "dclSbgPDSufixDuble" sbgPDSufixDuble) ; Если устанавливался какой либо текст - то ставим его 
  (action_tile "dclSbgPDSufixDuble" "(if (= $reason 1) (progn (if (= sbgPDTypeRun 2)(mode_tile \"accept\" 2)) ))") ;; если нажали ентер, то прыгаем дальше       
  ;; настройка переменной sbgPDTypeRun
  (if (null sbgPDTypeRun) (setq sbgPDTypeRun 1)) ; если пустая переменная, то заполняем её 1
  (if (/= sbgPDTypeRun 1) (progn  ;| Если уже менялся тип вызова окна, то возвращаем тот же тип окна |;
                              (if (= sbgPDTypeRun 0) (set_tile "dclSbgPDTypeRun0" "1")) ; устанавливаем флажок
                              (if (= sbgPDTypeRun 1) (set_tile "dclSbgPDTypeRun1" "1")) ; устанавливаем флажок
                              (if (= sbgPDTypeRun 2) (set_tile "dclSbgPDTypeRun2" "1")) ; устанавливаем флажок                          
                          ) ; end progn 
  ) ; end if   
  (if (= sbgPDTypeRun 0) (progn   ;| без счётчиков, гасим их |; 
                             (set_tile "dclSbgPDTypeRun0" "1")
                             (mode_tile "dclSbgPDStartOneLabel" 1)   ; отключаем
                             (mode_tile "dclSbgPDStartOne" 1)        ; отключаем
                             (mode_tile "dclSbgPDStepOneLabel" 1)    ; отключаем
                             (mode_tile "dclSbgPDStepOne" 1)         ; отключаем 
                             (mode_tile "dclSbgPDStopCalcOne" 1)     ; отключаем 
                             (mode_tile "dclSbgPDFunctionMissed" 1)  ; отключаем                  
                             (mode_tile "dclSbgPDStartDubleLabel" 1) ; отключаем
                             (mode_tile "dclSbgPDStartDuble" 1)      ; отключаем
                             (mode_tile "dclSbgPDStepDubleLabel" 1)  ; отключаем
                             (mode_tile "dclSbgPDStepDuble" 1)       ; отключаем
                             (mode_tile "dclSbgPDSufixDubleLabel" 1) ; отключаем
                             (mode_tile "dclSbgPDSufixDuble" 1)      ; отключаем
                             (mode_tile "dclSbgPDStopCalcDuble" 1)   ; отключаем 
                             ) ; конец progn
  ) ; end if
  (if (= sbgPDTypeRun 1) (progn   ;| с одним счётчиком, гасим второй |;                        
                             (set_tile "dclSbgPDTypeRun1" "1")
                             (mode_tile "dclSbgPDStartOneLabel" 0)   ; включаем
                             (mode_tile "dclSbgPDStartOne" 0)        ; включаем
                             (mode_tile "dclSbgPDStepOneLabel" 0)    ; включаем
                             (mode_tile "dclSbgPDStepOne" 0)         ; включаем
                             (mode_tile "dclSbgPDStopCalcOne" 0)     ; включаем
                             (mode_tile "dclSbgPDFunctionMissed" 0)  ; включаем
                             (mode_tile "dclSbgPDStartDubleLabel" 1) ; отключаем
                             (mode_tile "dclSbgPDStartDuble" 1)      ; отключаем
                             (mode_tile "dclSbgPDStepDubleLabel" 1)  ; отключаем
                             (mode_tile "dclSbgPDStepDuble" 1)       ; отключаем
                             (mode_tile "dclSbgPDSufixDubleLabel" 1) ; отключаем
                             (mode_tile "dclSbgPDSufixDuble" 1)      ; отключаем
                             (mode_tile "dclSbgPDStopCalcDuble" 1)   ; отключаем
                             ) ; конец progn
  ) ; end if 
  (if (= sbgPDTypeRun 2) (progn   ;| с двумя счётчиками, зажигаем оба |;
                             (set_tile "dclSbgPDTypeRun2" "1")
                             (mode_tile "dclSbgPDStartOneLabel" 0)   ; включаем
                             (mode_tile "dclSbgPDStartOne" 0)        ; включаем
                             (mode_tile "dclSbgPDStepOneLabel" 0)    ; включаем
                             (mode_tile "dclSbgPDStepOne" 0)         ; включаем 
                             (mode_tile "dclSbgPDStopCalcOne" 0)     ; включаем
                             (mode_tile "dclSbgPDFunctionMissed" 0)  ; включаем                          
                             (mode_tile "dclSbgPDStartDubleLabel" 0) ; включаем
                             (mode_tile "dclSbgPDStartDuble" 0)      ; включаем
                             (mode_tile "dclSbgPDStepDubleLabel" 0)  ; включаем
                             (mode_tile "dclSbgPDStepDuble" 0)       ; включаем
                             (mode_tile "dclSbgPDSufixDubleLabel" 0) ; включаем
                             (mode_tile "dclSbgPDSufixDuble" 0)      ; включаем
                             (mode_tile "dclSbgPDStopCalcDuble" 0)   ; включаем
                             ) ; конец progn
  ) ; end if   
  (action_tile "dclSbgPDTypeRun0" "(ACTION_TILE_ON_DCLSBGPDTYPERUN)") ; если ставим галочку, то зажигаем дополнительные поля ввода
  (action_tile "dclSbgPDTypeRun1" "(ACTION_TILE_ON_DCLSBGPDTYPERUN)") ; если ставим галочку, то зажигаем дополнительные поля ввода
  (action_tile "dclSbgPDTypeRun2" "(ACTION_TILE_ON_DCLSBGPDTYPERUN)") ; если ставим галочку, то зажигаем дополнительные поля ввода
  ;; переменная sbgPDStopCalcOne
 (if (null sbgPDStopCalcOne) (setq sbgPDStopCalcOne 0) ) ; если нет значений, то заполняем переменную
 (if (/= sbgPDStopCalcOne 0) (set_tile "dclSbgPDStopCalcOne" (itoa sbgPDStopCalcOne))) ; Если уже менялось значение, то возвращаем выбранное значение 
 (action_tile "dclSbgPDStopCalcOne" "(if (= (get_tile \"dclSbgPDStopCalcOne\") \"0\") (setq sbgPDStopCalcOne (atoi $value)) (setq sbgPDStopCalcOne (atoi $value)) ) ") ; если ставим галочку, то переменной задаём значение
  ;; переменная sbgPDStopCalcDuble
 (if (null sbgPDStopCalcDuble) (setq sbgPDStopCalcDuble 0) ) ; если нет значений, то заполняем переменную
 (if (/= sbgPDStopCalcDuble 0) (set_tile "dclSbgPDStopCalcDuble" (itoa sbgPDStopCalcDuble))) ; Если уже менялось значение, то возвращаем выбранное значение 
 (action_tile "dclSbgPDStopCalcDuble" "(if (= (get_tile \"dclSbgPDStopCalcDuble\") \"0\") (setq sbgPDStopCalcDuble (atoi $value)) (setq sbgPDStopCalcDuble (atoi $value)) ) ") ; если ставим галочку, то переменной задаём значение                                                                                   
  ;; переменная sbgPDTableMode
 (if (null sbgPDTableMode) (setq sbgPDTableMode 0) ) ; если нет значений, то заполняем переменную
 (if (/= sbgPDTableMode 0) (set_tile "dclSbgPDTableMode" (itoa sbgPDTableMode))) ; Если уже менялось значение, то возвращаем выбранное значение 
 (action_tile "dclSbgPDTableMode" "(if (= (get_tile \"dclSbgPDTableMode\") \"0\") (setq sbgPDTableMode (atoi $value)) (setq sbgPDTableMode (atoi $value)) ) ") ; если ставим галочку, то переменной задаём значение 
  ;; переменная sbgPDFunctionMissed
 (if (null sbgPDFunctionMissed) (setq sbgPDFunctionMissed 1) ) ; если нет значений, то заполняем переменную
 (if (/= sbgPDFunctionMissed 1) (set_tile "dclSbgPDFunctionMissed" (itoa sbgPDFunctionMissed))) ; Если уже менялось значение, то возвращаем выбранное значение 
 (action_tile "dclSbgPDFunctionMissed" "(if (= (get_tile \"dclSbgPDFunctionMissed\") \"1\") (setq sbgPDFunctionMissed (atoi $value)) (setq sbgPDFunctionMissed (atoi $value)) ) ") ; если ставим галочку, то переменной задаём значение  
;;;Стартующие action    ;|  |;
  (action_tile "accept" "(sbgPDReadvar)(done_dialog 1)")  ; Если нажата кнопка "аccept"
  (action_tile "cancel" "(done_dialog 0)") ; Если нажата кнопка "cancel"
;;;Конец сборок, дальше вызов самого окна диалога  
  ;;; Запускаем сам диалог 
  (setq sbgPDIDStatus (start_dialog))   
  (unload_dialog sbgPDDclIdNumber) ;| выгрузить диалоговое окно после окончания работы с ним, по нажатию одной из кнопок "Ок" или "Отмена"|;
) ; end defun SBGPDMAINSTARTWINDOWS


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;Функция вызова окна Help;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(defun SBGPDHELPWINDOWS ()
    (setq sbgPDDclIdNumber (load_dialog sbgPDFile))
    (if (not (new_dialog "dcl_drenum_help" sbgPDDclIdNumber))(exit)) ; указываем имя диалога
;;;Стартующие action    ;|  |;
  (action_tile "accept" "(done_dialog 1)")  ; Если нажата кнопка "аccept"
;;;Конец сборок, дальше вызов самого окна диалога  
  ;;; Запускаем сам диалог 
  (setq sbgPDIDStatus (start_dialog))   
  (unload_dialog sbgPDDclIdNumber) ;| выгрузить диалоговое окно после окончания работы с ним, по нажатию одной из кнопок "Ок" или "Отмена"|;
(princ)
) ; end defun SBGPDHELPWINDOWS


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;Функция экспортирования данных из таблицы в переменные блока;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun GET_NUMBER_CELL_TABLE ( sbgPDTempPointOfSelectCell / sbgPD_temp_ssget_select_all_tables
                                                                              sbgPD_temp_count
                                                                              sbgPD_temp_all_data_attrib_one_rows
                                                                              sbgPDOldEcho
                                           )            
  (vl-load-com)

  (setq sbgPDOldEcho (getvar "cmdecho")) ; запоминаем предыдущие установки переменной "cmdecho" 
  (setvar "cmdecho" 0) ; отключаем вывод в консоль 

  (setq sbgPDTempRowSelectCell nil) ; обнуляем для контроля
  (setq sbgPDTtempColumnSelectCell nil)
  (setq sbgPDTempTableNameSelectCell nil)

  (if (and
      	(setq sbgPDTempTableNameSelectCell nil
      	      sbgPD_temp_ssget_select_all_tables nil
      	      sbgPD_temp_ssget_select_all_tables (ssget "_X" '((0 . "ACAD_TABLE"))) ) ; end setq
      	(setq lst (mapcar 'vlax-ename->vla-object (vl-remove-if 'listp (mapcar 'cadr (ssnamex sbgPD_temp_ssget_select_all_tables)))) ) 
      	(mapcar '(lambda (x) (or sbgPDTempTableNameSelectCell (and (= :vlax-true (vla-HitTest x (vlax-3d-point (trans sbgPDTempPointOfSelectCell 1 0)) (vlax-3d-point (trans (getvar "VIEWDIR") 1 0)) 'row 'col ) ) (setq sbgPDTempTableNameSelectCell x) )) ) lst ) ; узнаём координаты ячейки
      	sbgPDTempTableNameSelectCell row col 
      ) ; end and                                   
      (progn   
           (setq sbgPDTempRowSelectCell row )    ; присваиваем переменным значения строки     
           (setq sbgPDTtempColumnSelectCell col ) ; значение столбца                                     
      ) ; end of progn
      (progn     
          (setq sbgPD_temp_ssget_select_all_tables nil   ; иначе всё обнуляем
                sbgPDTempRowSelectCell nil
                sbgPDTtempColumnSelectCell nil
                sbgPDTempTableNameSelectCell nil ) ; end setq
      ) ; end progn
  ) ;_ end of if 

  (setvar "cmdecho" sbgPDOldEcho) ; восстанавливаем предыдущее значение переменной "cmdecho"  

  (princ)

) ; end defun GET_NUMBER_CELL_TABLE

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;Общая часть ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(princ "\n \n \n")
(princ "\n[Info] Версия плагина 4.1                                              [Info]")
(princ "\n[Info] Инструмент перенумировки объектов:                              [Info]")
(princ "\n[Info] TEXT, DTEXT, MTEXT, ACAD_TABLE, МУЛЬТИВЫНОСКА и АТТРИБУТ БЛОКА. [Info]")
(princ "\n[Info] Для вызова команды наберите DRENUM                              [Info]")
(princ)
