[AVISO FECHADO!] Qualquer pergunta de novato, para não desorganizar o fórum. Profissionais, não passem por aqui. Não posso ir a lugar algum sem você. - página 697

Novo comentário
 
rensbit:
O ângulo da âncora é de que ângulo será contada a posição do objeto na janela. Os ângulos são contados no sentido horário da esquerda para a direita.

Se eu me encaixar no canto inferior direito, então o quê, devo definir coordenadas negativas?
 
valenok2003:

Se eu me encaixar no canto inferior direito, eu defini coordenadas negativas?
Não, coordenadas positivas, o terminal calcula por si só o ponto desejado. Por exemplo: 15 pixels a partir do 2º canto
[Excluído]  
Azerus:

Por favor, informe,

Para calcular o número de eventos contínuos (por exemplo, o número de barras em uma série em que o fechamento é maior que o aberto e vice-versa), eu só conseguiria chegar ao seguinte:

Duas perguntas (se o acima faz sentido): (1) como reiniciar a leitura do contador se a série contínua parou; e (2) como escrever corretamente Buffer[i] - ou seja, como posso "ver" o resultado em si?

Ou seja, se o indicador para uma determinada barra mostrar "-3", significa que é a terceira barra em sucessão que fechou abaixo da abertura; se a próxima barra depois de fechar acima da abertura, o indicador mostrará "1" ......

int i=Bars-1

enquanto (i > 0) {

int x=0;

int y=0;

se ( Fechar[i] > Abrir[i] ) { x++ ;

Buf [i]= x; }

se (Fechar[i] < Abrir[i] ) { y-- ;

Buf2[i] =y ; }

i--;

}

 
rensbit:
Não, coordenadas positivas, o próprio terminal calculará o ponto desejado. Por exemplo: 15 pixels de 2 esquinas
Obrigado, funcionou.
 
artmedia70:
Mostre seu código, para não adivinhar


Feito no programa Gorando, com seu martin adicionado.

//+------------------------------------------------------------------+
//| Copyright 2005, Gordago Software Corp. |
//| http://www.gordago.com/ |
//| versão 2.0 |
//+------------------------------------------------------------------+

#propriedade copyright "Copyright 2005, Gordago Software Corp."
#link da propriedade "http://www.gordago.com"

#define MIN_STOPLOSS_POINT 10
#define MIN_TAKEPROFIT_POINT 10
#define MAGIC 218650

sNameExpert = "Gerar de Gordago";
nConta exterior int =0;
duplo dBuyStopLossPoint externo = 0;
dSellStopLossPoint duplo externo = 0;
duplo dBuyTakeProfitPoint externo = 0;
dSellTakePonto de lucro externo duplo = 0;
duplo dBuyTrailingStopPoint externo = 0;
dSellTrailingStopPoint duplo externo = 0;
Lote duplo externo = 0,10;
nSlippage int exterior = 30;
bool externo lFlagUseHourTrade = True;
nFromHourTrade = 0;
IntToHourTrade externo = 23;
bool externo lFlagUseSound = Falso;
sSoundFileName externo de corda = "alert.wav";
cor exteriorOpenBuy = Azul;
cor exteriorCloseBuy = Aqua;
cor exteriorOpenSell = Vermelho;
cor exteriorFecharSell = Aqua;


void deinit() {
Comentário(");
}

//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int start(){
se (lFlagUseHourTrade){
se (!(Hora()>=nFromHourTrade && Hour()<=nToHourTrade)) {
Comentário ("Ainda não chegou a hora do comércio!");
retorno(0);
}
}

if(Bars < 100){
Impressão ("barras com menos de 100");
retorno(0);
}

if(nConta > 0 && nConta != AccountNumber()){
Comentário("Comércio por conta : "+ContaNúmero()+" PROIBIDO!");
retorno(0);
}

if((dBuyStopLossPoint > 0 && dBuyStopLossPoint < MIN_STOPLOSS_POINT) ||||
(dSellStopLossPoint > 0 && dSellStopLossPoint < MIN_STOPLOSS_POINT)){
Print("StopLoss menos que " + MIN_STOPLOSS_POINT);
retorno(0);
}
if((dBuyTakeProfitPoint > 0 && dBuyTakeProfitPoint < MIN_TAKEPROFIT_POINT) ||||
(dSellTakeProfitPoint > 0 && dSellTakeProfitPoint < MIN_TAKEPROFIT_POINT)){
Print("TakeProfit menos que " + MIN_TAKEPROFIT_POINT);
retorno(0);
}

duplo diOpen0=iOpen(NULL,60,0);
duplo d1=(0.00030);
duplo diHigh2=iHigh(NULL,60,0);
duplo diOpen3=iOpen(NULL,60,0);
duplo d4=(0.00030);
duplo diLow5=iLow(NULL,60,0);
duplo diOpen6=iOpen(NULL,60,1);
duplo diClose7=iClose(NULL,60,1);
duplo diOpen8=iOpen(NULL,60,2);
duplo diClose9=iClose(NULL,60,2);
duplo diOpen10=iOpen(NULL,60,0);
duplo d11=(0.00030);
duplo diHigh12=iHigh(NULL,60,0);
duplo diOpen13=iOpen(NULL,60,0);
duplo d14=(0.00030);
duplo diLow15=iLow(NULL,60,0);
duplo diOpen16=iOpen(NULL,60,1);
duplo diClose17=iClose(NULL,60,1);
duplo diOpen18=iOpen(NULL,60,2);
duplo diClose19=iClose(NULL,60,2);


if(AccountFreeMargin() < (1000*Lot)){
Imprimir("Nós não temos dinheiro. Margem Livre = " + AccountFreeMargin()));
retorno(0);
}

bool lFlagBuyOpen = falso, lFlagSellOpen = falso, lFlagBuyClose = falso, lFlagSellClose = falso;

lFlagBuyOpen = (diOpen0+d1>diHigh2 && diOpen3-d4<diLow5 && diOpen6<diClose7 && diOpen8>diClose9);
lFlagSellOpen = (diOpen10+d11>diHigh12 && diOpen13-d14<diLow15 && diOpen16>diClose17 && diOpen18<diClose19);
lFlagBuyClose = Falso;
lFlagSellClose = Falso;

se (!ExistPosições()){

se (lFlagBuyOpen){
OpenBuy();
{ return(0);
}

se (lFlagSellOpen){
OpenSell();
retorno(0);
}
}
if(ExistPosições()){
if(OrderType()==OP_BUY){
if(lFlagBuyClose){
bool flagCloseBuy = OrderClose(OrderTicket(), OrderLots(), Bid, nSlippage, colorCloseBuy);
se (flagCloseBuy && lFlagUseSound)
PlaySound(sSoundFileName);
retorno(0);
}
}
if(OrderType()==OP_SELL){
if(lFlagSellClose){
bool flagCloseSell = OrderClose(OrderTicket(), OrderLots(), Ask, nSlippage, colorCloseSell);
se (flagCloseSell && lFlagUseSound)
PlaySound(sSoundFileName);
retorno(0);
}
}
}

if (dBuyTrailingStopPoint > 0 || dSellTrailingStopPoint > 0){

para (int i=0; i<OrdersTotal(); i++) {
se (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
bool lMagic = true;
se (MAGIC > 0 && OrderMagicNumber() != MAGIC)
lMagic = falso;

se (OrderSymbol()==Symbol() && lMagic) {
if (OrderType()==OP_BUY && dBuyTrailingStopPoint > 0) {
if (Bid-OrderOpenPrice() > dBuyTrailingStopPoint*Point) {
se (OrderStopLoss()<Bid-dBuyTrailingStopPoint*Point)
ModifyStopLoss(Bid-dBuyTrailingStopPoint*Point);
}
}
se (OrderType()==OP_SELL) {
if (OrderOpenPrice()-Ask>dSellTrailingStopPoint*Point) {
se (OrderStopLoss()>Ask+dSellTrailingStopPoint*Point || OrderStopLoss()==0)
ModifyStopLoss(Ask+dSellTrailingStopPoint*Point);
}
}
}
}
}
}
retorno (0);
}

bool ExistPosições() {
para (int i=0; i<OrdersTotal(); i++) {
se (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
bool lMagic = true;

se (MAGIC > 0 && OrderMagicNumber() != MAGIC)
lMagic = falso;

se (OrderSymbol()==Symbol() && lMagic) {
retorno(Verdadeiro);
}
}
}
retorno(falso);
}

void ModifyStopLoss(double ldStopLoss) {
bool lFlagModify = OrderModify(OrderTicket(), OrderOpenPrice(), ldStopLoss, OrderTakeProfit(), 0, CLR_NONE);
se (lFlagModify && lFlagUseSound)
PlaySound(sSoundFileName);
}

//+----------------------------------------------------------------------------+
//| Autor : Kim Igor V. aka KimIV, http://www.kimiv.ru |
//+----------------------------------------------------------------------------+
//| Versão : 19.02.2008 |
//| Descrição : Retorna bandeira de perda da última posição |
//+----------------------------------------------------------------------------+
//| Parâmetros: |
//| sy - nome do instrumento (" - qualquer símbolo, |
//| NULL - símbolo atual) |
| //| op - operação (-1 - qualquer posição) |
//| mn - MagicNumber (-1 - qualquer magik) |
//+----------------------------------------------------------------------------+
bool isLossLastPos(string sy="", int op=-1, int mn=-1) {
data/hora t;
int i, j=-1, k=OrdensHistóriaTotal();

se (sy=="0") sy=Símbolo();
para (i=0; i<k; i++) {
se (OrderSelect(i, SELECT_BY_POS, MODE_HISTORY)) {
if (OrderSymbol()==sy ||| sy==") {
if (OrderType()==OP_BUY || OrderType()==OP_SELL) {
se (op<0 || OrderType()==op) {
se (mn<0 || OrderMagicNumber()==mn) {
se (t<OrderCloseTime()) {
t=OrderCloseTime();
j=i;
}
}
}
}
}
}
}
se (OrderSelect(j, SELECT_BY_POS, MODE_HISTORY)) {
se (OrderProfit()<0) return(True)
}
retorno(Falso);
}





OpenBuy nulo(){
duplo dStopLoss = 0, dTakeProfit = 0;
double Lots_New = Lote;

se (isLossLastPos(NULL, -1, MAGIC))
Lots_New *= 2;
senão se (!isLossLastPos(NULL, -1, MAGIC))
Lots_New = Lote;


se (dBuyStopLossPoint > 0)
dStopLoss = Bid-dBuyStopLossPoint*Point;

se (dBuyTakeProfitPoint > 0)
dTakeProfit = Bid + dBuyTakeProfitPoint * Ponto;

int numorder = OrderSend(Symbol(), OP_BUY, Lots_New, Ask, nSlippage, dStopLoss, dTakeProfit, sNameExpert, MAGIC, 0, colorOpenBuy);

se (numorder > -1 && lFlagUseSound)
PlaySound(sSoundFileName);
}

vazio OpenSell() {
duplo dStopLoss = 0, dTakeProfit = 0;
double Lots_New = Lote;

se (isLossLastPos(NULL, -1, MAGIC))
Lots_New *= 2;
senão se (!isLossLastPos(NULL, -1, MAGIC))
Lots_New = Lote;

se (dSellStopLossPoint > 0)
dStopLoss = Ask+dSellStopLossPoint*Point;

se (dSellTakeProfitPoint > 0)
dTakeProfit = Ask-dSellTakeProfitPoint*Point;

int numorder = OrderSend(Symbol(),OP_SELLL, Lots_New, Bid, nSlippage, dStopLoss, dTakeProfit, sNameExpert, MAGIC, 0, colorOpenSell);

se (numorder > -1 && lFlagUseSound)
PlaySound(sSoundFileName);
}

 
valenok2003:

Se não é difícil consertar o exemplo, não consigo fazê-lo funcionar por alguma razão.
      ObjectSetText("info", str3, fontsize, fontname);
      ObjectSet("info", OBJPROP_CORNER, corner);
      ObjectSet("info", OBJPROP_XDISTANCE, xdistance);
      ObjectSet("info", OBJPROP_YDISTANCE, ydistance);
      ObjectSet("info", OBJPROP_COLOR, clr);

Eu fiz o canto variável externo (por conveniência). Ele contém o número do canto a partir do qual as coordenadas serão calculadas

 
Roger:


Tente substituir por

if (OrderStopLoss()<pp-(TStop.Buy+TrailingStep-1)*po||OrderStopLoss()==0)

para

if (OrderStopLoss()>pp-(TStop.Buy+TrailingStep-1)*po||OrderStopLoss()==0)

Roger, obrigado, mas ainda não funciona corretamente. Tentei outra rede de arrasto, mas o erro ainda existe :( Existe alguma diferença entre uma postura de arrasto e várias de arrasto ao mesmo tempo?
 
rensbit:

Eu fiz o canto variável externo (por conveniência). Ele contém o número do canto a partir do qual as coordenadas serão calculadas

Obrigado!

Uma pergunta a mais. Como inserir corretamente o símbolo de Wingdings nos comentários.

 
qual símbolo?
 
rensbit:
qual símbolo?

direitos autorais
1...690691692693694695696697698699700701702703704...1145
Novo comentário