ScaleIntY() public static method

public static ScaleIntY ( int i ) : int
i int
return int
Exemplo n.º 1
0
        private void AddAppByShellExpand(string strShell, string strName,
                                         string strIconExe)
        {
            if (string.IsNullOrEmpty(strShell))
            {
                return;
            }

            if (string.IsNullOrEmpty(strName))
            {
                strName = strShell;
            }

            Image img = null;

            if (!string.IsNullOrEmpty(strIconExe))
            {
                img = UIUtil.GetFileIcon(strIconExe, DpiUtil.ScaleIntX(16),
                                         DpiUtil.ScaleIntY(16));
            }

            OpenWithItem owi = new OpenWithItem(strShell, OwFilePathType.ShellExpand,
                                                strName, img, m_dynMenu);

            m_lOpenWith.Add(owi);
        }
Exemplo n.º 2
0
        private bool AddAppByFile(string strAppCmdLine, string strName)
        {
            if (string.IsNullOrEmpty(strAppCmdLine))
            {
                return(false);                                                // No assert
            }
            string strPath = UrlUtil.GetShortestAbsolutePath(
                UrlUtil.GetQuotedAppPath(strAppCmdLine).Trim());

            if (strPath.Length == 0)
            {
                Debug.Assert(false); return(false);
            }

            foreach (OpenWithItem it in m_lOpenWith)
            {
                if (it.FilePath.Equals(strPath, StrUtil.CaseIgnoreCmp))
                {
                    return(false);                    // Already have an item for this
                }
            }

            // Filter non-existing/legacy applications
            try { if (!File.Exists(strPath))
                  {
                      return(false);
                  }
            }
            catch (Exception) { Debug.Assert(false); return(false); }

            if (string.IsNullOrEmpty(strName))
            {
                strName = UrlUtil.StripExtension(UrlUtil.GetFileName(strPath));
            }

            Image img = UIUtil.GetFileIcon(strPath, DpiUtil.ScaleIntX(16),
                                           DpiUtil.ScaleIntY(16));

            string       strMenuText = KPRes.OpenWith.Replace(@"{PARAM}", strName);
            OpenWithItem owi         = new OpenWithItem(strPath, OwFilePathType.Executable,
                                                        strMenuText, img, m_dynMenu);

            m_lOpenWith.Add(owi);
            return(true);
        }
Exemplo n.º 3
0
        public static Image CreateBanner(int nWidth, int nHeight, BannerStyle bs,
                                         Image imgIcon, string strTitle, string strLine, bool bNoCache)
        {
            // imgIcon may be null
            Debug.Assert(strTitle != null); if (strTitle == null)
            {
                throw new ArgumentNullException("strTitle");
            }
            Debug.Assert(strLine != null); if (strLine == null)
            {
                throw new ArgumentNullException("strLine");
            }

            Debug.Assert((nHeight == StdHeight) || DpiUtil.ScalingRequired);

            if (MonoWorkarounds.IsRequired(12525) && (nHeight > 0))
            {
                --nHeight;
            }

            string strImageID = nWidth.ToString() + "x" + nHeight.ToString() + ":";

            if (strTitle != null)
            {
                strImageID += strTitle;
            }
            strImageID += ":";
            if (strLine != null)
            {
                strImageID += strLine;
            }

            if (bs == BannerStyle.Default)
            {
                bs = Program.Config.UI.BannerStyle;
            }
            if (bs == BannerStyle.Default)
            {
                Debug.Assert(false);
                bs = BannerStyle.WinVistaBlack;
            }

            strImageID += ":" + ((uint)bs).ToString();

            // Try getting the banner from the banner cache
            Image img = null;

            if (!bNoCache && m_vImageCache.TryGetValue(strImageID, out img))
            {
                return(img);
            }

            if (m_pCustomGen != null)
            {
                img = m_pCustomGen(new BfBannerInfo(nWidth, nHeight, bs, imgIcon,
                                                    strTitle, strLine));
            }

            const float fHorz = 0.90f;
            const float fVert = 90.0f;

            if (img == null)
            {
                img = new Bitmap(nWidth, nHeight, PixelFormat.Format24bppRgb);
                Graphics g = Graphics.FromImage(img);

                Color clrStart = Color.White;
                Color clrEnd   = Color.LightBlue;
                float fAngle   = fHorz;

                if (bs == BannerStyle.BlueCarbon)
                {
                    fAngle = fVert;

                    g.Clear(Color.Black);                     // Area from 3/8 to 1/2 height

                    clrStart = Color.LightGray;
                    clrEnd   = Color.Black;

                    Rectangle rect = new Rectangle(0, 0, nWidth, (nHeight * 3) / 8);
                    using (LinearGradientBrush brCarbonT = new LinearGradientBrush(
                               rect, clrStart, clrEnd, fAngle, true))
                    {
                        g.FillRectangle(brCarbonT, rect);
                    }

                    // clrStart = Color.FromArgb(0, 0, 32);
                    clrStart = Color.FromArgb(0, 0, 28);
                    // clrEnd = Color.FromArgb(192, 192, 255);
                    clrEnd = Color.FromArgb(155, 155, 214);

                    // rect = new Rectangle(0, nHeight / 2, nWidth, (nHeight * 5) / 8);
                    int hMid = nHeight / 2;
                    rect = new Rectangle(0, hMid - 1, nWidth, nHeight - hMid);
                    using (LinearGradientBrush brCarbonB = new LinearGradientBrush(
                               rect, clrStart, clrEnd, fAngle, true))
                    {
                        g.FillRectangle(brCarbonB, rect);
                    }

                    // Workaround gradient drawing bug (e.g. occuring on
                    // Windows 8.1 with 150% DPI)
                    using (Pen pen = new Pen(Color.Black))
                    {
                        g.DrawLine(pen, 0, hMid - 1, nWidth - 1, hMid - 1);
                    }
                }
                else
                {
                    if (bs == BannerStyle.WinXPLogin)
                    {
                        clrStart = Color.FromArgb(200, 208, 248);
                        clrEnd   = Color.FromArgb(40, 64, 216);
                    }
                    else if (bs == BannerStyle.WinVistaBlack)
                    {
                        clrStart = Color.FromArgb(151, 154, 173);
                        clrEnd   = Color.FromArgb(27, 27, 37);

                        fAngle = fVert;
                    }
                    else if (bs == BannerStyle.KeePassWin32)
                    {
                        clrStart = Color.FromArgb(235, 235, 255);
                        clrEnd   = Color.FromArgb(192, 192, 255);
                    }

                    Rectangle rect = new Rectangle(0, 0, nWidth, nHeight);
                    using (LinearGradientBrush brBack = new LinearGradientBrush(
                               rect, clrStart, clrEnd, fAngle, true))
                    {
                        g.FillRectangle(brBack, rect);
                    }
                }

                bool bRtl = Program.Translation.Properties.RightToLeft;
                // Matrix mxTrfOrg = g.Transform;
                // if(bRtl)
                // {
                //	g.TranslateTransform(nWidth, 0.0f);
                //	g.ScaleTransform(-1.0f, 1.0f);
                // }

                int xIcon       = DpiScaleInt(10, nHeight);
                int wIconScaled = StdIconDim;
                int hIconScaled = StdIconDim;
                if (imgIcon != null)
                {
                    float fIconRel = (float)imgIcon.Width / (float)imgIcon.Height;
                    wIconScaled = (int)Math.Round(DpiScaleFloat(fIconRel *
                                                                (float)StdIconDim, nHeight));
                    hIconScaled = DpiScaleInt(StdIconDim, nHeight);

                    int xIconR = (bRtl ? (nWidth - xIcon - wIconScaled) : xIcon);
                    int yIconR = (nHeight - hIconScaled) / 2;
                    if (hIconScaled == imgIcon.Height)
                    {
                        g.DrawImageUnscaled(imgIcon, xIconR, yIconR);
                    }
                    else
                    {
                        g.DrawImage(imgIcon, xIconR, yIconR, wIconScaled, hIconScaled);
                    }

                    ColorMatrix cm = new ColorMatrix();
                    cm.Matrix33 = 0.1f;
                    ImageAttributes ia = new ImageAttributes();
                    ia.SetColorMatrix(cm);

                    int       w = wIconScaled * 3, h = hIconScaled * 3;
                    int       x        = (bRtl ? xIcon : (nWidth - w - xIcon));
                    int       y        = (nHeight - h) / 2;
                    Rectangle rectDest = new Rectangle(x, y, w, h);
                    g.DrawImage(imgIcon, rectDest, 0, 0, imgIcon.Width, imgIcon.Height,
                                GraphicsUnit.Pixel, ia);
                }

                if ((bs == BannerStyle.WinXPLogin) || (bs == BannerStyle.WinVistaBlack) ||
                    (bs == BannerStyle.BlueCarbon))
                {
                    int sh = DpiUtil.ScaleIntY(20) / 10;                     // Force floor

                    Rectangle rect = new Rectangle(0, nHeight - sh, 0, sh);

                    rect.Width = nWidth / 2 + 1;
                    rect.X     = nWidth / 2;
                    clrStart   = Color.FromArgb(248, 136, 24);
                    clrEnd     = Color.White;
                    using (LinearGradientBrush brushOrangeWhite = new LinearGradientBrush(
                               rect, clrStart, clrEnd, fHorz, true))
                    {
                        g.FillRectangle(brushOrangeWhite, rect);
                    }

                    rect.Width = nWidth / 2 + 1;
                    rect.X     = 0;
                    clrStart   = Color.White;
                    clrEnd     = Color.FromArgb(248, 136, 24);
                    using (LinearGradientBrush brushWhiteOrange = new LinearGradientBrush(
                               rect, clrStart, clrEnd, fHorz, true))
                    {
                        g.FillRectangle(brushWhiteOrange, rect);
                    }
                }
                else if (bs == BannerStyle.KeePassWin32)
                {
                    int sh = DpiUtil.ScaleIntY(10) / 10;                     // Force floor

                    // Black separator line
                    using (Pen penBlack = new Pen(Color.Black))
                    {
                        for (int i = 0; i < sh; ++i)
                        {
                            g.DrawLine(penBlack, 0, nHeight - i - 1,
                                       nWidth - 1, nHeight - i - 1);
                        }
                    }
                }

                // if(bRtl) g.Transform = mxTrfOrg;

                // Brush brush;
                Color clrText;
                if (bs == BannerStyle.KeePassWin32)
                {
                    // brush = Brushes.Black;
                    clrText = Color.Black;
                }
                else
                {
                    // brush = Brushes.White;
                    clrText = Color.White;
                }

                // float fx = 2 * xIcon, fy = 9.0f;
                int tx = 2 * xIcon, ty = DpiScaleInt(9, nHeight);
                if (imgIcon != null)
                {
                    tx += wIconScaled;                                 // fx
                }
                // TextFormatFlags tff = (TextFormatFlags.PreserveGraphicsClipping |
                //	TextFormatFlags.NoPrefix);
                // if(bRtl) tff |= TextFormatFlags.RightToLeft;

                float fFontSize = DpiScaleFloat((12.0f * 96.0f) / g.DpiY, nHeight);
                Font  font      = FontUtil.CreateFont(FontFamily.GenericSansSerif,
                                                      fFontSize, FontStyle.Bold);
                int txT = (!bRtl ? tx : (nWidth - tx));
                // - TextRenderer.MeasureText(g, strTitle, font).Width));
                // g.DrawString(strTitle, font, brush, fx, fy);
                BannerFactory.DrawText(g, strTitle, txT, ty, font, clrText, bRtl);
                font.Dispose();

                tx += xIcon;                 // fx
                ty += xIcon * 2 + 2;         // fy

                float fFontSizeSm = DpiScaleFloat((9.0f * 96.0f) / g.DpiY, nHeight);
                Font  fontSmall   = FontUtil.CreateFont(FontFamily.GenericSansSerif,
                                                        fFontSizeSm, FontStyle.Regular);
                int txL = (!bRtl ? tx : (nWidth - tx));
                // - TextRenderer.MeasureText(g, strLine, fontSmall).Width));
                // g.DrawString(strLine, fontSmall, brush, fx, fy);
                BannerFactory.DrawText(g, strLine, txL, ty, fontSmall, clrText, bRtl);
                fontSmall.Dispose();

                g.Dispose();
            }

            if (!bNoCache)
            {
                while (m_vImageCache.Count >= MaxCachedImages)
                {
                    foreach (string strKey in m_vImageCache.Keys)
                    {
                        m_vImageCache.Remove(strKey);
                        break;                         // Remove first item only
                    }
                }

                // Save in cache
                m_vImageCache[strImageID] = img;
            }

            return(img);
        }
Exemplo n.º 4
0
        protected override void OnRenderMenuItemBackground(ToolStripItemRenderEventArgs e)
        {
            if (((e.Item.Owner is ContextMenuStrip) || (e.Item.OwnerItem != null)) &&
                e.Item.Selected)
            {
                Rectangle rect = e.Item.ContentRectangle;
                rect.Offset(0, -1);
                rect.Height += 1;

                Color clrStart  = CtsrColorTable.StartGradient(this.ColorTable.MenuItemSelected);
                Color clrEnd    = CtsrColorTable.EndGradient(this.ColorTable.MenuItemSelected);
                Color clrBorder = this.ColorTable.MenuItemBorder;

                if (!e.Item.Enabled)
                {
                    Color clrBase = this.ColorTable.MenuStripGradientEnd;
                    clrStart  = UIUtil.ColorTowardsGrayscale(clrStart, clrBase, 0.5);
                    clrEnd    = UIUtil.ColorTowardsGrayscale(clrEnd, clrBase, 0.2);
                    clrBorder = UIUtil.ColorTowardsGrayscale(clrBorder, clrBase, 0.2);
                }

                LinearGradientBrush br = new LinearGradientBrush(rect,
                                                                 clrStart, clrEnd, LinearGradientMode.Vertical);
                Pen p = new Pen(clrBorder);

                SmoothingMode smOrg = e.Graphics.SmoothingMode;
                e.Graphics.SmoothingMode = SmoothingMode.HighQuality;

                GraphicsPath gp = UIUtil.CreateRoundedRectangle(rect.X, rect.Y,
                                                                rect.Width, rect.Height, DpiUtil.ScaleIntY(2));
                if (gp != null)
                {
                    e.Graphics.FillPath(br, gp);
                    e.Graphics.DrawPath(p, gp);
                    gp.Dispose();
                }
                else                 // Shouldn't ever happen...
                {
                    e.Graphics.FillRectangle(br, rect);
                    e.Graphics.DrawRectangle(p, rect);
                }

                e.Graphics.SmoothingMode = smOrg;

                p.Dispose();
                br.Dispose();
            }
            else
            {
                base.OnRenderMenuItemBackground(e);
            }
        }