Обновление размороженного мультитекста

void ads_regen();

M_Legend_Shaper::M_Legend_Shaper(M_Legend::MultilevelText& LegendText)
{
    this->LegendText=LegendText;
     pBlockTbl=NULL;
     MText=new AcDbMText();
     Contour=new AcDb2dPolyline();
     Angle=0;
     pRecord= NULL;
     Attachment =AcDbMText::AttachmentPoint::kBottomLeft;
     //Contour=new AcDbEntity();
     if(!GetHeight(Height)){
         Height=10;
     }
     Layer=_T("0");
     // Открываем БД текущего рисунка и получаем указатель на таблицу блоков
    // Получаем указатель на пространство модели как блок ACDB_MODEL_SPACE
    // открываем его для записи
    if(SetPointers()!=isAllowably){
        AfxMessageBox(_T("Возникли проблемы при открытии БД текущего рисунка или не получен один из важных указателей"));
    }
    SetStyle(L"Standard");
    
    CString TempText=ConvertMultilevelText(LegendText);
    The_second_point_is_established=false;
    The_point_is_established_at_preliminary_viewing=false;
}
M_Legend_Shaper::ShaperError M_Legend_Shaper::GetPointAnd2DPolyline(){
     AcDbObjectId objIdContour;
     ads_name entres;
       if( acedEntSel(_T("\n"),entres,BeginningPoint)!=RTNORM){
            acutPrintf(_T("Контур не выбран\n"));
            return isError;
       }
       else {
       }
       acdbGetObjectId(objIdContour,entres);
       if(Acad::eOk != acdbOpenObject(Contour,objIdContour,AcDb::kForRead)){
             acutPrintf(_T("Не открыт логически целостный элемент области\n"));
             return isError;
       }
       if (Contour->isA()!=AcDb2dPolyline::desc()){
           acutPrintf(_T("Выбранный объект не является 2d полилинией"));
           return isError;
       }
       return isAllowably;
}

M_Legend_Shaper::ShaperError M_Legend_Shaper::CreateLeader(){
    if(The_point_is_established_at_preliminary_viewing==false){
    if(The_second_point_is_established)
        return M_Legend_Shaper::ShaperError::isError;
    if (acedGetPoint(BeginningPoint, _T("\nУкажите положение текста технологической надписи:\n "), InvestigatePoint) != RTNORM){
              acutPrintf(_T("Точка не ввелась ... \n"));
       }
    The_second_point_is_established=true;
    }
    AcDbLeader* Leader=new AcDbLeader();
    Leader->appendVertex(Convert_adstoAcGe(BeginningPoint));
    Leader->appendVertex(Convert_adstoAcGe(InvestigateLeaderEndPoint));    
    Leader->enableArrowHead();
    Leader->setLayer(Layer.GetBuffer());
    if ((pRecord->appendAcDbEntity(Leader))!=Acad::eOk){
        acutPrintf(_T("\nОшибка добавления к БД мультитекста"));
        return isError;
    }
    Leader->close();
    return M_Legend_Shaper::ShaperError::isAllowably;
}

AcGePoint3d M_Legend_Shaper::Convert_adstoAcGe(ads_point& Point){
    AcGePoint3d AcGePoint3dPoint;
    CString m_strXPt;
    CString m_strYPt;
    CString m_strZPt;

        m_strXPt.Format(_T("%g"), Point[X]);
        m_strYPt.Format(_T("%g"), Point[Y]);
        m_strZPt.Format(_T("%g"), Point[Z]);

    acdbDisToF(m_strXPt, -1, &Point[X]);
    acdbDisToF(m_strYPt, -1, &Point[Y]);
    acdbDisToF(m_strZPt, -1, &Point[Z]);

    AcGePoint3dPoint.x=_tstof(m_strXPt.GetBuffer());
    AcGePoint3dPoint.y=_tstof(m_strYPt.GetBuffer());
    AcGePoint3dPoint.z=_tstof(m_strZPt.GetBuffer());

    return AcGePoint3dPoint;
}
M_Legend_Shaper::ShaperError M_Legend_Shaper::SetPointers(){
    dblock =new AcAxDocLock(acdbCurDwg());
             if(dblock->lockStatus() != Acad::eOk) {
                 acutPrintf(_T("\nНе удалось заблокировать базу"));
                 return isNotOpen;
              }

       if(acdbCurDwg()->getBlockTable(pBlockTbl, AcDb::kForRead)!=Acad::eOk){
            acutPrintf(_T("\nНе удалось получить блок"));
          
            return isNotOpen;
        }
        if(pBlockTbl->getAt(ACDB_MODEL_SPACE, pRecord, AcDb::kForWrite)){
            acutPrintf (_T("\nНет доступа к блоку *Model_Space. ")) ;
           
            return isNotOpen;
        }
        return isAllowably;
}

CString M_Legend_Shaper::ConvertMultilevelText(M_Legend::MultilevelText& LegendText){
    CString Text=L"";
    if(LegendText.AboveText!=L""){
          TextFlag=ViewText::AboveText;
    }
    else {
        if(LegendText.BelowText!=L""){
          TextFlag=ViewText::BelowText;
        }
        else {
          TextFlag=ViewText::LineText;
        }
    }
    if((LegendText.AboveText!=L""||LegendText.BelowText!=L"")&&LegendText.ReverseText!=L""){
        Text=L"\\A1;{\\H0.7x;\\S"+LegendText.AboveText+L"/"+LegendText.BelowText+L";}"+LegendText.ReverseText;
        return Text;
    }
    if((LegendText.AboveText!=L""||LegendText.BelowText!=L"")&&LegendText.FrontText!=L""){
        Text=L"\\A1;"+LegendText.FrontText+L"{\\H0.7x;\\S"+LegendText.AboveText+L"/"+LegendText.BelowText+L";}";
       
        return Text;
    }
    if((LegendText.AboveText==L""&&LegendText.BelowText==L"")&&LegendText.FrontText!=L""){
        Text=LegendText.FrontText;
        return Text;
    }
    if((LegendText.AboveText==L""&&LegendText.BelowText==L"")&&LegendText.ReverseText!=L""){
        Text=LegendText.ReverseText;
        return Text;
    }
    return Text;
}
bool M_Legend_Shaper::PreliminaryViewingText(){
    The_point_is_established_at_preliminary_viewing=true;
     struct resbuf rbFrom, rbTo;
      rbFrom.restype = RTSHORT;
    rbFrom.resval.rint = 1;
    rbTo.restype = RTSHORT;
    rbTo.resval.rint = 0;

    MLegendJig *pLegendJig
        = new MLegendJig(Convert_adstoAcGe(BeginningPoint),Convert_adstoAcGe(InvestigatePoint),Contour,TextFlag);
    pLegendJig->SetTextContent(ConvertMultilevelText(LegendText));
    pLegendJig->SetTextStyle(IdStyle);
    pLegendJig->SetTextHeight(Height);
    pLegendJig->SetTextAttachment(Attachment);

     pLegendJig->doIt();
    
     if(pLegendJig->inContour()==true){
       InvestigatePoint[0]=pLegendJig->GetSelectedMTextPoint().x;
       InvestigatePoint[1]=pLegendJig->GetSelectedMTextPoint().y;
       InvestigatePoint[2]=pLegendJig->GetSelectedMTextPoint().z;

       InvestigateLeaderEndPoint[0]=pLegendJig->GetSelectedLeaderEndPoint().x;
       InvestigateLeaderEndPoint[1]=pLegendJig->GetSelectedLeaderEndPoint().y;
       InvestigateLeaderEndPoint[2]=pLegendJig->GetSelectedLeaderEndPoint().z;

       InvestigateLineEndPoint[0]=pLegendJig->GetSelectedLineEndPoint().x;
       InvestigateLineEndPoint[1]=pLegendJig->GetSelectedLineEndPoint().y;
       InvestigateLineEndPoint[2]=pLegendJig->GetSelectedLineEndPoint().z;

       this->Angle=pLegendJig->GetSelectedAngle();
     }
    delete pLegendJig;
    return pLegendJig->inContour();
}

M_Legend_Shaper::ShaperError M_Legend_Shaper::CreateMText(){
    if(The_point_is_established_at_preliminary_viewing==false){

    if(The_second_point_is_established!=true){
           if (acedGetPoint(BeginningPoint, _T("\nУкажите положение текста технологической надписи:\n "), InvestigatePoint) != RTNORM){
              acutPrintf(_T("Точка не ввелась ... \n"));
              return isError;
           }
    }
    }
    AcGePoint3d TemporaryPoint=Convert_adstoAcGe(InvestigatePoint);

    Acad::ErrorStatus LgndErrorStatus;
        CString TempText=ConvertMultilevelText(LegendText);
        MText->setContents(TempText.GetBuffer());
        
        MText->setTextStyle(IdStyle);
        pRecord->appendAcDbEntity(MText->objectId(),MText);

        LgndErrorStatus=MText->setTextHeight(Height);
        LgndErrorStatus=MText->setAttachment(Attachment);

        LgndErrorStatus=MText->setLocation(TemporaryPoint);
        MText->setRotation(Angle);

        LgndErrorStatus=MText->setLayer(Layer.GetBuffer());
        
    return M_Legend_Shaper::ShaperError::isAllowably;
    
}

M_Legend_Shaper::~M_Legend_Shaper(void)
{
    delete dblock;
    Contour->close();
    MText->close();
    pRecord->close();
    pBlockTbl->close();
    
}
bool M_Legend_Shaper::SetLayer(CString Name){
    Acad::ErrorStatus Status;
    AcDbLayerTable * pLayerTable = NULL;
    ACHAR* pLayerName;
    Status=acdbCurDwg()->getLayerTable(pLayerTable, AcDb::kForWrite);
    if(Status!=Acad::ErrorStatus::eOk){
        acutPrintf(_T("Не удалось открыть таблицу слоёв"));
            return true;
        }
    AcDbLayerTableIterator * pLayerIterator = NULL;
    pLayerTable->newIterator(pLayerIterator);
    AcDbLayerTableRecord *pLayerTableRecord;
    bool flag=false;
    for (   ; !pLayerIterator->done(); pLayerIterator->step() ) 
    {
        
        // чтение данных очередного блока
        Status=pLayerIterator->getRecord(pLayerTableRecord, AcDb::kForWrite);
        if(Status!=Acad::ErrorStatus::eOk){
            acutPrintf(_T("Не удалось открыть запись из таблицы слоёв"));
            return true;
        }
        
        pLayerTableRecord->getName(pLayerName);
        CString Temp(pLayerName);
        
        if(Temp==Name){
            CString Temp;
            Temp=_T("\nНайден слой ")+Name;
                acutPrintf(Temp.GetBuffer());
                Layer=Name;
                flag=true;
                if(pLayerTableRecord->isFrozen()==true){
                    Status=pLayerTableRecord->setIsFrozen(false);
                    if(Status!=Acad::ErrorStatus::eOk){
                     acutPrintf(_T("\nНе удалось разморозить слой"));
                        return false;
                    } 
                       acutPrintf(_T("\nСлой разморожен"));               
                }    
                if(pLayerTableRecord->isOff()==true){
                    pLayerTableRecord->setIsOff(false);
                    acutPrintf(_T("\nСлой включен"));    
                }
                if(pLayerTableRecord->isLocked()==true){
                    pLayerTableRecord->setIsLocked(false);
                    acutPrintf(_T("\nСлой разблокирован"));    
                }
                pLayerTableRecord->close();
                break;    
        }
        pLayerTableRecord->close();// закрыть запись!
    }
    if(!flag){
        pLayerTableRecord=new AcDbLayerTableRecord();
          pLayerTableRecord->setName((ACHAR*)(Name.GetBuffer()));
          pLayerTable->add(pLayerTableRecord);
          Layer=Name;
          pLayerTableRecord->close();
    }

    delete pLayerIterator;
    pLayerTable->close();// закрыть таблицу блоков!
     ads_regen();
    return true;
}
void M_Legend_Shaper::SetStyle(CString Name){
    AcDbTextStyleTable* TextStyleTable;
    ACHAR* pStyleName;
    if(!(Acad::ErrorStatus::eOk==acdbCurDwg()->getTextStyleTable(TextStyleTable,AcDb::kForRead))){
           acutPrintf(_T("Не удалось открыть таблицу стилей"));
            return;
    }
    AcDbTextStyleTableRecord* TextStyleTableRecord;
    Acad::ErrorStatus Status;
    AcDbTextStyleTableIterator* Iter;
    TextStyleTable->newIterator(Iter);
    for (   ; !Iter->done(); Iter->step() ) 
    {
        // чтение данных очередного блока
        Status=Iter->getRecord(TextStyleTableRecord, AcDb::kForWrite);
        if(!(Acad::ErrorStatus::eOk==Status)){
            acutPrintf(_T("Не удалось открыть стиль Standard"));
            return;
        }
        // извлечение имени слоя
        
        TextStyleTableRecord->getName(pStyleName);
        
        CString Temp(pStyleName);
        if(Temp==Name){
          double tempScale;
          tempScale=TextStyleTableRecord->xScale();
              if(!((tempScale>0.74)&&(tempScale<0.76))){
                  TextStyleTableRecord->setXScale(0.75);
              }
          IdStyle=TextStyleTableRecord->objectId();
          acutPrintf(Name.GetBuffer());
        }
        TextStyleTableRecord->close();
    }
    delete Iter;
    TextStyleTable->close();
}
void M_Legend_Shaper::EnableLayer(AcDbLayerTableRecord * pLayerTableRecord){
}

M_Legend_Shaper::ShaperError M_Legend_Shaper::CreateBelowLine(){
      
      AcDbLine* BelowLine=new  AcDbLine(Convert_adstoAcGe(InvestigateLeaderEndPoint),Convert_adstoAcGe(InvestigateLineEndPoint));
      BelowLine->setLayer(Layer.GetBuffer());
      pRecord->appendAcDbEntity(BelowLine->objectId(),BelowLine);
      BelowLine->close();
      return M_Legend_Shaper::ShaperError::isAllowably;
}
CString GetHeightVariable(CString Name)
{
  struct resbuf *rb = NULL;
  CString Variable=L"";

  if (acedGetSym(Name.GetBuffer(), &rb) == RTNORM) {
    if (rb) {
      switch (rb->restype) {
          case RTREAL  :
              Variable.Format(L"%.1f",rb->resval.rreal);
              break;
        default:
            Variable=L"";
          break;
      }
    } else {
      acutPrintf(_T("\nВысота == NULL"));
      Variable=L"";
    }
  } else {
     acutPrintf(_T("\nОшибка при чтении информации для чтения высоты"));
     Variable=L"";
  }
  return Variable;
}
bool M_Legend_Shaper::GetHeight(double& Height){
    CString TempHeight;
    TempHeight=GetHeightVariable(L"Tehscale");
    if(TempHeight==L""){
        return false;
    }
     Height=_wtof(TempHeight.GetBuffer());
        Height=0.15*Height;
    return true;
}

class M_Legend_Shaper
{
public:
    M_Legend_Shaper(M_Legend::MultilevelText& LegendText);
    enum ShaperError{
        isNotOpen=80220,
        isError=80379,
        isAllowably=80228
    };
    enum ViewText{
         AboveText=255,
         BelowText=257,
         LineText=251
    };
    
    /*!Метод для осуществления выбора слоя на который будет передан мультитекст
     */
     bool SetLayer(CString Name);
    /*!Метод для отображения надписи в виде мультитекста 
      @param LegendText Надпись в виде текста
    */
    ShaperError CreateMText();
    /*!Метод для отображения выноски
    */
    ShaperError CreateLeader();
    /*!Метод для отображения черты для мультитекста
    */
    ShaperError CreateBelowLine();
    /*!Метод для конвертации ads_point в AcGePoint3d
    */
    AcGePoint3d Convert_adstoAcGe(ads_point& Point);
    /*!Предварительный просмотр текста перед вставкой в чертёж
     */
     bool PreliminaryViewingText();
     M_Legend_Shaper::ShaperError GetPointAnd2DPolyline();
     
public:
    ~M_Legend_Shaper(void);
private:
    /*!Вид размещения текста
    */
    ViewText TextFlag;
    /*!Контур
    */
    AcDbEntity *Contour;
    /*!Мультитекст
    */
     AcDbMText* MText;
    /*!Высота
    */
     double Height;
     /*!Слой
    */
     CString Layer;
     /*!Указатель на таблицу блоков
     */
    AcDbBlockTable* pBlockTbl;
    /*!Указатель на запись таблицы блоков
     */
    AcDbBlockTableRecord *pRecord;
    /*!метод для открытия БД текущего рисунка и получения указателя на таблицу блоков
     *кроме того он задаёт указатель на пространтсво модели как блока  ACDB_MODEL_SPACE
    */
    ShaperError SetPointers();
    /*!Метод для преобразования MultilevelText в текст для передачи в MText
    */
    CString ConvertMultilevelText(M_Legend::MultilevelText& LegendText);
     AcDbMText::AttachmentPoint Attachment;
     /*!Начальная точка
     */
     ads_point BeginningPoint;
     /*!Точка вставки мультитекста
     */
     ads_point InvestigatePoint;
     /*!Вторая точка для выноски первая точка линии, над которой устанавливается мультитекст
     */
      ads_point InvestigateLeaderEndPoint;
     /*!Вторая точка линии, над которой устанавливается мультитекст
     */
      ads_point InvestigateLineEndPoint;
     /*!Правая нижняя точка Мультитекста
     */
     ads_point BelowRightPoint;
     AcAxDocLock *dblock;
     /*!Угол поворота мультитекста
     */
     double Angle;
     /*!Id выбранного стиля для мультитекста
     */
     AcDbObjectId IdStyle;
     /*!Метод для осуществления выбора стиля для мультитекста
     */
     void SetStyle(CString Name);
     /*!Метод при необходимости разморозит разблокирует и отключит необходимый слой
     */
     void EnableLayer(AcDbLayerTableRecord * pLayerTableRecord);
     /*!Метод для осуществления выбора высоты текста
     */
     bool GetHeight(double& Height);
     bool The_point_is_established_at_preliminary_viewing;
     bool The_second_point_is_established;
  
     M_Legend::MultilevelText LegendText;
};