Example #1
0
        int drawThreahold(xGraphics g, int x, int y, bool isUpper)
        {
            int           imgw = mArrowImage.Width / 3;
            int           imgh = mArrowImage.Height;
            Font          f    = mContext.getFontText();
            String        s;
            StringBuilder sb = Utils.getSB();

            if (isUpper)
            {
                g.drawImage(mArrowImage, x, y, imgw, imgh, 0, 0);

                x += 10;
                g.setColor(C.COLOR_WHITE);
                if (mAlarm.upperPrice > 0)
                {
                    sb.AppendFormat("{0:F1}", (float)mAlarm.upperPrice);
                    s = sb.ToString();
                }
                else
                {
                    s = "  -";
                }
                g.drawString(f, s, x, y);

                x += g.getStringWidth(f, s);
            }
            else
            {
                g.drawImage(mArrowImage, x, y, imgw, imgh, imgw, 0);

                x += 10;
                g.setColor(C.COLOR_WHITE);
                if (mAlarm.lowerPrice > 0)
                {
                    sb.AppendFormat("{0:F1}", (float)mAlarm.lowerPrice);
                    s = sb.ToString();
                }
                else
                {
                    s = "  -";
                }
                g.drawString(f, s, x, y);
                x += g.getStringWidth(f, s);
            }

            return(x);
        }
Example #2
0
        void drawText(xGraphics g, int x)
        {
            Font f      = mContext.getFontSmall();
            Font fLabel = mContext.getFontText();

            //  ma co phieu
            g.setColor(C.COLOR_WHITE);
            string s = "#" + mTrade.getCode();

            g.drawString(mContext.getFontTextB(), s, x, 1);
            x += g.getStringWidth(mContext.getFontTextB(), s) + 5;
            //	time
            if (mCandleCnt > 0)
            {
                g.setColor(C.COLOR_GRAY_DARK);
                g.fillRect(0, getH() - 12, getW(), 12);
                g.setColor(C.COLOR_WHITE);
                g.drawString(f, mTimeStart, 0 + 1, 0 + getH(), xGraphics.BOTTOM | xGraphics.LEFT);
                g.drawString(f, mTimeEnd, mChartXYs[2 * (mCandleCnt - 1)], 0 + getH() - 12, xGraphics.BOTTOM | xGraphics.LEFT);

                g.setColor(C.COLOR_WHITE);
                s = "KL: " + Utils.formatNumber(mTrade.getVolume(-1));
                g.drawString(f, s, (getW() - Utils.getStringW(s, f)) / 2, getH(), xGraphics.BOTTOM);
            }

            g.setColor(C.GREY_LINE_COLOR);
            g.drawHorizontalLine(x, 0 + getH(), getW());
            //=============cursor & some info========================
            if (mCandleCnt > 0)
            {
                //x = getW() / 2;
                g.setColor(C.COLOR_GRAY_LIGHT);
                g.drawString(fLabel, mCurrentTrade, x, 0 + 1, xGraphics.LEFT);// xGraphics.HCENTER | xGraphics.TOP);
                g.setColor(C.COLOR_FADE_YELLOW0);
                g.drawVerticalLine(mChartXYs[2 * mCurrentTradeSel], 12, getH() - 26);
                //g.drawPoint(mChartXYs[2 * mCurrentTradeSel] - 2, mChartXYs[2 * mCurrentTradeSel + 1] - 4, 4);

                if (mChangedValue > 0)
                {
                    g.setColor(C.COLOR_GREEN);
                }
                else if (mChangedValue == 0)
                {
                    g.setColor(C.COLOR_YELLOW);
                }
                else
                {
                    g.setColor(C.COLOR_RED);
                }
                g.drawString(fLabel, mChanged, mChartXYs[2 * mCurrentTradeSel], 26);
            }
            //=====================================================
        }
Example #3
0
        virtual public int renderTitles(xGraphics g, int x, int y)
        {
            xVector v = getTitles();

            if (v != null)
            {
                for (int i = 0; i < v.size(); i++)
                {
                    stTitle t = (stTitle)v.elementAt(i);
                    g.setColor(t.color);
                    g.drawString(mFont, t.title, x, y);

                    x += g.getStringWidth(mFont, t.title) + 20;
                }
            }

            return(x);
        }
Example #4
0
        public override void render(xGraphics g)
        {
            int mH = getH();
            int mW = getW();

            if (isHiding())
            {
                return;
            }
            Share share = getShare(3);

            if (share == null)
            {
                return;
            }
            if (detectShareCursorChanged())
            {
                share.calcIchimoku();

                int newSize = mChartLineLength * 2;
                mLineTenkansen = allocMem(mLineTenkansen, newSize);
                mLineKijunsen  = allocMem(mLineKijunsen, newSize);
                mLineChikou    = allocMem(mLineChikou, newSize);
                mLineSpanA     = allocMem(mLineSpanA, newSize + 1000);
                mLineSpanB     = allocMem(mLineSpanB, newSize + 1000);

                int idx = share.mBeginIdx;
                pricesToYs(share.pTenkansen, idx, mLineTenkansen, mChartLineLength, false);
                pricesToYs(share.pKijunsen, idx, mLineKijunsen, mChartLineLength, false);
                pricesToYs(share.pChikouSpan, idx, mLineChikou, mChartLineLength, false);
                //  correct the chikou length
                int chikouCnt = share.getCandleCount() - (int)mContext.mOptIchimokuTime2;
                mChikouLineLength = mChartLineLength;
                if (idx + mChikouLineLength > chikouCnt)
                {
                    mChikouLineLength = chikouCnt - idx;
                }

                int kumoLen = mChartLineLength + (int)mContext.mOptIchimokuTime2;    //  shift 26 days ahead
                pricesToYs(share.pSpanA, idx, mLineSpanA, kumoLen, false);
                pricesToYs(share.pSpanB, idx, mLineSpanB, kumoLen, false);

                //  kumo cloud
                uint[]     colors  = { 0x40f06070, 0x40f0f0f0 }; //  bronw/white
                int        t       = mLineSpanA[1] > mLineSpanB[1] ? 0 : 1;
                xVectorInt vinters = new xVectorInt(100);
                xVectorInt vcolors = new xVectorInt(100);
                vinters.addElement(0);
                vcolors.addElement((int)colors[t]);

                for (int i = 0; i < kumoLen; i++)
                {
                    int j = 2 * i + 1;
                    if (t == 0)
                    {
                        if (mLineSpanA[j] < mLineSpanB[j])
                        {
                            t = 1 - t;
                            vinters.addElement(i);
                            vcolors.addElement((int)colors[t]);
                        }
                    }
                    else if (t == 1)
                    {
                        if (mLineSpanA[j] > mLineSpanB[j])
                        {
                            t = 1 - t;
                            vinters.addElement(i);
                            vcolors.addElement((int)colors[t]);
                        }
                    }
                }
                //===========================
                vinters.addElement(kumoLen - 1);
                vcolors.addElement(0);  //  dont care this time
                clearKumoCloud();
                //  create kumo cloud
                for (int i = 1; i < vinters.size(); i++)
                {
                    int     b     = vinters.elementAt(i - 1);
                    int     e     = vinters.elementAt(i);
                    short[] cloud = new short[((e - b + 10) * 4)];

                    int j = 0;
                    for (int k = b; k <= e; k++)
                    {
                        cloud[j++] = mLineSpanA[2 * k];
                        cloud[j++] = mLineSpanA[2 * k + 1];
                    }
                    cloud[j++] = mLineSpanB[2 * e];
                    cloud[j++] = mLineSpanB[2 * e + 1];
                    for (int k = e; k >= b; k--)
                    {
                        cloud[j++] = mLineSpanB[2 * k];
                        cloud[j++] = mLineSpanB[2 * k + 1];
                    }

                    mKumoCloud.addElement(cloud);
                    mKumoCloudItemLength.addElement(j / 2);
                    mKumoCloudColor.addElement(vcolors.elementAt(i - 1));
                }
            }

            if (mChartLineLength == 0)
            {
                return;
            }

            //===============================================
            //  tenkansen: pink
            g.setColor(0xc0ff00ff);
            g.drawLines(mLineTenkansen, mChartLineLength);

            //  kijunsen:
            g.setColor(0xc00050ff);
            g.drawLines(mLineKijunsen, mChartLineLength);

            //  chikou
            if (mChikouLineLength > 0)
            {
                g.setColor(0xc0907070);
                g.drawLines(mLineChikou, mChikouLineLength);
            }
            //  spanA
            g.setColor(0xb000a050);
            g.drawLines(mLineSpanA, mChartLineLength + (int)mContext.mOptIchimokuTime2);
            //  spanB
            g.setColor(0xb0ff0000);
            g.drawLines(mLineSpanB, mChartLineLength + (int)mContext.mOptIchimokuTime2);

            //  kumo cloud
            for (int i = 0; i < mKumoCloud.size(); i++)
            {
                short[] p = (short[])mKumoCloud.elementAt(i);
                if (p != null)
                {
                    g.setColor(mKumoCloudColor.elementAt(i));
                    g.fillShapes(p, mKumoCloudItemLength.elementAt(i));
                }
            }

            //  info
            String        sz;
            StringBuilder sb = Utils.sb;

            sb.Length = 0;
            int cur = share.getCursor();
            int y   = 24;

            if (mShouldDrawValue && cur >= 0 && cur < share.getCandleCount())
            {
                g.setColor(0x60404040);
                if (cur - mContext.mOptIchimokuTime2 > 0)
                {
                    int x0 = candleToX(cur - mContext.mOptIchimokuTime2);
                    g.drawVerticalLine(x0, 0, getH());
                }
                int x1 = candleToX(cur + mContext.mOptIchimokuTime2);
                g.drawVerticalLine(x1, 0, getH());

                //==========draw 2 shadow vertical
                g.setColor(0xffffa000);
                sb.AppendFormat("Ichi({0},{1},{2})", (int)mContext.mOptIchimokuTime1, (int)mContext.mOptIchimokuTime2, (int)mContext.mOptIchimokuTime3);
                sz = sb.ToString();
                g.drawString(mFont, sz, 130, y, 0);
                int x = 150 + g.getStringWidth(mFont, sz) + 10;

                String sz1;
                sz1 = formatPrice(share.pTenkansen[cur]);
                //  tenkansen
                g.setColor(0xc0ff00ff);
                sb.Length = 0;
                sb.AppendFormat("Tenkan: {0}", sz1);
                sz = sb.ToString();
                g.drawString(mFont, sz, x, y, 0);
                x += g.getStringWidth(mFont, sz) + 10;
                //  kijun
                g.setColor(0xc00050ff);
                sz1       = formatPrice(share.pKijunsen[cur]);
                sb.Length = 0;
                sb.AppendFormat("Kijun: {0}", sz1);
                sz = sb.ToString();
                g.drawString(mFont, sz, x, y, 0);
                x += g.getStringWidth(mFont, sz) + 10;
                //  chikou
                g.setColor(0xc0a0a0a0);
                float chikou = 0;
                if (cur < share.getCandleCount() - mContext.mOptIchimokuTime2)
                {
                    chikou = share.pChikouSpan[cur];
                }
                sz1       = formatPrice(chikou);
                sb.Length = 0;
                sb.AppendFormat("Chikou: {0}", sz1);
                sz = sb.ToString();
                g.drawString(mFont, sz, x, y, 0);
                x += g.getStringWidth(mFont, sz) + 10;
                //  spanA
                g.setColor(0xff00a050);
                sz1       = formatPrice(share.pSpanA[cur]);
                sb.Length = 0;
                sb.AppendFormat("SpanA: {0}", sz1);
                sz = sb.ToString();
                g.drawString(mFont, sz, x, y, 0);
                x += g.getStringWidth(mFont, sz) + 10;
                //  spanB
                g.setColor(0xb0ff0000);
                sz1       = formatPrice(share.pSpanB[cur]);
                sb.Length = 0;
                sb.AppendFormat("SpanB: {0}", sz1);
                sz = sb.ToString();
                g.drawString(mFont, sz, x, y, 0);
            }
        }
Example #5
0
        override public void render(xGraphics g)
        {
            Utils.trace("=====render today candle");

            if (mIsSelected)
            {
                g.setColor(C.COLOR_BLUE);
                g.fillRect(0, 0, getW(), getH());

                g.setColor(C.COLOR_BLACK);
                g.fillRect(3, 3, getW() - 6, getH() - 6);
            }
            else
            {
                g.setColor(C.COLOR_BLACK);
                g.fillRect(0, 0, getW(), getH());
            }

            g.setColor(C.COLOR_GRAY_LIGHT);
            g.drawRect(0, 0, getW() - 1, getH() - 1);

            Share share = mShare;

            if (share == null)
            {
                return;
            }

            int x, y;

            x = 0;
            y = 0;
            int h = getH();

            if (mHasTitle)
            {
                Font ft = mContext.getFontTextB();
                //  title background
                if (mIsSelected)
                {
                    g.setColor(C.COLOR_BLUE);
                }
                else
                {
                    g.setColor(0xff204040);
                }
                //g.setColor(0xff004070);
                g.fillRect(1, 1, getW() - 2, 1 * ft.Height);

                //  code
                g.setColor(C.COLOR_WHITE);
                g.drawString(ft, mShare.mCode, 1, 1);
                //  point
                stPriceboardState ps     = mContext.mPriceboard.getPriceboard(share.getID());
                float             price  = ps.getCurrentPrice();
                float             change = price - ps.getRef();
                StringBuilder     sb     = Utils.getSB();
                if (change >= 0)
                {
                    sb.AppendFormat("{0:F2} (+{1:F2})", (float)price, (float)change);
                }
                else
                {
                    sb.AppendFormat("{0:F2} ({1:F2})", (float)price, (float)change);
                }

                x += g.getStringWidth(ft, mShare.mCode) + 4;

                uint color = mContext.valToColorF(price, ps.getCe(), ps.getRef(), ps.getFloor());
                g.setColor(color);
                g.drawString(ft, sb.ToString(), x, 1);
                //=====vol
                g.setColor(C.COLOR_ORANGE);
                x  = 1;
                ft = mContext.getFontSmall();
                y  = getH() - ft.Height;

                sb.Length = 0;
                if (ps.getTotalVolume() > 100000)
                {
                    sb.AppendFormat("{0}K", (ps.getTotalVolume() / 1000));
                }
                else if (ps.getTotalVolume() > 1000)
                {
                    sb.AppendFormat("{0:F1}K", (float)(ps.getTotalVolume() / 1000));
                }
                else
                {
                    sb.AppendFormat("{0}", ps.getTotalVolume());
                }
                g.drawString(ft, sb.ToString(), x, y);
                //=========================
                x  = 0;
                h -= (int)ft.Height;
                y  = ft.Height;
            }
            //===========================================
            drawCandle(g, x, y, getW(), h);
        }
Example #6
0
        public override void render(xGraphics g)
        {
            g.setColor(C.COLOR_BLACK);
            g.clear();
            g.setColor(0xffffffff);
            g.drawLine(0, 0, 0, getH());
            stPriceboardStateIndex pi = mContext.mPriceboard.getPriceboardIndexOfMarket(mMarketID);

            if (pi == null || pi.current_point == 0)
            {
                return;
            }

            //===========================================
            //  VNIndex 375.3 (-1.86, -0.49%)   KL: 37,716,548 GT: 560.9 ty     up:84 no:53 down:169
            //===========================================
            int lineH = 20;

            int  x0 = 4;
            int  x  = x0;
            int  y  = 0;
            uint color;

            g.setColor(C.COLOR_WHITE);

            Font fTitle = mContext.getFontTextItalic();

            //  date
            x = x0;
            g.setColor(C.COLOR_WHITE);
            g.drawString(fTitle, pi.mDate, x, y);
            y += lineH;
            //==============================
            //  VNINDEX
            g.drawString(mFont, pi.code, x, y);
            //======point

            if (pi.changed_point > 0)
            {
                color = C.COLOR_GREEN;
            }
            else if (pi.changed_point < 0)
            {
                color = C.COLOR_RED;
            }
            else
            {
                color = C.COLOR_YELLOW;
            }
            g.setColor(color);

            String s;

            s = String.Format("{0:F2}", pi.current_point);
            //  point
            x += g.getStringWidth(mFont, pi.code) + 10;
            g.drawString(mFont, s, x, y);

            //  change
            g.setColor(C.COLOR_WHITE);
            y += lineH + 10;
            g.drawString(fTitle, "Thay đổi: ", x0, y);

            x = x0 + g.getStringWidth(fTitle, "Thay đổi: ") + 6;
            g.setColor(color);
            //  change
            String        s1             = String.Format("{0:F2}", pi.changed_point);
            float         changedPercent = (pi.changed_point * 100) / pi.current_point;
            String        s2             = String.Format("{0:F2}", changedPercent);
            StringBuilder sb             = Utils.sb;

            sb.Length = 0;
            sb.AppendFormat("({0}, {1} %)", s1, s2);
            s = sb.ToString();
            g.drawString(mFont, s, x, y);

            x  = x0;
            y += lineH + 10;
            //  KL
            g.setColor(C.COLOR_WHITE);
            double t = pi.total_volume;

            t /= 1000000;
            //s =
            s = Utils.formatNumber((float)t, 2);
            //Utils.formatNumber(0, 1);
            sb.Length = 0;
            sb.AppendFormat("KLGD: {0} tr", s);
            g.drawString(mFont, sb.ToString(), x, y);

            x  = x0;
            y += lineH;
            //  GT
            s         = Utils.formatDecimalNumber(pi.totalGTGD, 1000, 1);
            sb.Length = 0;
            sb.AppendFormat("GTGD: {0} tỷ", s);
            g.drawString(mFont, sb.ToString(), x, y);

            x  = x0;
            y += lineH;
            //  cung-cau
            g.setColor(C.COLOR_WHITE);

            double[] tt = { 0, 0 };
            calcBuySellRemains(pi.marketID, tt);
            //  mua
            t = tt[0] / 1000000;
            s = Utils.formatNumber((float)t, 1);
            //  ban
            t         = tt[1] / 1000000;
            s1        = Utils.formatNumber((float)t, 1);
            sb.Length = 0;
            sb.AppendFormat("Dư mua/bán (tr): {0} / {1}", s, s1);
            g.drawString(mFont, sb.ToString(), x, y);

            x = x0;

            y += lineH + 10;

            g.setColor(C.COLOR_WHITE);
            g.drawString(fTitle, "Số mã tăng/giảm:", x, y);
            y += lineH;
            //  up/none/down
            int frmW = mArrows.Width / 3;
            int frmH = mArrows.Height;

            g.drawImage(mArrows, x, y, frmW, frmH, 0, 0);
            x += frmW + 2;
            g.setColor(C.COLOR_GREEN);
            g.drawString(mFont, "" + pi.inc_cnt, x, y);
            x += 40;
            //  none
            g.drawImage(mArrows, x, y, frmW, frmH, 2 * frmW, 0);
            x += frmW + 2;
            g.setColor(C.COLOR_YELLOW);
            g.drawString(mFont, "" + pi.floor_cnt, x, y);
            x += 40;
            //  down
            g.drawImage(mArrows, x, y, frmW, frmH, frmW, 0);
            x += frmW + 2;
            g.setColor(C.COLOR_RED);
            g.drawString(mFont, "" + pi.dec_cnt, x, y);

            //===========cao:
            x = x0;
            g.setColor(C.COLOR_YELLOW);
            TradeHistory trade = mContext.getTradeHistory(pi.id);

            //  referent
            s  = String.Format("{0:F2}", pi.reference);
            y += lineH + 10;
            s  = "Tham chiếu: " + s;
            //fTitle = mContext.getFon
            g.drawString(mFont, s, x, y);
            //  cao
            s  = String.Format("{0:F2}", trade.mHighest);
            y += lineH;
            s  = "Cao nhất: " + s;
            g.drawString(mFont, s, x, y);

            //  thap
            s  = String.Format("{0:F2}", trade.mLowest);
            y += lineH;
            s  = "Thấp nhất: " + s;
            g.drawString(mFont, s, x, y);
        }
Example #7
0
        override public void render(xGraphics g)
        {
            g.setColor(C.COLOR_BLACK);
            g.clear();

            //  title

            xVector v = getMoneyVolumeArray();

            if (v == null || v.size() == 0)
            {
                return;
            }
            int biggest = 0;
            int i       = 0;

            for (i = 0; i < v.size(); i++)
            {
                MoneyVol mv = (MoneyVol)v.elementAt(i);
                if (mv.volume > biggest)
                {
                    biggest = mv.volume;
                }
            }

            float             rx;
            StringBuilder     sb = Utils.sb;
            uint              color;
            int               itemH = (getH() - 18) / v.size() - 4;
            int               y     = 4;
            int               x     = 60;
            stPriceboardState ps    = mContext.mPriceboard.getPriceboard(mShareID);

            if (ps == null)
            {
                return;
            }

            Font   f  = mContext.getFontSmall();
            int    x1 = g.getStringWidth(f, "444.44") + 2;
            int    w0 = getW() - x1;
            string s;

            g.setColor(C.COLOR_GRAY_DARK);
            g.fillRect(0, 0, x1, 14);
            g.setColor(C.COLOR_WHITE);
            g.drawString(f, "Giá", 2, 0);

            g.setColor(C.COLOR_GRAY_DARK);
            g.fillRect(x1 + 2, 0, getW() - x1 - 5, 14);
            g.setColor(C.COLOR_WHITE);
            g.drawString(f, "Khối lượng", x1 + 4, 0);

            y = 18;
            for (i = 0; i < v.size(); i++)
            {
                MoneyVol mv = (MoneyVol)v.elementAt(i);
                sb.Length = 0;
                sb.AppendFormat("{0:F2}", (float)mv.price);
                //  gia
                g.setColor(C.COLOR_GRAY_DARK);
                g.fillRect(0, y, x1, itemH);
                g.setColor(0xffffffff);
                g.drawString(f, sb.ToString(), 2, y);

                if (x1 == 0)
                {
                    x1 = g.getStringWidth(f, sb.ToString());
                }
                //  column
                color = mContext.valToColorF(mv.price, ps.getCe(), ps.getRef(), ps.getFloor());
                g.setColor(color);
                float w = ((float)mv.volume / biggest) * (w0 - 10);
                g.fillRect(2 + x1, y, (int)w, itemH);
                //  volume
                s         = Utils.formatNumber(mv.volume);
                sb.Length = 0;
                sb.AppendFormat("kl={0:}", s);
                s = sb.ToString();
                int w2 = g.getStringWidth(f, s) + 2;
                g.setColor(C.COLOR_GRAY_DARK);
                g.fillRect(4 + x1, y, w2, 14);
                g.setColor(C.COLOR_ORANGE);
                g.drawString(f, s, 5 + x1, y);
                y += itemH + 3;
            }
        }