Exemplo de objeto
Fonte gráfica
Mesa
SVersion = 2; // A primeira linha do script determina a versão do interpretador
// Descrição. Será exibido no painel Propriedades
// Você também pode classificar os objetos no campo
// Dados tabulares e mcqs
ObjectDescription = "furo central";
// Esta é a descrição da função do objeto
função ActHeader {
NPart = 2; // O número de solicitações para uma seleção dinâmica de parâmetros
// Esta seção contém descrições dos parâmetros do objeto aberto
// Visível para outros objetos
Público (
// Defina o parâmetro tamanho do furo - o diâmetro
d, "diâmetro",
// Plano para instalar, dependendo da ponta do eixo
WP1, "o começo do avião"
rValType, "Shaft Type" // Tipo de eixo que conecta o furo
// Definido para sobreposição em
// Tipos e com um corte sem corte
Lhole, "A profundidade dos buracos", // Esta é a profundidade total dos buracos
Lthread, parâmetro "Comprimento do thread" // comprimento do thread
// Parâmetros de desempenho específicos
DF, "diâmetro do eixo para formar F",
DH, "O diâmetro do eixo para formar H"
);
// Parâmetros privados usados para plotar
// E calcular os limites dos outros parâmetros
Protegido (seted, freeLen, bBlind, rSuppressPointHeight);
// Esta seção lista os parâmetros da abertura,
// Que será acessível de fora para edição
// Isso é classificado apenas como ações específicas em
// Alterando os parâmetros de funções externas definidas em
// Parâmetros OnChange
Mutável (d, WP1, DF, DH, rValType, Lhole, Lthread);
// Mostrar caixa de diálogo para inserir parâmetros de seleção dinâmica
OnDlgBeforeSelectParam = 1;
// Não regenere o circuito de supressão após a inserção
ContornoOnLine = 0;
// Esta é a parte do elemento do eixo
IsAValPart = 1;
// E uma parte embutida do eixo
ParteDentro = 1;
// Este elemento - abertura (esta variável é usada para
// Dimensionamento no Inventor)
É um buraco = 1;
};
// Inicializa os parâmetros do objeto
função OnInitialization {
// Carregue a tabela no cache
// A tabela de parâmetros da linha atual no script está sempre disponível
// Portanto carregou apenas um parâmetro d
CarregarEmCache (d);
// A variável seted é o valor padrão UnknownValue
// Conforme inicializado com este valor
// Então, se fizermos o seguinte teste, esta unidade
// Os operadores serão executados apenas uma vez:
se (seted == ValorDesconhecido) {
seted = 1; // Defina seted 1 para a condição não atendida
// De novo
// Definir valores iniciais
rValType = 1; // O furo é colocado na porção do eixo
rZOrder = 4220; // Classificação - valor inicial de
// Selecione de uma tabela os valores iniciais
SelectInCache ("kFirst", "Formulário", "~", "FH", "d", "~", 10);
//De acordo com a sintaxe do operador - selecionou o primeiro registro
// Tabela onde o parâmetro do formulário é "FH" e um parâmetro
// O diâmetro do furo d é aproximadamente igual a 10
// Conjunto, de acordo com o qual o objeto será inicialmente
// Exibe
strDesignName = "Formulário F";
// Define o valor inicial de parâmetros arbitrários
Lhole = 30; // O comprimento do buraco
Lthread = Lhole-d / 2; // Este é o comprimento mínimo possível do thread
// A variável que determina se o buraco é surdo.
// Padrão - cego.
bBlind = VERDADEIRO;
// Esta variável determina que o valor do parâmetro é relativo a
// Altura do ponto final do cone de supressão. (Veja o desenho)
rSuppressPointHeight = tg (30) * (d-1,082 * p) / 2;
};
};
// Configurando identificadores de função
função SetGripPoint {
NGrip = 3; // Total de 3 canetas
pntGrip0 = pntOrigin; // O primeiro - no ponto de inserção
// A segunda alça - o comprimento da alça da parte rosqueada
pntGrip1 = pntOrigin + vecDirection * Lthread;
// Terceira alça - a alça é o comprimento total do furo
pntGrip2 = pntOrigin + vecDirection * Lhole;
};
// Esta função determina a reação do objeto ao movimento das alças
função OnMoveGripPoint {
// Aí vem a variável NMovingGrip, igual ao índice com um slide
// O manipulador de numeração do array começa em zero.
// Ao editar o primeiro identificador, basta mover o item para
// Onde o cursor está com esta caneta. Ou seja, mova o ponto de inserção
// Onde está a primeira caneta
se (NMovingGrip == 0) {
pntOrigin = pntGrip0;
};
// Com isso esticamos o comprimento da (segunda caneta)
// Isso define o comprimento da parte rosqueada, dependendo da corrente
// Execução de furos
se (NMovingGrip == 1) {
// Determina a distância de alongamento como comprimento do vetor,
// Define um ponto ruchki1 e ruchki0
rDistance = vecLen (pntGrip1-pntGrip0);
// Para a execução (furo em forma) "P"
se (Formulário == "P") {
// O comprimento do fio deve ser limitado para reduzir a quantidade de
// (Ld / 2). Obviamente, o parâmetro de comprimento do thread Lthread
// Será definido para a posição relativa do cursor
// Se for maior que (Ld / 2).
Lthread = máx. (rDistância, Ld / 2);
};
// Para a execução de "F H"
se (Formulário == "F H") {
// O mesmo vale para a execução do comprimento do thread deve ser
// O tamanho é limitado abaixo por (l + d / 2).
Lthread = max (rDistância, l + d / 2);
};
// Finalmente, nesta condição, limitamos o comprimento do thread
// Ligado, pois o comprimento do fio não pode ser maior
// O comprimento do furo. Portanto, vamos retirar todo o furo
// De acordo com o novo diâmetro da rosca.
se (Lthread > Lhole-d / 2) {
//Te quando você altera o comprimento maior que o comprimento dos furos da rosca
// Defina o novo comprimento dos furos igual
// Comprimento da rosca mais metade do diâmetro
Lhole = Lthread + d / 2;
};
};
// Esta seção examina o movimento da terceira alça.
// O resultado da edição é aumentar o comprimento do furo,
// Sem afetar o thread.
se (NMovingGrip == 2) {
// Neste caso, a distância atual é definida como
// Comprimento do vetor formado por pontos e ruchki0 ruchki2
rDistance = vecLen (pntGrip2-pntGrip0);
// Para a execução de "P"
se (Formulário == "P") {
// O comprimento do furo é limitado abaixo do parâmetro L
Lhole = máx. (rDistância, L);
};
// Dlyaispolneniya "F H"
se (Formulário == "F H") {
// Comprimento dos parâmetros do orifício restrito (l + d)
Lhole = max (rDistância, l + d);
};
// Se você alterar o comprimento do furo será menor que o comprimento da rosca
// Mover o tópico para o exterior
se (Lhole > Lthread + d / 2) {
// Ou seja, se o comprimento da abertura for menor que Lthread + d / 2,
// Recalcula o novo comprimento do thread que é menor que
// Comprimento atual dos furos no d / 2
Lthread = Lhole-d / 2;
};
};
};
// Função de cálculo final dos parâmetros
função OnMakeParameters {
// Nome, sobrenome e patronímico do objeto
strTheName = "CenterHole"; // Furo de centralização
strTheType = "ArborParts"; // Refere-se a eixos de detalhes
strTheSubType = "Simple"; // Tipo de abertura - fácil
// Define a posição do plano WP1. É apenas um plano
// O ponto base no ponto de inserção e um vetor normal,
// Coincide com a direção do vetor de inserção
WP1 = Plano (pntOrigin, vecDirection);
// Perceba a sobreposição para diferentes ocasiões:
// Se a variável rValType, especificando o tipo de seção do eixo, no
// Defina que o buraco é igual a 1 (este é um simples
// Porção do eixo), a ordem de sobreposição é igual a 4220
// (Este número é dado com base nos valores da ordem de
// Partes do eixo, de modo que o furo se sobreponha ao eixo até o seu
// Supressão de loop
se (rValType == 1) rZOorder = 4220;
// Para porções de eixo interno e outras porções onde rValType não é igual a 1
caso contrário rZOorder = 2150;
// A sequência será diferente
// Essas restrições de parâmetros são encontradas dependendo da versão
// Para a execução de "P", mais precisamente, para o registro atual na tabela,
// Forma que encontra o furo "P".
se (Formulário == "P") {
// Limita o comprimento do parâmetro L dos furos
Lhole = máx. (Lhole, L);
// Limita o comprimento do parâmetro do thread (Ld / 2)
Lthread = máx. (Lthread, Ld / 2);
// Defina strDesignName em "Formulário P"
//escolher o que o desenho bidimensional, que corresponde a
// Os parâmetros atuais da tabela
strDesignName = "Formulário P";
};
// O mesmo vale para o formato "F H"
se (Formulário == "F H") {
// Limita os parâmetros dos furos e o comprimento da rosca
Lhole = máx. (Lhole, l + d);
Lthread = máx. (Lthread, l + d / 2);
// Esta garantia, se o usuário escolher
// Execução "P" nas formas bidimensionais, desde que a tabela
// Valor do parâmetro exibido no Formulário "FH".
// Em geral, se você selecionar a versão errada, o conjunto
// Primeira correta.
se (strDesignName == "Formulário P") {
strDesignName = "Formulário F";
};
};
// Limitando o comprimento do fio a partir do topo, dependendo do
// Comprimento total do furo
Lthread = min (Lthread, Lhole-d / 2);
// Os buracos formam P sempre surdos
se (Formulário == "P") {bBlind = TRUE;};
// Isto é para garantir que o caminho correto seja desenhado supressão
// O cronograma possui uma supressão de contorno, a posição de um dos pontos
// Que é especificado por rSuppressPointHeight
// Para saber se o usuário selecionou a exibição
// Cego ou passante, defina o parâmetro
// RSuppressPointHeight valor desejado
se (bBlind == TRUE) {// Para furo cego
rSuppressPointHeight = tg (30) * (d-1,082 * p) / 2;
} Senão {// Para o furo passante (ou seja, não da broca cônica)
rSuppressPointHeight = 0;
};
// Esta linha simplesmente define especificações
// Dependendo da versão adiciona a letra necessária
// Para os buracos designados.
se (strDesignName == "Formulário F") {strLetterForm = "F";};
se (strDesignName == "FormaH") {strLetterForm = "H";};
se (strDesignName == "FormaP") {strLetterForm = "P";};
// Parâmetro strPartName - uma especificação de string holes.
// Além disso, ele também exibiu dica.
strPartName = "Centro de Ed." + strLetterForm + "M" + d + "GOST14034-74";
// Formata a string automaticamente, ou seja
// Ao adicionar um valor de string com
// O valor numérico é convertido automaticamente em uma string
};
// Esta função determina o tipo de diálogo do furo de inserção
função OnDialog {
// Carregar os parâmetros da tabela de trabalho do cache
CarregarEmCache (d);
// Chame o diálogo com a chave
UniDialog (
// Isso define os campos da tabela hole
// A forma e o diâmetro. Saída como uma tabela definindo os parâmetros
DBFLD, Formulário, d,
// O diâmetro do eixo para formar F e Forma H
// Saída somente como parâmetros de referência
DBINF, DF, DH,
// Parâmetros solicitados aleatoriamente (sujeito a restrições, é claro)
// Exibir na guia Propriedades
VFLD,
Lthread, "profundidade da rosca"
Lhole, "A profundidade do buraco"
// Marcação de furo cego ou passante
// Exibir na guia de propriedades na forma de um visto
BFLD,
bCego, "Surdo"
// Desempenhos de escolhas. Exibe todos os desempenhos
VIDS, strDesignName, "Todos",
// Exibe todos os tipos reconhecidos
TVIDS, lViewType, "Todos",
// Exibe a pré-visualização
VER, "Vídeos"
);
};
// Esta função é executada antes da seleção dinâmica dos parâmetros
função OnInitSelect {
// Esta função vem com a variável rPart - número de sequência
// Solicita que você escolha os parâmetros dinâmicos. A contagem começa em 0
se (rParte == 0) {
// Para o primeiro caso indique o diâmetro da rosca
// Produza uma dica correspondente
strPromt = "Digite a profundidade da rosca";
};
se (rParte == 1) {
// Para o segundo caso indica a profundidade do furo (é zhe
// Comprimento total).
strPromt = "Digite a profundidade do furo";
};
};
// Esta função define o comportamento do objeto na seleção dinâmica dos parâmetros
função OnSelectParam {
// Para o primeiro ciclo de parâmetros de seleção. Em princípio, as limitações
// O mesmo que para as alças.
// Essas variáveis vêm rXcoord e rYcoord - relativas
// Abscissa e ordenada do cursor
se (rParte == 0) {
// O intervalo do parâmetro é determinado
// Módulo abscissa relativa
rDistância = Abs (rXcoord);
// Limitações na escolha de parâmetros dependendo da versão
se (Formulário == "P") {
Lthread = máx. (rDistância, Ld / 2);
};
se (Formulário == "F H") {
Lthread = max (rDistância, l + d / 2);
};
se (Lthread > Lhole-d / 2) {
Lhole = Lthread + d / 2;
};
};
// Para a segunda solicitação
se (rParte == 1) {
// Distância do parâmetro
rDistância = Abs (rXcoord);
// Restrições.
se (Formulário == "P") {
Lhole = máx. (rDistância, L);
};
se (Formulário == "F H") {
Lhole = max (rDistância, l + d);
};
se (Lhole < Lthread + d / 2) {
Lhole = Lthread + d / 2;
};
};
};
// Esta função é executada quando os parâmetros na caixa de diálogo são inseridos
função OnDialogChanged {
// A função adiciona interatividade na forma de diálogo.
// Neste caso precisamos esconder a execução e daw "surdo"
// O operador ShowDesign oculta ou exibe o desempenho.
// Dependendo do valor do primeiro parâmetro (1 - Mostra
// 0 - oculta.
// Operador ShowBool ??oculta e exibe interruptores (marque)
// Para começar, execute e mostre tudo daw
ShowDesign (1 "Formulário F");
ShowDesign (1, "Formulário H");
ShowDesign (1 "FormaP");
ShowBool ??(1, "surdo");
// Se você escolher uma linha na tabela onde d3 é 0,
// É necessário ocultar a performance do "Formulário H". (Conforme definido no convidado,
// Que o desempenho não seja utilizado para tais valores
// Configurações
se (d3 == 0) ShowDesign (0, "Formulário H");
// Se a linha selecionada corresponde ao formato do furo "P", então
// Para ocultar as outras duas performances (elas não podem ser selecionadas)
// E daw "cego" porque o formato de P é sempre cego.
se (Formulário == "P") {
ShowDesign (0, "FormaH");
ShowDesign (0, "FormaF");
ShowBool ??(0, "surdo");
};
// Mas para a forma escolhida de "FH", você só precisa se esconder
// Execução "Formulário F"
se (Formulário == "F H") {
ShowDesign (0, "Formulário P");
};
};
// Função OnChangeParameters executada sob influência externa
// Objeto. É uma tentativa de estabelecer uma dependência ou direta
// Altera os parâmetros do painel de propriedades do objeto
// Esta função determina a reação do objeto a tal mudança.
função OnChangeParameters {
// Aí vem o objeto new, representando um
// O mesmo objeto com o novo valor de opções abertas.
// Variável aleatória podemos atribuir imediatamente novos valores
rValType = novo.rValType;
Lhole = novo.Lhole;
Lthread = novo.Lthread;
// Aqui é dado de forma consistente, como escolher uma linha da tabela,
// O novo valor dos parâmetros correspondentes.
// Verifique se o parâmetro alterado d
se (novo.d! = d) {// ou seja, se o novo valor não for igual ao antigo
// A tabela é carregada no cache
CarregarEmCache (d);
// E retire dele o primeiro registro disponível com um parâmetro
// D, aproximadamente igual ao novo valor.
SelectInCache ("kFirst", "d", "~", novo.d);
// Então verificamos se não alteramos nenhum outro parâmetro
} Else if (DH! = New.DH) {// altera o diâmetro do eixo H desempenho
// Carregar
CarregarEmCache (DH);
// Selecione o primeiro registro
SelectInCache ("kFirst", "DH", "~", novo.DH);
} Else if (DF! = New.DF) {// altera o diâmetro do eixo versão F
// Carregar
CarregarEmCache (DF);
// Selecione a primeira entrada com um valor aproximadamente igual
SelectInCache ("kFirst", "DF", "~", novo.DF);
};
// Processamento padrão concluído com sucesso.
//Enviar o objeto para alterar os parâmetros que
// Defina os parâmetros necessários.
// Para fazer isso, atribuímos o valor da variável Handled OBJ_HANDLED
Manipulado = OBJ_HANDLED;
// Se após selecionar na tabela o diâmetro do eixo não for estabelecido
// O novo valor pode exigir a atualização cíclica
// Envia uma variável de objeto variável
// Manipulado igual a OBJ_WARNING
se (d! = novo.d) {
Manipulado = OBJ_WARNING;
};
// Neste bloco os operadores recalculam a nova posição do objeto
// Quando você muda seu plano de trabalho
// Correção de variável para testar a capacidade de movimento.
// Em geral, neste caso não poderia ser utilizado
// Porque o buraco não muda quando você muda sua geometria
// Aviões.
// Este bloco é gerado pelo script do assistente, então ele tem
// Esta visão unificada
correção = 0;
// Verifique se a dependência mudou e se o
// PloskostWP1
se (IsFixedParam (WP1)) {
// Aumentar o valor da variável fix, para a auditoria de acompanhamento
consertar = consertar + 1;
// Salva o valor antigo da inserção do vetor.
vecXOld = vecDireção;
// Atribui novo valor ao vetor insere correspondência
// Para a nova posição do plano WP1
vecDirection = Vetor (novo.WP1);
// E mova o ponto de inserção para uma nova posição de aberturas
// PloskostiWP1
pntOrigin = Ponto (new.WP1);
// Restaura o sistema de coordenadas com base em
// Valores antigos e novos dos vetores
restaurarBase(vecXOld, vecPlano, vecDireção);
};
// Se de repente um buraco com geometria fixa
// Os objetos começam a se esticar em direções diferentes, então
// Retorna um erro
se (fixar > 1) {
Manipulado = OBJ_ERROR;
};
};
// Esta função é executada antes de cada tentativa de estabelecer um relacionamento
função BeforeConnect {
// Aqui nós apenas reiniciamos de acordo com as últimas
// A função a seguir para estabelecer novos
RedefinirÚltimaConstraint();
}
// Esta função define a dependência. Mais especificamente,
// Determina exatamente como se comportar quando um objeto
// Adesão a outro objeto
função OnConnect {
// Verifique o valor da variável rPart, definindo
// O número de sequência da solicitação para unir as partes.
//Se o relacionamento for definido em duas etapas,
// Ou mais, é possível instalar uma peça
// Depende de duas ou mais partes.
// Mas neste caso particular, dependendo apenas do estabelecido
// De uma peça, então apenas uma solicitação e verificação
// RPart igual a 0
se (rParte == 0) {
// A função vem no objeto onConnect obj - isso é um detalhe,
// Ao qual estamos tentando nos juntar. Podemos ajudar a qualificar
// Acesso aos parâmetros das peças para verificar se
// Instalar dependências automaticamente ou não.
// Verifique se a parte à qual você está tentando se juntar,
// Haste:
se (obj.strTheType == "Arbor") {
// Próximo - será definido dependendo da execução atual
// Furos. Ou seja, versões diferentes são implementadas de forma diferente dependendo do eixo.
se (Formulário == "F H") {
// Conjunto para abertura do poço do mesmo tipo do
// Trecho do eixo, que se une (isso é necessário para a execução de
// Sobreposição
rValType = obj.rValType;
// Encontre o plano mais próximo do plano da abertura WP1:
strNearestPlane = mais próximoPlaneName (WP1, obj.WP1, obj.WP2);
// Isso leva em consideração apenas os objetos WP1 e WP2 do plano
//te se estes não forem os aviões mais próximos, strNearestPlane
// É incerto.
// Além disso - verifique o tipo de poço. para áreas comuns (externas):
se (obj.rValType! = 1)
// Define a relação geométrica
// Digite "inserir" codirecional. Pelo objeto ao qual
// Inscreva-se para obter detalhes e informações sobre os aviões WP1
// O plano mais próximo. A distância entre os planos é de 0 mm.
// Dependência unidirecional
SetGeomConstraint (INSERIR, CODIRECT, obj, WP1, strNearestPlane, 0, FALSO);
// Para as seções internas dos eixos:
outro
// Defina o relacionamento com os mesmos parâmetros,
// Mas o oposto.
SetGeomConstraint (INSERIR, CONTRDIRECT, obj, WP1, strNearestPlane, 0, FALSE);
// Define o parâmetro dependendo da execução atual
// Buracos.
// Para formar o buraco F deve ser igualado
// Parâmetro rDiameter (diâmetro do eixo) para o diâmetro do furo da tabela DF
se (strDesignName == "Formulário F") {
// Então, se o teste for realizado, o
// Define a dependência paramétrica na expressão.
// RDiâmetro igualando a DF
SetParamConstraint (DF, obj, EXPR, "obj.rDiameter");
};
// Formar H é o mesmo teste, mas estabelece uma relação
// Já diâmetro do furo DH.
if (strDesignName == "FormaH") {
SetParamConstraint (DH, obj, EXPR, "obj.rDiameter");
};
NoVectorSelect = 1; // definindo a variável NoVectorSelect como 1
// Desabilite a seleção do vetor de direção para obter detalhes
// Desde que se juntou e estabeleceu o vício
// Então escolha mais, não é necessário.
Handled = OBJ_HANDLED; // Define a variável Handled
// Valor OBJ_HANDLED, ou seja dizendo que de acordo com
// Definido com sucesso.
};
};
};
}