Exemple #1
0
        //public void OnActivate()
        //{
        //    if (!(Model.Count > 0))
        //    {
        //        NavigationService.GoBack();
        //    }
        //}

        public Bitmap CreateScreenShot()
        {
            Bitmap    bitmap = new Bitmap(Width, Height);
            Rectangle rect   = new Rectangle(0, 0, Width, Height);

            using (Graphics g = Graphics.FromImage(bitmap))
            {
                IntPtr gMemPtr = g.GetHdc();

                using (Gdi gMem = Gdi.FromHdc(gMemPtr, Rectangle.Empty))
                {
                    DrawBackground(gMem, rect);

                    if (Canvas != null)
                    {
                        Canvas.Render(gMem, rect);
                    }

                    foreach (Control control in Controls)
                    {
                        if (control is KineticControlBase)
                        {
                            ((KineticControlBase)control).DrawRender(gMem);
                        }
                    }
                }

                g.ReleaseHdc(gMemPtr);
            }

            return(bitmap);
        }
        private void SetStartPositions(List <NativeItemData> nid)
        {
            int c = 0;

            StartPositions.Clear();

            if (ItemCount == 0)
            {
                _ActiveListHeight = 0;
                _ActiveListWidth  = 0;
                return;
            }

            var hdcMem = OffScreenGraphics.GetHdc();

            try
            {
                using (Gdi g = Gdi.FromHdc(hdcMem, Rectangle.Empty))
                {
                    g.Font      = Settings.SecondaryTextFontGdi;
                    g.TextAlign = Win32.TextAlign.TA_LEFT;

                    for (int i = 0; i < ItemCount; i++)
                    {
                        StartPositions.Add(c);

                        //nid[i].SecondaryTextLines = TextFormatHelper.CutTextToLines(nid[i].SecondaryText, Width - UISettings.CalcPix(40), 0, g);
                        nid[i].SecondaryTextLines = TextFormatHelper.CutTextToLines(nid[i].SecondaryText, Width - UISettings.CalcPix(29), Settings.SecondaryTextLinesCount, g);

                        //SecondaryTextLinesCount

                        c += (Settings.ListItemPixSize + (nid[i].SecondaryTextLines.Count + 1) * UISettings.CalcPix(11));

                        if (ShowGroupHeader)
                        {
                            //if (IsItemNewGroup(nItem) && item.Group != null && rItem.Top >= rListRect.Top)
                            if (IsItemNewGroup(i) && nid[i].Group != null)
                            {
                                c += Settings.GroupPixHeight;
                            }
                        }

                        //c += Settings.ListItemPixSize;
                    }
                }
            }
            finally
            {
                OffScreenGraphics.ReleaseHdc(hdcMem);
            }

            StartPositions.Add(c); //The end of tha last item

            _ActiveListHeight = c;

            ScrollTo(0);
        }
        protected override List <NativeItemData> BuildNativeControlItems()
        {
            var newListData = new List <NativeItemData>(Items.Count);

            if (Items != null)
            {
                var hdcMem = OffScreenGraphics.GetHdc();

                try
                {
                    using (Gdi g = Gdi.FromHdc(hdcMem, Rectangle.Empty))
                    {
                        g.Font      = Settings.SecondaryTextFontGdi;
                        g.TextAlign = Win32.TextAlign.TA_LEFT;

                        for (int i = 0; i < Items.Count; i++)
                        {
                            string photo = string.Empty;

                            if (Items[i].IsPhotoLoaded)
                            {
                                photo = Items[i].Photo;
                            }
                            else
                            {
                                photo = "clear";
                            }

                            NativeItemData newNativeItemData = new KineticListView <PhotoCommentsUpdatesViewItem> .NativeItemData
                            {
                                Uid   = Items[i].Uid,
                                Group = Items[i].Group,

                                PrimaryText   = Items[i].SenderName,
                                SecondaryText = Items[i].Comment,
                                TertiaryText  = Items[i].CommentSetDate.ToString("HH:mm"),

                                SecondaryTextLines = TextFormatHelper.CutTextToLines(Items[i].Comment, UISettings.CalcPix(170), 2, g),

                                PrimaryImageURL = photo,

                                InfoLeftIndents = new int[3],
                                InfoTopIndents  = new int[2]
                            };

                            newListData.Add(newNativeItemData);
                        }
                    }
                }
                finally
                {
                    OffScreenGraphics.ReleaseHdc(hdcMem);
                }
            }

            return(newListData);
        }
        protected override List <NativeItemData> BuildNativeControlItems()
        {
            var newListData = new List <NativeItemData>(Items.Count);

            if (Items != null)
            {
                for (int i = 0; i < Items.Count; i++)
                {
                    List <string> secondaryTextLines = new List <string>();

                    var hdcMem = OffScreenGraphics.GetHdc();

                    try
                    {
                        using (Gdi g = Gdi.FromHdc(hdcMem, Rectangle.Empty))
                        {
                            g.Font      = Settings.SecondaryTextFontGdi;
                            g.TextAlign = Win32.TextAlign.TA_LEFT;

                            secondaryTextLines = TextFormatHelper.CutTextToLines(Items[i].MessageText, UISettings.CalcPix(192), 2, g);
                        }
                    }
                    finally
                    {
                        OffScreenGraphics.ReleaseHdc(hdcMem);
                    }

                    NativeItemDataNew newNativeItemData = new NativeItemDataNew
                    {
                        Uid = Items[i].Uid,

                        PrimaryText   = Items[i].UserName,
                        SecondaryText = Items[i].MessageText,
                        TertiaryText  = Items[i].MessageWroteDateString,

                        SecondaryTextLines = secondaryTextLines,

                        IsItemHighlight = Items[i].IsMessageNew,
                        IsOutboxIconSet = Items[i].IsMessageOutbox,

                        Tag          = Items[i].UserID,
                        PrimaryImage = null,//MasterForm.SkinManager.GetImage("IsOutputMessage"),

                        InfoLeftIndents = new int[5],
                        InfoTopIndents  = new int[3]
                    };

                    newListData.Add(newNativeItemData);
                }
            }

            return(newListData);
        }
Exemple #5
0
        public void DrawRender(Gdi g)
        {
            Rectangle rect   = new Rectangle(0, 0, Width, Height);
            IntPtr    hdcMem = OffScreenGraphics.GetHdc();

            using (Gdi gMem = Gdi.FromHdc(hdcMem, Rectangle.Empty))
            {
                DrawScreenOn(gMem, rect, _currentScrollPosition);

                g.BitBlt(Location.X, Location.Y, rect.Width, rect.Height, gMem, 0, 0, TernaryRasterOperations.SRCCOPY);
            }

            OffScreenGraphics.ReleaseHdc(hdcMem);
        }
Exemple #6
0
        /// <summary>
        /// Render method to implement by inheritors
        /// </summary>
        /// <param name="graphics">Graphics object.</param>
        /// <param name="clipRect">Rectangle in which to paint</param>
        protected void OnRender(Graphics graphics, Rectangle clipRect)
        {
            IntPtr hdc = graphics.GetHdc();

            try
            {
                using (Gdi gMem = Gdi.FromHdc(hdc, Rectangle.Empty))  //e.ClipRectangle
                {
                    OnRender(gMem, clipRect);
                }
            }
            finally
            {
                graphics.ReleaseHdc(hdc);
            }
        }
Exemple #7
0
        protected override void OnPaint(PaintEventArgs e)
        {
            IntPtr hdc = e.Graphics.GetHdc();

            try
            {
                using (Gdi gMem = Gdi.FromHdc(hdc, e.ClipRectangle)) //	 Rectangle.Empty
                {
                    OnRender(gMem, e.ClipRectangle);
                }
            }
            finally
            {
                e.Graphics.ReleaseHdc(hdc);
            }
        }
Exemple #8
0
        protected bool OnPaint(IntPtr hWnd)
        {
            var ps = new Win32.PAINTSTRUCT();

            if (OffScreenGraphics == null)
            {
                return(false);
            }

            var hdc    = Win32.BeginPaint(hWnd, ref ps);
            var hdcMem = OffScreenGraphics.GetHdc();

            try
            {
                using (Gdi g = Gdi.FromHdc(hdc, ps.rcPaint))
                {
                    using (Gdi gMem = Gdi.FromHdc(hdcMem, Rectangle.Empty))
                    {
                        Rectangle rect = ps.rcPaint;

                        try
                        {
                            DrawScreenOn(gMem, rect, _currentScrollPosition);
                        }
                        catch (COMException ex)
                        {
                            throw;
                        }
                        catch (Exception)
                        {
                            throw;
                        }

                        g.BitBlt(rect.Left, rect.Top, rect.Right - rect.Left, rect.Bottom - rect.Top, gMem, rect.Left, rect.Top,
                                 TernaryRasterOperations.SRCCOPY);
                    }
                }
            }
            finally
            {
                OffScreenGraphics.ReleaseHdc(hdcMem);
                Win32.EndPaint(hWnd, ref ps);
            }

            return(true);
        }
Exemple #9
0
        private void SetStartPositions(List <NativeItemData> nid)
        {
            int c = 0;

            StartPositions.Clear();

            if (ItemCount == 0)
            {
                _ActiveListHeight = 0;

                return;
            }

            var hdcMem     = OffScreenGraphics.GetHdc();
            int lastHeight = 0;

            try
            {
                using (Gdi g = Gdi.FromHdc(hdcMem, Rectangle.Empty))
                {
                    g.Font      = Settings.SecondaryTextFontGdi;
                    g.TextAlign = Win32.TextAlign.TA_LEFT;

                    // для текста в каждой ячейке
                    for (int i = 0; i < ItemCount; i++)
                    {
                        StartPositions.Add(c);

                        nid[i].SecondaryTextLines = TextFormatHelper.CutTextToLines(nid[i].SecondaryText, UISettings.CalcPix(200), 0, g);

                        c += (Settings.ListItemPixSize + (nid[i].SecondaryTextLines.Count + 1) * UISettings.CalcPix(11));
                    }

                    StartPositions.Add(c);
                }
            }
            finally
            {
                OffScreenGraphics.ReleaseHdc(hdcMem);
            }



            _ActiveListHeight = c;
        }
Exemple #10
0
        public Bitmap CreateScreenShot(Size size)
        {
            Bitmap   snapShotBmp      = null;
            Graphics snapShotGraphics = null;
            var      hdcMem           = IntPtr.Zero;

            try
            {
                snapShotBmp      = new Bitmap(size.Width, size.Height);
                snapShotGraphics = Graphics.FromImage(snapShotBmp);

                if (size != ClientSize)
                {
                    snapShotGraphics.Clear(BackColor);
                }

                hdcMem = snapShotGraphics.GetHdc();

                using (var gMem = Gdi.FromHdc(hdcMem, Rectangle.Empty))
                {
                    DrawScreenOn(gMem, ClientRectangle, _currentScrollPosition);
                }
            }
            catch (Exception ex)
            {
                DebugHelper.WriteLogEntry(ex.ToString());
                if (snapShotBmp != null)
                {
                    snapShotBmp.Dispose();
                    snapShotBmp = null;
                }
            }
            finally
            {
                if (snapShotGraphics != null)
                {
                    //tr
                    snapShotGraphics.ReleaseHdc(hdcMem);
                    snapShotGraphics.Dispose();
                }
            }

            return(snapShotBmp);
        }
Exemple #11
0
        private void FormResize(object sender, EventArgs e)
        {
            loginLogo.Location = new Point((Width - loginLogo.Width) / 2, UISettings.CalcPix(23));

            var bmp = new Bitmap(Width, Height);

            using (Graphics g = Graphics.FromImage(bmp))
            {
                IntPtr hdc = g.GetHdc();
                using (Gdi loginGdi = Gdi.FromHdc(hdc, new Rectangle(0, 0, Width, Height)))
                {
                    loginGdi.GradientFill(ClientRectangle, Color.FromArgb(21, 70, 114), Color.FromArgb(78, 121, 161),
                                          FillDirection.TopToBottom);
                }
                g.ReleaseHdc(hdc);
            }
            BackgroundImage = bmp;
            //bmp.Dispose();
        }
Exemple #12
0
        protected virtual void OnRender(Gdi graphics, Rectangle clipRect)
        {
            IntPtr ptrSrc = OffscreenBuffer.OffScreenGraphics.GetHdc();

            using (Gdi gr = Gdi.FromHdc(ptrSrc, Rectangle.Empty))
            {
                DrawBackground(gr, clipRect);

                // Pass the graphics to the canvas to render
                if (Canvas != null)
                {
                    Canvas.Render(gr, clipRect);
                }
            }

            graphics.BitBlt(clipRect.Left, clipRect.Top, Width, Height, ptrSrc, clipRect.Left, clipRect.Top, TernaryRasterOperations.SRCCOPY);

            OffscreenBuffer.OffScreenGraphics.ReleaseHdc(ptrSrc);

            InvokeFirstRender();
        }
        protected override void OnRender(Gdi graphics, Rectangle clipRect)
        {
            IntPtr ptrSrc = OffscreenBuffer.OffScreenGraphics.GetHdc();

            using (Gdi gr = Gdi.FromHdc(ptrSrc, Rectangle.Empty))
            {
                DrawBackground(gr, clipRect);

                // fill background with double gradient
                var y = (int)(_backgroundRectangle.Height * _gradientCenter);

                gr.GradientFill(new Rectangle(_backgroundRectangle.Left, _backgroundRectangle.Top,
                                              _backgroundRectangle.Width, y),
                                _gradientColor1, _gradientColor2, FillDirection.TopToBottom);

                gr.GradientFill(new Rectangle(_backgroundRectangle.Left, _backgroundRectangle.Top + y,
                                              _backgroundRectangle.Width, _backgroundRectangle.Height - y),
                                _gradientColor2, _gradientColor3, FillDirection.TopToBottom);

                // Pass the graphics to the canvas to render
                if (Canvas != null)
                {
                    Canvas.Render(gr, clipRect);
                }

                //Draw Text
                SetFont(gr);

                gr.DrawText(_message,
                            new Win32.RECT(_textRectangle.X,
                                           _textRectangle.Y,
                                           _textRectangle.Width,
                                           _textRectangle.Height),
                            Win32.DT.LEFT | Win32.DT.TOP | Win32.DT.WORDBREAK | Win32.DT.NOCLIP);
            }

            graphics.BitBlt(clipRect.Left, clipRect.Top, Width, Height, ptrSrc, clipRect.Left, clipRect.Top, TernaryRasterOperations.SRCCOPY);

            OffscreenBuffer.OffScreenGraphics.ReleaseHdc(ptrSrc);
        }
Exemple #14
0
        private void FormResize(object sender, EventArgs e)
        {
            if (this.Width < this.Height)
            {
                giLogo.Location = new Point((Width - giLogo.Width) / 2, UISettings.CalcPix(45));

                lblVersion.Top         = UISettings.CalcPix(125);
                lblVersionShadow.Top   = UISettings.CalcPix(125 + 1);
                lblButtonSubstitue.Top = UISettings.CalcPix(145);

                giGlassoftLogo.Location = new Point((Width - giGlassoftLogo.Width) / 2, Height - UISettings.CalcPix(35));
            }
            else
            {
                giLogo.Location = new Point((Width - giLogo.Width) / 2, UISettings.CalcPix(25));

                lblVersion.Top         = UISettings.CalcPix(90);
                lblVersionShadow.Top   = UISettings.CalcPix(90 + 1);
                lblButtonSubstitue.Top = UISettings.CalcPix(100);

                giGlassoftLogo.Location = new Point((Width - giGlassoftLogo.Width) / 2, Height - UISettings.CalcPix(35));
            }

            var bmp = new Bitmap(Width, Height);

            using (Graphics g = Graphics.FromImage(bmp))
            {
                IntPtr hdc = g.GetHdc();

                using (Gdi loginGdi = Gdi.FromHdc(hdc, new Rectangle(0, 0, Width, Height)))
                {
                    loginGdi.GradientFill(ClientRectangle, Color.FromArgb(21, 70, 114), Color.FromArgb(78, 121, 161), FillDirection.TopToBottom);
                }

                g.ReleaseHdc(hdc);
            }

            BackgroundImage = bmp;
        }
Exemple #15
0
        private void FlipOut(Gdi mem, Rectangle canvas, IntPtr dc, IntPtr stretchDC, double transitionPct)
        {
            int margin = (int)((double)_CanvasMiddle * transitionPct);

            using (Gdi stretch = Gdi.FromHdc(stretchDC, Rectangle.Empty))
            {
                stretch.FillRect(canvas, Color.Gainsboro);
                stretch.StretchBlt(0, 0, canvas.Width - margin * 2, canvas.Height,
                                   dc,
                                   0, 0, canvas.Width, canvas.Height, TernaryRasterOperations.SRCCOPY);
            }

            var currLine = BuildPath(_FlipOutLeftPath[margin].X, _FlipOutLeftPath[margin].Y, _FlipOutTopPath[margin].X,
                                     _FlipOutTopPath[margin].Y);

            for (int i = 0; i < currLine.Count - 1; i++)
            {
                mem.StretchBlt(currLine[i].X, currLine[i].Y, 1, canvas.Height - currLine[i].Y * 2,
                               stretchDC,
                               i, 0, 1, canvas.Height,
                               TernaryRasterOperations.SRCCOPY);
            }
        }
Exemple #16
0
        bool OnPaint(IntPtr hWnd)
        {
            if (CurrentTransition == null)
            {
                return(false);
            }

            var ps = new Win32.PAINTSTRUCT();

            IntPtr hdc = Win32.BeginPaint(hWnd, ref ps);

            IntPtr hdcMem = _offScreenGraphics.GetHdc();

            using (Gdi g = Gdi.FromHdc(hdc, ps.rcPaint))
            {
                using (Gdi gMem = Gdi.FromHdc(hdcMem, Rectangle.Empty))
                {
                    Rectangle rect = ps.rcPaint;

                    try
                    {
                        CurrentTransition.DrawScreenOn(gMem, ps.rcPaint);
                    }
                    catch (Exception)
                    {
                        throw;
                    }

                    g.BitBlt(rect.Left, rect.Top, rect.Width, rect.Height, hdcMem, rect.Left, rect.Top,
                             TernaryRasterOperations.SRCCOPY);
                }
            }

            _offScreenGraphics.ReleaseHdc(hdcMem);
            Win32.EndPaint(hWnd, ref ps);
            return(true);
        }
        protected Bitmap CreateBitmapFromIImage(IImage img, bool isSelected)
        {
            ImageInfo ii;

            if (img != null)
            {
                img.GetImageInfo(out ii);
            }
            else
            {
                return(null);
            }

            int topIndent = -UISettings.CalcPix(15);  //Arrow
            int height    = Settings.ListItemPixSize;

            Bitmap res = new Bitmap((int)ii.Width, (int)ii.Height);

            using (Graphics gr = Graphics.FromImage(res))
            {
                IntPtr ptr = gr.GetHdc();
                try
                {
                    using (Gdi g = Gdi.FromHdc(ptr, Rectangle.Empty))
                    {
                        DrawItemBackgroundOn(g, null, new Rectangle(0, topIndent, res.Width, height), 0, isSelected);
                        g.DrawImageAlphaChannel(img, 0, 0);
                    }
                }
                finally
                {
                    gr.ReleaseHdc(ptr);
                }
            }
            return(res);
        }
Exemple #18
0
        public Bitmap CreateScreenShot()
        {
            var bitmap = new Bitmap(Width, Height);
            var rect   = new Rectangle(0, 0, Width, Height);

            using (Graphics g = Graphics.FromImage(bitmap))
            {
                IntPtr gMemPtr = g.GetHdc();

                using (Gdi gMem = Gdi.FromHdc(gMemPtr, Rectangle.Empty))
                {
                    DrawBackground(gMem, rect);

                    if (Canvas != null)
                    {
                        Canvas.Render(gMem, rect);
                    }
                }

                g.ReleaseHdc(gMemPtr);
            }

            return(bitmap);
        }
Exemple #19
0
        private void SetStartPositions(List <NativeItemData> nid)
        {
            int c = 0;

            StartPositions.Clear();

            if (ItemCount == 0)
            {
                _ActiveListHeight = 0;

                return;
            }

            var hdcMem = OffScreenGraphics.GetHdc();

            try
            {
                using (Gdi g = Gdi.FromHdc(hdcMem, Rectangle.Empty))
                {
                    g.Font      = Settings.SecondaryTextFontGdi;
                    g.TextAlign = Win32.TextAlign.TA_LEFT;

                    // для текста в каждой ячейке
                    for (int i = 0; i < ItemCount; i++)
                    {
                        StartPositions.Add(c);

                        // есть заголовок группы?
                        if (IsItemNewGroup(i) && !string.IsNullOrEmpty(nid[i].Group))
                        {
                            c += Settings.GroupPixHeight;
                        }

                        // что выводим?
                        switch (Items[i].Type)
                        {
                        case ImageDetailedListViewItemType.Author:     // ячейка "автор"
                            c += UISettings.CalcPix(25);
                            break;

                        case ImageDetailedListViewItemType.Comment:     // ячейка "комментарий"
                            nid[i].SecondaryTextLines = TextFormatHelper.CutTextToLines(nid[i].SecondaryText, Width - UISettings.CalcPix(10), 0, g);
                            c += (Settings.ListItemPixSize + (nid[i].SecondaryTextLines.Count + 1) * UISettings.CalcPix(11));
                            break;

                        case ImageDetailedListViewItemType.Photo:
                            if (Items[i].IsPhotoLoaded)
                            {
                                c += Items[i].PhotoHeight;
                            }
                            else
                            {
                                c += UISettings.CalcPix(50);
                            }
                            break;
                        }
                    }
                }
            }
            finally
            {
                OffScreenGraphics.ReleaseHdc(hdcMem);
            }

            StartPositions.Add(c);

            _ActiveListHeight = c;

            ScrollTo(0);
        }