Пример #1
0
        void drawItems(int offset, int itemPerColumn, float x, float y0, float cellW, float cellH, float maxPercent, int numberOfColumns, xGraphics g)
        {
            //====================================
            for (int i = 0; i < itemPerColumn; i++)
            {
                int j = i + offset;
                if (j >= mChanges.size())
                {
                    return;
                }

                int y = (int)(y0 + i * cellH);

                ShareChanges gc = (ShareChanges)mChanges.elementAt(j);
                cellW = (float)((Math.Abs(gc.changedPercent) / maxPercent) * getW() / numberOfColumns);
                //if (gc.changedPercent >= 0)
                {
                    g.setColor(gc.changedPercent > 0?C.COLOR_GREEN_DARK:C.COLOR_RED);
                    g.fillRectF(x, y, cellW, cellH - 2);

                    //  text
                    g.setColor(C.COLOR_WHITE);
                    if (gc.changedPercent > 0)
                    {
                        string s = String.Format("{0} +{1:F2} %", gc.code, gc.changedPercent);
                        g.drawString(mContext.getFontText(), s, (int)x, (int)(y + cellH / 2), xGraphics.VCENTER);
                    }
                    else
                    {
                        string s = String.Format("{0} {1:F2} %", gc.code, gc.changedPercent);
                        g.drawString(mContext.getFontText(), s, (int)x, (int)(y + cellH / 2), xGraphics.VCENTER);
                    }
                    j++;

                    gc.x = (int)x;
                    gc.y = (int)y;
                    gc.w = (int)getW() / numberOfColumns - 10;
                    gc.h = (int)cellH;
                }
            }
            //g.setColor(C.COLOR_GRAY_DARK);
            //g.drawVerticalLine((int)(x + cellW), (int)y0, getH());
        }
        override public void render(xGraphics g)
        {
            //=========================
            if (viewState == VIEWSTATE_1_NHOMNGANH && chartG != null)
            {
                chartG.render(g);
                return;
            }

            g.setColor(C.COLOR_BLACK);
            g.clear();

            if (isProcessing)
            {
                g.setColor(C.COLOR_ORANGE);
                g.drawStringInRect(mContext.getFontSmallB(), "Đang xử lý", 0, 0, getW(), getH(), xGraphics.HCENTER | xGraphics.VCENTER);
                return;
            }

            //  title
            //      [Hom nay] [1 Tuan] [1 Thang] [3 thang] [1 nam]
            //          Tang          |          Giam          |
            //  VN30: +15%; GTDG: 30.1ti    .Chart
            //
            if (mChanges.size() == 0)
            {
                calcChanged(mPeriod);
            }
            if (mChanges.size() == 0)
            {
                return;
            }


            float x, y;
            int   buttonW = 80;
            int   buttonH = 26;

            int gap = 4;

            x = (getW() - 6 * (buttonW + gap)) / 2;

            //  button
            y = 2;
            mButtonPositions.removeAllElements();
            mPeriods.removeAllElements();
            string[] buttons = { "1 Ngày", "1 Tuần", "1 Tháng", "3 Tháng", "6 Tháng", "1 Năm" };
            int[]    periods = { 1, 5, 22, 67, 130, 260 };
            for (int i = 0; i < buttons.Length; i++)
            {
                string s = buttons[i];
                g.setColor(C.COLOR_GRAY_LIGHT);
                g.drawRect((int)x, 2, buttonW, buttonH);
                g.setColor(mPeriod == periods[i]?C.COLOR_ORANGE:C.COLOR_WHITE);
                g.drawStringInRect(mContext.getFontSmallB(), s, (int)x, (int)y, buttonW, buttonH, xGraphics.HCENTER | xGraphics.VCENTER);

                Rectangle rc = new Rectangle((int)x, 2, buttonW, buttonH);
                mButtonPositions.addElement(rc);
                mPeriods.addElement(periods[i]);

                x += buttonW + gap;
            }

            g.setColor(C.COLOR_GRAY_DARK);
            g.drawHorizontalLine(0, buttonH + 4, getW());

            int    columnH    = ItemH;
            double maxPercent = 0;

            for (int i = 0; i < mChanges.size(); i++)
            {
                GroupChanges gc = (GroupChanges)mChanges.elementAt(i);
                if (Math.Abs(gc.changedPercent) > maxPercent)
                {
                    maxPercent = Math.Abs(gc.changedPercent);
                }
            }
            //--------------------
            int buttonY = 30;
            int drawH   = getH() - buttonY;

            ItemH = getItemH(getH() - 40, mChanges.size());

            float cellW = getW() / 2;
            float cellH = ItemH;

            maxPercent *= 1.15;
            //  Left side
            int j = 0;

            y = buttonY + 4;

            int itemPerColumn = mChanges.size() / 2;

            for (int i = 0; i < itemPerColumn; i++)
            {
                GroupChanges gc = (GroupChanges)mChanges.elementAt(i);
                x = 2;
                //if (gc.changedPercent >= 0)
                {
                    y     = buttonY + 4 + j * cellH;
                    cellW = (float)((Math.Abs(gc.changedPercent) / maxPercent) * getW() / 2);
                    g.setColor(gc.changedPercent > 0?C.COLOR_GREEN_DARK:C.COLOR_RED);
                    g.fillRectF(x, y, cellW, cellH - 2);

                    //  text
                    g.setColor(C.COLOR_WHITE);
                    if (gc.changedPercent >= 0)
                    {
                        string s = String.Format("{0} +{1:F2} %", gc.code, gc.changedPercent);
                        g.drawString(mContext.getFontText(), s, (int)x, (int)(y + cellH / 2), xGraphics.VCENTER);
                    }
                    else
                    {
                        string s = String.Format("{0} {1:F2} %", gc.code, gc.changedPercent);
                        g.drawString(mContext.getFontText(), s, (int)x, (int)(y + cellH / 2), xGraphics.VCENTER);
                    }
                    j++;

                    gc.x = (int)x;
                    gc.y = (int)y;
                    gc.w = (int)getW() / 2 - 10;
                    gc.h = (int)cellH;
                }
            }
            g.setColor(C.COLOR_GRAY_DARK);
            g.drawVerticalLine(getW() / 2, buttonY, getH());
            //  Right side
            j = 0;
            for (int i = itemPerColumn; i < mChanges.size(); i++)
            {
                GroupChanges gc = (GroupChanges)mChanges.elementAt(i);
                x = getW() / 2 + 2;
                //if (gc.changedPercent < 0)
                {
                    y     = buttonY + 4 + j * cellH;
                    cellW = (float)((Math.Abs(gc.changedPercent) / maxPercent) * getW() / 2);
                    g.setColor(gc.changedPercent > 0 ? C.COLOR_GREEN_DARK : C.COLOR_RED);
                    g.fillRectF(x, y, cellW, cellH - 2);

                    //  text
                    g.setColor(C.COLOR_WHITE);
                    if (gc.changedPercent >= 0)
                    {
                        string s = String.Format("{0}: +{1:F2} %", gc.code, gc.changedPercent);
                        g.drawString(mContext.getFontText(), s, (int)x, (int)(y + cellH / 2), xGraphics.VCENTER);
                    }
                    else
                    {
                        string s = String.Format("{0}: {1:F2} %", gc.code, gc.changedPercent);
                        g.drawString(mContext.getFontText(), s, (int)x, (int)(y + cellH / 2), xGraphics.VCENTER);
                    }
                    j++;

                    gc.x = (int)x;
                    gc.y = (int)y;
                    gc.w = (int)getW() / 2 - 10;
                    gc.h = (int)cellH;
                }
            }
        }
Пример #3
0
        public override void render(xGraphics g)
        {
            Share share = getShare(3);

            if (share == null)
            {
                return;
            }
            if (detectShareCursorChanged())
            {
                bankerXY    = allocMem(bankerXY, mChartLineLength * 2);
                bankerXYSMA = allocMem(bankerXYSMA, mChartLineLength * 2);
                hotmoneyXY  = allocMem(hotmoneyXY, mChartLineLength * 2);

                // banker
                int   baseBanker        = (int)getConfigValue(true, FIELD_BASE);
                int   periodBanker      = (int)getConfigValue(true, FIELD_PERIOD);
                float sensitivityBanker = getConfigValue(true, FIELD_SENSITIVITY);

                //  hot money
                int   baseHM        = (int)getConfigValue(false, FIELD_BASE);
                int   periodHM      = (int)getConfigValue(false, FIELD_PERIOD);
                float sensitivityHM = getConfigValue(false, FIELD_SENSITIVITY);

                int newChecksum = 0;
                //-----------------------
                newChecksum = share.getID() + baseBanker * 100 + periodBanker * 99 + (int)(sensitivityBanker * 1000)
                              + baseHM * 88 + periodHM * 77 + (int)(sensitivityHM * 2000);
                int checkSumData = share.getCandleCnt();
                for (int i = 0; i < 10; i++)
                {
                    checkSumData += (int)(share.getClose(share.getCandleCnt() - 1 - i) * 10);
                }
                newChecksum = newChecksum + checkSumData;
                //-----------------------
                if (checkSum != newChecksum)
                {
                    checkSum = newChecksum;

                    rsi_function(share, sensitivityBanker, periodBanker, baseBanker, rsiBanker);
                    Share.SMA(rsiBanker, 0, share.getCandleCnt(), 5, rsiBankerSMA);

                    rsi_function(share, sensitivityHM, periodHM, baseHM, rsiHotmoney);
                }

                //  banker
                pricesToYs(rsiBanker, share.mBeginIdx, bankerXY, mChartLineLength, 0, 20);

                //  sma of banker
                pricesToYs(rsiBankerSMA, share.mBeginIdx, bankerXYSMA, mChartLineLength, 0, 20);

                //  hot money
                pricesToYs(rsiHotmoney, share.mBeginIdx, hotmoneyXY, mChartLineLength, 0, 20);
            }

            String[] ss  = { "5", "10", "15" };
            float[]  tmp = { 5, 10, 15 };
            pricesToYs(tmp, 0, mPricelines, 3, 0, 20);

            for (int i = 0; i < 3; i++)
            {
                g.setColor(C.COLOR_FADE_YELLOW);
                g.drawLine(0, mPricelines[2 * i + 1], getW() - 34, mPricelines[2 * i + 1]);

                g.setColor(C.COLOR_FADE_YELLOW0);
                g.drawString(mFont, ss[i], getW() - 8, mPricelines[2 * i + 1], xGraphics.VCENTER | xGraphics.RIGHT);
            }

            int mY = 0;
            int mX = 0;

            //  bars
            mVolumeBarW = (((float)getDrawingW() / mChartLineLength) * 2.0f / 3);
            for (int i = 0; i < mChartLineLength; i++)
            {
                //  retail
                g.setColor(themeDark()?0xff005e07:C.COLOR_GREEN_DARK);

                float x = bankerXY[i * 2] - mVolumeBarW / 2;
                float y = mY + getMarginY();

                g.fillRectF(x, y, mVolumeBarW, getDrawingH());

                //  hot money
                g.setColor(themeDark()?0xffd8c200:C.COLOR_YELLOW);
                //y = mY + getMarginY() + getDrawingH() - rsiHotMoneyXY[2*i+1];
                y = hotmoneyXY[2 * i + 1];
                g.fillRectF(x, y, mVolumeBarW, mY + getMarginY() + getDrawingH() - y);

                //  banker
                g.setColor(themeDark()?0xffff0000:C.COLOR_RED);
                //y = mY + getMarginY() + getDrawingH() - rsiBankerXY[2*i+1];
                y = bankerXY[2 * i + 1];
                g.fillRectF(x, y, mVolumeBarW, mY + getMarginY() + getDrawingH() - y);
            }

            //  sma of banker
            g.setColor(C.COLOR_BLUE_LIGHT);// colorSMAOfIndicator());
            g.drawLines(bankerXYSMA, mChartLineLength, 1.0f);

            mMouseTitle = null;//"" + (int)yToPrice(mLastY, 0, 100);

            renderCursor(g);
        }
Пример #4
0
        public override void render(xGraphics g)
        {
            if (isHiding())
            {
                return;
            }
            if (getShare(3) == null)
            {
                return;
            }
            Share share = getShare();
            int   mX    = 0;
            int   mY    = 0;

            Utils.trace(String.Format("volume render: {0}", getStartX()));

            if (detectShareCursorChanged())
            {
                mHighestVolume = "";
                if (mChartLineXY == null)
                {
                    mChartLineXY = new short[2 * MAX_DRAW_POINT];
                }

                //	get biggest volume
                biggest = 0;
                lowest  = -1;
                int vol;
                int i, j;
                for (i = share.mBeginIdx; i <= share.mEndIdx; i++)
                {
                    vol = share.getVolume(i);
                    if (lowest == -1)
                    {
                        lowest = vol;
                    }
                    if (biggest < vol)
                    {
                        biggest = vol;
                    }
                    if (lowest > vol)
                    {
                        lowest = vol;
                    }
                }

                if (biggest == 0)
                {
                    return;
                }

                StringBuilder sb = Utils.sb;
                sb.Length = 0;

                lowest -= 1000;

                if (lowest < 0)
                {
                    lowest = 0;
                }

                if (biggest < 1000)
                {
                    sb.Append(biggest);
                }
                else if (biggest < 1000000)
                {
                    sb.AppendFormat("{0}KB", (int)(biggest / 1000));
                }
                else
                {
                    sb.AppendFormat("{0}M", (int)(biggest / 1000000));
                }

                mHighestVolume = sb.ToString();

                lowest /= 4;

                double ry = (float)getDrawingH() / (biggest - lowest);
                double rw = (float)getDrawingW() / mChartLineLength;
                mVolumeBarW = (int)(((float)getDrawingW() / mChartLineLength) * 2.0f / 3);

                if (mVolumeBarW < 1)
                {
                    mVolumeBarW = 1;
                }
                float volumeBarWHalf = mVolumeBarW / 2;
                int   vH             = 0;
                int   vL             = 0xffffff;
                for (i = 0; i < mChartLineLength; i++)
                {
                    j = (i + share.mBeginIdx);
                    mChartLineXY[i * 2]     = (short)(mX + CHART_BORDER_SPACING_X + i * rw + getStartX() - volumeBarWHalf); //	x
                    mChartLineXY[i * 2 + 1] = (short)(mY + getMarginY() + getDrawingH() - (share.getVolume(j) - lowest) * ry);

                    if (share.mCVolume[j] > vH)
                    {
                        vH = share.mCVolume[j];
                    }
                    if (share.mCVolume[j] < vL)
                    {
                        vL = share.mCVolume[j];
                    }
                }

                //==========================
                mSMAVolumeXY = allocMem(mSMAVolumeXY, share.getCandleCount() * 2);
                share.calcSMAVolume(0, share.getCandleCount());
                mCurrentShare = share;

                pricesToYs(share.pSMAVolume, share.mBeginIdx, mSMAVolumeXY, mChartLineLength, vL, vH);
            }

            if (mShouldDrawGrid)
            {
                drawGrid(g);
            }

            //g.setColor(0xffff00ff);
            //g.drawLine(0, 150, getW(), 150);

            g.setColor(0xff00ff00);
            int tmp = mY + getH() - getMarginY();

            for (int i = 0; i < mChartLineLength; i++)
            {
                if (share.mBeginIdx + i > 0)
                {
                    if (share.getClose(share.mBeginIdx + i) > share.getClose(share.mBeginIdx + i - 1))
                    {
                        g.setColor(0xff00c000);
                    }
                    else if (share.getClose(share.mBeginIdx + i) < share.getClose(share.mBeginIdx + i - 1))
                    {
                        g.setColor(0xffa00000);
                    }
                    else
                    {
                        g.setColor(0xffa08000);
                    }
                }
                g.fillRectF(mChartLineXY[2 * i], mChartLineXY[2 * i + 1], mVolumeBarW, tmp - mChartLineXY[2 * i + 1]);
            }

            //  sma
            g.setColor(C.COLOR_ORANGE);
            g.drawLines(mSMAVolumeXY, mChartLineLength);

            g.setColor(C.COLOR_GRAY_LIGHT);
            g.drawString(mFont, mHighestVolume, getW() - 8, 0, xGraphics.RIGHT | xGraphics.TOP);
            g.drawString(mFont, "0", getW() - 8, getH(), xGraphics.RIGHT | xGraphics.BOTTOM);

            //  calc mMouseTitle
            mMouseTitle = Utils.formatNumber((int)yToPrice(mLastY, lowest, biggest));

            renderCursor(g);
        }
Пример #5
0
        void renderVolume(xGraphics g)
        {
            int h = (int)(rcView.Height / 2.5f);

            //	get biggest volume
            long biggest = 0;
            long lowest  = -1;
            int  vol;
            int  i, j;

            for (i = beginIdx; i <= endIdx; i++)
            {
                vol = volumes[i];
                if (lowest == -1)
                {
                    lowest = vol;
                }
                if (biggest < vol)
                {
                    biggest = vol;
                }
                if (lowest > vol)
                {
                    lowest = vol;
                }
            }

            if (biggest == 0)
            {
                return;
            }

            int   rightPadding = (int)1;// xUtils.pointToPixels(1);
            float w            = rcView.Width - rightPadding;

            double ry          = (float)h / (biggest - lowest);
            double rw          = w / mChartLineLength;
            float  mVolumeBarW = ((w / mChartLineLength) * 2.0f / 3);

            float volumeBarWHalf = mVolumeBarW / 2;

            for (i = 0; i < mChartLineLength; i++)
            {
                j = (i + beginIdx);
                mChartLineXY[i * 2]     = (short)(rcView.X + (i * rw - volumeBarWHalf));        //	x
                mChartLineXY[i * 2 + 1] = (short)(rcView.Y + (h - (volumes[j] - lowest) * ry)); //  h
            }

            //  render
            g.setColor(0xff00ff00);
            float tmp = rcView.Height;
            int   y0  = rcView.Height - h;

            for (i = 0; i < mChartLineLength; i++)
            {
                if (beginIdx + i > 0)
                {
                    if (closes[beginIdx + i] > closes[beginIdx + i - 1])
                    {
                        g.setColor(0xff00c000);
                    }
                    else if (closes[beginIdx + i] < closes[beginIdx + i - 1])
                    {
                        g.setColor(0xffa00000);
                    }
                    else
                    {
                        g.setColor(0xffa08000);
                    }
                }
                g.fillRectF(mChartLineXY[2 * i], y0 + mChartLineXY[2 * i + 1], mVolumeBarW, h - mChartLineXY[2 * i + 1]);
            }
        }
Пример #6
0
        public override void render(xGraphics g)
        {
            g.setColor(0xff002000);
            g.fillRect(0, 0, getW(), getH());

            if (_isProcessing)
            {
                g.setColor(C.COLOR_ORANGE);
                g.drawStringInRect(mContext.getFontSmallB(), "Đang xử lý", 0, 0, getW(), getH(), xGraphics.HCENTER | xGraphics.VCENTER);
                return;
            }

            g.setColor(C.COLOR_ORANGE);

            String sz = String.Format("MãCP (giá, thay đổi %): Tăng/Giảm index: {0:F2}/{1:F2}", totalIndexInc, totalIndexDec);

            g.drawString(mContext.getFontSmall(), sz, 8, 1, xGraphics.TOP);

            if (totalIndexInc == 0 && totalIndexDec == 0)
            {
                return;
            }

            double total      = totalIndexInc + Math.Abs(totalIndexDec);
            float  incPercent = (float)(totalIndexInc / total);
            float  decPercent = (float)(Math.Abs(totalIndexDec) / total);

            if (incPercent < 0.25)
            {
                incPercent = 0.25f; decPercent = 1.0f - incPercent;
            }
            if (decPercent < 0.25)
            {
                decPercent = 0.25f; incPercent = 1.0f - decPercent;
            }

            float incW = (getW() - 4) * 0.5f; //incPercent;
            float decW = (getW() - 4) * 0.5f; //decPercent;

            int   maxItems = 22;
            int   incCnt   = vChangeInc.size() > maxItems?maxItems:vChangeInc.size();
            float itemH    = (getH() - 20) / maxItems;
            int   decCnt   = vChangeDec.size() > maxItems?maxItems:vChangeDec.size();

            int x0 = 1;
            int x1 = (int)(getW() - decW);

            float incBiggest = 0;
            float decBiggest = 0;

            ChangeIndexItem first = (ChangeIndexItem)vChangeInc.firstElement();

            if (vChangeInc.size() > 0)
            {
                incBiggest = 1.1f * first.modifiedValue;
            }

            first = (ChangeIndexItem)vChangeDec.firstElement();
            if (vChangeDec.size() > 0)
            {
                decBiggest = 1.1f * first.modifiedValue;
            }

            float maxBiggest = Math.Max(incBiggest, decBiggest);

            int titleH = 20;

            //  increase
            for (int i = 0; i < incCnt; i++)
            {
                ChangeIndexItem item = (ChangeIndexItem)vChangeInc.elementAt(i);

                g.setColor(C.COLOR_GREEN_DARK);
                float y     = titleH + i * itemH;
                float itemW = item.modifiedValue * incW / maxBiggest;

                g.fillRectF(x0, y, itemW, itemH - 1);

                g.setColor(C.COLOR_WHITE);
                stPriceboardState ps = mContext.mPriceboard.getPriceboard(item.shareID);

                sz = String.Format("{0}({1:F1}, {2:F1}%): {3:F3}", ps.code, item.price, item.modifiedPercent, item.modifiedValue);
                g.drawStringF(mContext.getFontSmall(), sz, x0 + 8, y + itemH / 2, xGraphics.VCENTER);

                item.x = x0;
                item.y = y;
                item.w = incW;
                item.h = itemH;
            }

            //  decrease
            for (int i = 0; i < decCnt; i++)
            {
                ChangeIndexItem item = (ChangeIndexItem)vChangeDec.elementAt(i);

                g.setColor(C.COLOR_RED);
                float y     = titleH + i * itemH;
                float itemW = item.modifiedValue * decW / maxBiggest;

                g.fillRectF(x1, y, itemW, itemH - 1);

                g.setColor(C.COLOR_WHITE);
                stPriceboardState ps = mContext.mPriceboard.getPriceboard(item.shareID);

                sz = String.Format("{0}({1:F1}, {2:F1%}): {3:F3}", ps.code, item.price, item.modifiedPercent, item.modifiedValue);
                g.drawStringF(mContext.getFontSmall(), sz, x1 + 8, y + itemH / 2, xGraphics.VCENTER);

                item.x = x1;
                item.y = y;
                item.w = decW;
                item.h = itemH;
            }

            if (currentSelected != null && currentSelected.selected)
            {
                g.setColor(C.COLOR_ORANGE);
                g.drawRectF(currentSelected.x, currentSelected.y, currentSelected.w, currentSelected.h);
            }
        }