Example #1
0
        private static bool callScriptTextOutForItem(IntPtr HDC, IntPtr psc, int x, int y, uint fuOptions, Win32.RECT lprc,
                                                     Uniscribe.SCRIPT_ANALYSIS psa, string pwcReserved, int iReserved,
                                                     ushort[] pwGlyphs, int cGlyphs,
                                                     int[] piAdvance, int[] piJustify, Uniscribe.GOFFSET[] pGoffset)
        {
            uint res = 0;

            try
            {
                res = 0;

                res = Uniscribe.ScriptTextOut(HDC, ref psc, /*x*/ 0, /*y*/ 0, /*fuOptions*/ 0,
                                              /*lprc*/ null, psa, /*pwcReserved*/ IntPtr.Zero, /*iReserved*/ 0,
                                              pwGlyphs, cGlyphs, piAdvance, piJustify, pGoffset);

                if (res != 0)
                {
                }
            }
            catch (System.Exception)
            {
            }

            return(res == 0);
        }
Example #2
0
        public static bool ScriptPlace(System.Drawing.Font font, Uniscribe.SCRIPT_ITEM[] items,
                                       List <ushort[]> pwGlyphs, List <int> cGlyphs, List <Uniscribe.SCRIPT_VISATTR[]> psva,
                                       out List <int[]> piAdvanceArray, out List <Uniscribe.GOFFSET[]> pGoffsetArray, out List <Uniscribe.ABC> pABCArray)
        {
            piAdvanceArray = new List <int[]>();
            pGoffsetArray  = new List <Uniscribe.GOFFSET[]>();
            pABCArray      = new List <Uniscribe.ABC>();

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

            bool res = false;

            // HFONT hfont = initialize your font;
            IntPtr hfont = font.ToHfont();

            IntPtr psc = IntPtr.Zero; // Initialize to NULL, will be filled lazily.

            // Don't use the last item because it is a dummy that points
            // to the end of the string.
            for (int i = 0; i < items.Length - 1; i++)
            {
                int[] piAdvance;
                Uniscribe.GOFFSET[] pGoffset;
                Uniscribe.ABC       pABC;

                Uniscribe.SCRIPT_ANALYSIS sa = items[i].a;
                res = callScriptPlaceForItem(ref hfont, ref psc, pwGlyphs[i], cGlyphs[i], psva[i], ref sa, out piAdvance, out pGoffset, out pABC);

                if (res)
                {
                    items[i].a = sa;

                    piAdvanceArray.Add(piAdvance);
                    pGoffsetArray.Add(pGoffset);
                    pABCArray.Add(pABC);
                }
            }

            // Need to tell Uniscribe to delete the cache we were using. If you are going
            // to keep the HFONT around, you should probably also keep the cache.
            //             ScriptFreeCache(psc);

            Win32.DeleteObject(hfont);

            return(res);
        }
Example #3
0
        public static bool ScriptBreakForItem(string input, int input_length, Uniscribe.SCRIPT_ANALYSIS psa,
                                              out Uniscribe.SCRIPT_LOGATTR[] psla)
        {
            psla = new Uniscribe.SCRIPT_LOGATTR[input_length];

            uint res = 0;

            try
            {
                res = 0;
                res = Uniscribe.ScriptBreak(input, input_length, psa, psla);

                if (res != 0)
                {
                    psla = null;
                }
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }

            return(res == 0);
        }
Example #4
0
        private static bool callScriptPlaceForItem(ref IntPtr hfont, ref IntPtr psc,
                                                   ushort[] pwGlyphs, int cGlyphs, Uniscribe.SCRIPT_VISATTR[] psva,
                                                   ref Uniscribe.SCRIPT_ANALYSIS psa,
                                                   out int[] piAdvance, out Uniscribe.GOFFSET[] pGoffset, out Uniscribe.ABC pABC)
        {
            // All arrays are in visual order unless the fLogicalOrder member is set
            // in the SCRIPT_ANALYSIS structure indicated by the psa parameter.
            psa.fLogicalOrder = true;

            piAdvance = new int[cGlyphs];
            pGoffset  = new Uniscribe.GOFFSET[cGlyphs];

            pABC = new Uniscribe.ABC();

            IntPtr hdcSrc = IntPtr.Zero;
            IntPtr HDC    = IntPtr.Zero; // Don't give it a DC unless we have to.

            // HFONT old_font = NULL;
            IntPtr old_font = IntPtr.Zero;

            uint res = 0;

            //while (true)
            for (int max = 1000; max > 0; --max)
            {
                try
                {
                    res = 0;
                    res = Uniscribe.ScriptPlace(HDC, ref psc, pwGlyphs, cGlyphs, psva, ref psa, piAdvance, pGoffset, ref pABC);

                    if (res != 0)
                    {
                        // Different types of failure...
                        if (res == Win32.E_PENDING)
                        {
                            // Need to select the font for the call. Don't do this if we don't have to
                            // since it may be slow.
                            throw new ArgumentException();
                        }
                        else
                        {
                            throw new Exception(); // Some other failure.
                        }
                    }

                    break;
                }
                catch (ArgumentException)
                {
                    // ... select font into hdc ...

                    hdcSrc = Win32.GetDC(IntPtr.Zero);
                    HDC    = Win32.CreateCompatibleDC(hdcSrc);

                    old_font = Win32.SelectObject(HDC, hfont);

                    // Loop again...
                    continue;
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                    break;
                }
            }

            if (old_font != IntPtr.Zero)
            {
                Win32.SelectObject(HDC, old_font);  // Put back the previous font.
            }
            Win32.ReleaseDC(IntPtr.Zero, HDC);
            Win32.ReleaseDC(IntPtr.Zero, hdcSrc);

            return(res == 0);
        }
Example #5
0
        // Called with the array output by callScriptItemize, this will
        private static bool callScriptShapeForItem(string input, int input_length,      // IN: characters
                                                   ref IntPtr hfont, ref IntPtr psc,    // IN: font info
                                                   Uniscribe.SCRIPT_ANALYSIS sa,        // IN: from ScriptItemize
                                                   out ushort[] pwOutGlyphs,            // OUT: one per glyph
                                                   out ushort[] pwLogClust,             // OUT: one per character
                                                   out Uniscribe.SCRIPT_VISATTR[] psva) // OUT: one per glyph
        {
            // Initial size guess for the number of glyphs recommended by Uniscribe
            int cMaxGlyphs = input_length * 3 / 2 + 16;

            pwOutGlyphs = new ushort[cMaxGlyphs];
            psva        = new Uniscribe.SCRIPT_VISATTR[cMaxGlyphs];

            // The logs array is the same size as the input.
            pwLogClust = new ushort[input_length];

            IntPtr hdcSrc = IntPtr.Zero;
            IntPtr HDC    = IntPtr.Zero; // Don't give it a DC unless we have to.

            // HFONT old_font = NULL;
            IntPtr old_font = IntPtr.Zero;

            uint res = 0;

            //while (true)
            for (int max = 1000; max > 0; --max)
            {
                try
                {
                    int pcGlyphs = 0;

                    res = 0;
                    res = Uniscribe.ScriptShape(HDC, ref psc, input, input_length, cMaxGlyphs, ref sa,
                                                pwOutGlyphs, pwLogClust, psva, ref pcGlyphs);

                    if (res != 0)
                    {
                        // Different types of failure...
                        if (res == Win32.E_PENDING)
                        {
                            // Need to select the font for the call. Don't do this if we don't have to
                            // since it may be slow.
                            throw new ArgumentException();
                        }
                        else if (res == Win32.E_OUTOFMEMORY)
                        {
                            // The glyph buffer needs to be larger. Just double it every time.
                            throw new OutOfMemoryException();
                        }
                        else if (res == Win32.USP_E_SCRIPT_NOT_IN_FONT)
                        {
                            // The font you selected doesn't have enough information to display
                            // what you want. You'll have to pick another one somehow...
                            // For our cases, we'll just return failure.
                            //throw new Exception(); // Some other failure.

                            sa.eScript = 0;
                            // Loop again...
                            continue;
                        }
                        else
                        {
                            throw new Exception(); // Some other failure.
                        }
                    }

                    // It worked, resize the output list to the exact number it returned.
                    ushort[] glyphs = new ushort[pcGlyphs];
                    Array.Copy(pwOutGlyphs, glyphs, pcGlyphs);
                    pwOutGlyphs = glyphs;

                    ushort[] logs = new ushort[pcGlyphs];
                    Array.Copy(pwLogClust, logs, pcGlyphs);
                    pwLogClust = logs;

                    Uniscribe.SCRIPT_VISATTR[] visattr = new Uniscribe.SCRIPT_VISATTR[pcGlyphs];
                    Array.Copy(psva, visattr, pcGlyphs);
                    psva = visattr;

                    break;
                }
                catch (ArgumentException)
                {
                    // ... select font into hdc ...

                    hdcSrc = Win32.GetDC(IntPtr.Zero);
                    HDC    = Win32.CreateCompatibleDC(hdcSrc);

                    old_font = Win32.SelectObject(HDC, hfont);

                    // Loop again...
                    continue;
                }
                catch (OutOfMemoryException)
                {
                    cMaxGlyphs  = pwOutGlyphs.Length * 2;
                    pwOutGlyphs = new ushort[cMaxGlyphs];
                    psva        = new Uniscribe.SCRIPT_VISATTR[cMaxGlyphs];
                    // Loop again...
                    continue;
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.Message);
                    break;
                }
            }

            if (old_font != IntPtr.Zero)
            {
                Win32.SelectObject(HDC, old_font);  // Put back the previous font.
            }
            Win32.ReleaseDC(IntPtr.Zero, HDC);
            Win32.ReleaseDC(IntPtr.Zero, hdcSrc);

            return(res == 0);
        }