תחומים - פורום חרדי מקצועי

pcinfogmach

@אף-אחד-3
כל מילה בסלע!
רק רציתי להוסיף שהרבה פעמים נתקע שעות וכיו"ב שם בפנים ואם כבר עושים גירוז אז להסיר כמובן את כל הליכלוכים

pcinfogmach

DiffPlex השוואת טקסטים.zip

Diffplex השוואת טקסטים - נייד.zip

או בגיט

https://github.com/pcinfogmach/DiffPlex-/releases/tag/DiffplexSpinOff

pcinfogmach

@dovid
אה
הייתרון לעניין הסדר הוא העובדה שאני מפריד את המתודות של ה-פעולות משאר המתודות שלא נוגעות לפעולות אלא ל-view
כאשר יש מאות לחצנים זה מאוד משמעותי

pcinfogmach

אני מנסה ליצור מאגר של קודים שימושיים ל-VSTO (Visual Studio Tools for Office). הבעיה היא שאני צריך להתייחס ל-Globals של התוסף, וזה ספציפי ל-namespace שלו. המשמעות היא שאם אני אשתף את המאגר עם מישהו אחר, הוא ייתקל באלף שגיאות ויצטרך להחליף את כל ההתייחסויות ל-Globals בכל הקוד.

האם יש דרך לזהות את ה-Globals בצורה דינמית בהתאם לאפליקציה, כך שזה לא משנה באיזה namespace הם נמצאים?

pcinfogmach

@dovid
תודה על המשוב. אתה צודק כמובן, זה לא נעשה כמו שצריך.
למעישה אני מחפש סדר בקוד
אשמח לשמוע רעיונות.

pcinfogmach

לאחרונה יצא לי לעבוד על פרויקט עם הרבה לחצנים בסרגל הכלים של וורד. אמרתי לעצמי שזה לא שפוי ואני חייב לעשות סדר בבלאגן באמצעות חלוקה למשהו כמו-MVVM (Model-View-ViewModel).

מכיון שה-ribbon xml לא באמת נותן גישה לאוסף של הפקדים חשבתי על הרעיון הבא:

הרעיון הוא לקרוא לכל מתודה על ידי ID של הלחצן באותו שם, ולהעביר את הלוגיקה הקשורה ללחיצה על הלחצן לתוך class נפרד ומסודר, מה שיעשה את הקוד יותר נקי וניתן לניהול.

(עוד לא יישמתי את הרעיון לגבי אייקונים אבל שם זה אמור להיות ממש עוצמתי מאחר ובצורה הזו כל מה שהמשתמש יצטרך לעשות זה להוסיף אייקון לפרוייקט ולקרוא לו בשם של הכפתור).

להלן דוגמאות עבור button1 ו-button2.

בתוך ה-callbacks יש להוסיף את הקודים הבאים:

private ButtonInvoker buttonInvoker;

public Ribbon()
{
    buttonInvoker = new ButtonInvoker();
}


public void button_Click(Office.IRibbonControl control)
{
    buttonInvoker.InvokeButtonMethod(control.Id);
}

במקום ליצור מתודה ייחודית לכל כפתור ב-XML, כל כפתור יקרא לאותה מתודה. הנה דוגמה ל-XML:

xml

<?xml version="1.0" encoding="UTF-8"?>
<customUI onLoad="Ribbon_Load" xmlns="http://schemas.microsoft.com/office/2006/01/customui">
    <ribbon>
        <tabs>
            <tab id="tab1" label="Label">
                <group id="MyCustomGroup" label="My Custom Group">
                    <button id="button1" label="Button 1" onAction="button_Click"/>
                    <button id="button2" label="Button 2" onAction="button_Click"/>
                </group>
            </tab>
        </tabs>
    </ribbon>
</customUI>

כעת, נוסיף את מחלקת ה-ButtonInvoker שתטפל בלחצנים:

public class ButtonInvoker
{
    public void InvokeButtonMethod(string methodName)
    {
        try
        {
            MethodInfo method = this.GetType().GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Instance);
            if (method != null)
            {
                method.Invoke(this, null);
            }
            else
            {
                MessageBox.Show($"No method found for button ID: {methodName}");
            }
        }
        catch (Exception ex)
        {
            MessageBox.Show($"Error invoking method for button ID: {methodName}. Error: {ex.Message}");
        }
    }

    private void button1()
    {
        MessageBox.Show("Button 1 clicked");
    }

    private void button2()
    {
        MessageBox.Show("Button 2 clicked");
    }
}

בעזרת הקוד הזה, הצלחנו לפשט את ניהול הלחצנים בסרגל הכלים של וורד ולהקטין את הבלאגן. כל לחצן מזוהה לפי ה-ID שלו וקורא לאותה מתודה כללית שמפעילה את המתודה המתאימה בהתאם ל-ID.

pcinfogmach

@dovid כתב בקוד להצגת שינויים בין טקסטים ב-C# (השוואת טקסטים):

בינתיים ריק...

עודכן
תודה!

pcinfogmach

@קומפיונט
תודה רבה!
עזרת לי מאוד!

pcinfogmach

**DiffPlex השוואת טקסטים.exe **

למי שמעוניין בניתי את הפקד של DiffPlex בתוך חלון בצורה מסודרת (בעברית כמובן).
עובד מעולה החיסרון היחיד שלו הוא העובדה שאין לו אפשרות לעשות wrap עבור הטקסט המוזן.

https://github.com/mmanela/diffplex/issues/113

שימו לב! מכיון שמדובר בתוכנה ניידת האנטי וירוס עלול למחוק אותו (תלוי איזה אנטי וירוס יש לכם).

למי שרוצה את הקודים שמתי בגיטהאב
https://github.com/pcinfogmach/DiffPlex-

pcinfogmach

@shraga
לפי מה שכתוב שם המתקין החדש אמור לטפל בזה באופן אוטומטי
למעישה התקנתי שוב ולא עזר
לפנות לנטפרי?

pcinfogmach

@צדיק-תמים
על פניו זה נראה שהוא רק משווה מסמכים, לא טקסטים מוזנים?

pcinfogmach

אני מנסה לעזור למישהו עם הפקוייקט שלו בגיט האב הוא שיתף אותי בפרוייקט
אבל כל פעם שאני מנסה לעשות cloning אני נתקל בשגיאה דלהלן

pcinfogmach

@צדיק-תמים
תודה
ראיתי את זה נראה ממש יפה
אבל זה לא בעברית

pcinfogmach

@dovid כתב בקוד להצגת שינויים בין טקסטים ב-C# (השוואת טקסטים):

יש מאות כאלו... תחפש text compare tool.

שכחתי לציין אני מחפש משהו בעברית שאינו דורש חיבור לאינטרנט (עבור אברכים)

pcinfogmach

@dovid כתב בקוד להצגת שינויים בין טקסטים ב-C# (השוואת טקסטים):

הקוד שלך עובד לך טוב?

בדיקות בסיסיות עבר לא היה לי פנאי לבדוק אותו לעומק

pcinfogmach

אני יודע שיש כבר דברים מוכנים כגון אלו:
https://github.com/mmanela/diffplex/
http://git.savannah.gnu.org/cgit/diffutils.git/tree/src/analyze.c?id=fecd0079fe6e15b0f53bf953721d838d9099bf05

אבל לשם ההתלמדות חשבתי לעשות אולי משהו כזה בעצמי
הייתי שמח לקבל משוב (ההשואה יוצרת טקסט html שמסמן את השינויים)

אגב אם מישהו מכיר תוכנה כבר מוכנה (לא אתר) אשמח לשמוע עליה

להלן הקוד שלי

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace TextComparer
{
    public static class TextCompare
    {
        public static void Compare(ref string text1, ref string text2)
        {
            text1 = $"<span style=\"background-color: lightblue;\">{text1}</span>";
            text2 = $"<span style=\"background-color: lightblue;\">{text2}</span>";
            // Get the LSS lss
            string lssString = "placeholdertext";
            List<string> lssList = new List<string>();
            string copyOfText1 = text1;
            string copyOfText2 = text2;
            while (!string.IsNullOrEmpty(lssString))
            {
                try
                {
                    lssString = FindLongestSimilarSubstring(copyOfText1.ToCharArray(), copyOfText2.ToCharArray());
                    if (lssString.Length > 1) { lssList.Add(lssString); }
                    copyOfText2 = copyOfText2.Replace(lssString, "");
                    copyOfText1 = copyOfText1.Replace(lssString, "");
                }
                catch { break; }
            }

            foreach (var item in lssList)
            {
                text1.Replace(item, $"<span style=\"background-color: white;\"{item}");
                text2.Replace(item, $"<span style=\"background-color: white;\"{item}");
            }
        }

        static string FindLongestSimilarSubstring(char[] arr1, char[] arr2)
        {
            // Initialize variables to keep track of the longest common substring
            int[,] table = new int[arr1.Length + 1, arr2.Length + 1];
            int maxLength = 0;
            int endIndex = 0;

            // Fill the table
            for (int i = 1; i <= arr1.Length; i++)
            {
                for (int j = 1; j <= arr2.Length; j++)
                {
                    if (arr1[i - 1] == arr2[j - 1])
                    {
                        table[i, j] = table[i - 1, j - 1] + 1;
                        if (table[i, j] > maxLength)
                        {
                            maxLength = table[i, j];
                            endIndex = i - 1;
                        }
                    }
                    else
                    {
                        table[i, j] = 0;
                    }
                }
            }

            // Extract the longest common substring
            if (maxLength == 0)
            {
                return ""; // No common substring found
            }
            else
            {
                return new string(arr1, endIndex - maxLength + 1, maxLength);
            }
        }

    }
}

עריכה:
לבינתיים גילית שהרעיון הנ"ל מוגבל ביותר מאחר והוא לא יכול לגלות שינויים בסדר של הקבצים מה שצריך לעשות הוא להשתמש עם lcs כמתואר כאן
https://en.wikipedia.org/wiki/Diff
מהשלא הצלחתי להבין הוא איך פותרים על ידי זה את הבעיה של מילים ששונה מיקומם. כי אפילו עם lcs עדיין אם יש אות זהה במיקום בו היתה המילה בראשונה אזי התוכנה תחשוב שהיא אותה האות למרות שבאמת היא שייכת למילה שהוזזה.
בכל אופן מצו"ב הקוד הנוכחי שלי ל-lcs

 static List<string> Compare(string text1, string text2)
 {
     // Find the longest common subsequence
     List<string> commonSubsequence = LongestCommonSubsequence(text1, text2);

     // Generate diff output based on the longest common subsequence
     List<string> diffOutput = GenerateDiffOutput(text1, text2, commonSubsequence);

     return diffOutput;
 }

 private static List<string> LongestCommonSubsequence(string text1, string text2)
 {
     int m = text1.Length;
     int n = text2.Length;

     int[,] dp = new int[m + 1, n + 1];

     // Build DP table
     for (int i = 0; i <= m; i++)
     {
         for (int j = 0; j <= n; j++)
         {
             if (i == 0 || j == 0)
                 dp[i, j] = 0;
             else if (text1[i - 1] == text2[j - 1])
                 dp[i, j] = dp[i - 1, j - 1] + 1;
             else
                 dp[i, j] = Math.Max(dp[i - 1, j], dp[i, j - 1]);
         }
     }

     // Reconstruct the longest common subsequence
     List<string> commonSubsequence = new List<string>();
     int index = dp[m, n];
     int temp = index;

     char[] lcs = new char[index + 1];
     lcs[index] = '\0';

     int p = m, q = n;
     while (p > 0 && q > 0)
     {
         if (text1[p - 1] == text2[q - 1])
         {
             lcs[index - 1] = text1[p - 1];
             p--;
             q--;
             index--;
         }
         else if (dp[p - 1, q] > dp[p, q - 1])
             p--;
         else
             q--;
     }

     // Convert char array to List of strings
     foreach (char c in lcs)
     {
         if (c != '\0')
             commonSubsequence.Add(c.ToString());
     }

     return commonSubsequence;
 }

 private static List<string> GenerateDiffOutput(string text1, string text2, List<string> commonSubsequence)
 {
     List<string> diffOutput = new List<string>();

     int index1 = 0, index2 = 0;
     foreach (string s in commonSubsequence)
     {
         while (index1 < text1.Length && text1[index1].ToString() != s)
         {
             diffOutput.Add($"<span style=\"background-color: rgb(255, 204, 204);\">{text1[index1]}</span>");
             index1++;
         }

         while (index2 < text2.Length && text2[index2].ToString() != s)
         {
             diffOutput.Add($"<span style=\"background-color: lightblue;\">{text2[index2]}</span>");
             index2++;
         }

         diffOutput.Add($"{s}");
         index1++;
         index2++;
     }

     // Handle remaining parts of text1 and text2
     for (int i = index1; i < text1.Length; i++)
     {
         diffOutput.Add($"<span style=\"background-color: rgb(255, 204, 204);\">{text1[i]}</span>");
     }

     for (int i = index2; i < text2.Length; i++)
     {
         diffOutput.Add($"<span style=\"background-color: lightblue;\">{text2[i]}</span>");
     }

     return diffOutput;
 }

pcinfogmach

@dovid

כל כך התרגלתי שאין לי את הפקדים שאני צריך ששחכתי לבדוק אם במקרה הזה יש אותו כבר מובנה.

אל דאגה זה לא לקח לי הרבה זמן לעשות קצת העתק הדבק וזהו
הנטייה שלי למחוק את הפוסט למנוע את הפדיחות
אבל אז אמרתי שיישאר ואולי מישהו אחר ייקח לקח לבדוק לפני.....

pcinfogmach

רציתי מכמה טעמים לקרוא לcolorpicker של חלונות מתוך C#
מצו"ב הקוד שגיבבתי מפה ומשם:
עריכה: מסתבר שסתם בזבזתי זמן ומתוך רשלנות שחכתי לבדוק אם דבר כזה כבר קיים ראה להלן בהמשך השרשור

using System;
using System.Collections.Generic;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;

namespace SystemColorPicker
{
    public class ColorPicker
    {
        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
        public struct CHOOSECOLOR
        {
            public int lStructSize;
            public IntPtr hwndOwner;
            public IntPtr hInstance;
            public uint rgbResult;
            public IntPtr lpCustColors;
            public uint flags;
            public IntPtr lCustData;
            public IntPtr lpfnHook;
            [MarshalAs(UnmanagedType.LPTStr)]
            public string lpTemplateName;
        }

        [DllImport("comdlg32.dll", CharSet = CharSet.Auto)]
        [return: MarshalAs(UnmanagedType.Bool)]
        public static extern bool ChooseColor(ref CHOOSECOLOR lpcc);

        public static bool GetColor(ref uint col)
        {
            CHOOSECOLOR CS = new CHOOSECOLOR();
            int structSize = Marshal.SizeOf(CS);
            CS.lStructSize = structSize;
            CS.hwndOwner = IntPtr.Zero;
            CS.flags = 0x1 | 0x2;
            CS.lpCustColors = Marshal.AllocCoTaskMem(Marshal.SizeOf(typeof(uint)) * 16);
            CS.rgbResult = col;
            CS.hInstance = IntPtr.Zero;

            bool result = ChooseColor(ref CS);
            if (!result)
                return false;

            col = CS.rgbResult;

            Marshal.FreeCoTaskMem(CS.lpCustColors);
            return true;
        }
    }
}

וצורת השימוש בו היא

 uint color = 0;
 ColorPicker.GetColor(ref color);

האמת היא שאני מבין רק חלק מהקוד אשמח לקבל הצעות לשיפור ממי שבאמת מבין מה הולך פה

pcinfogmach

מצאתי קוד חמוד כיצד להמיר צבע על ידי RGB שלו ל- int בודד אני כותב אותו פה למקרה שמישהו יצטרך ג"כ יום אחד
הצורך שלי היה כדי לעשת colorpicker פשוט בשביל תוסף לוורד. בוורד צבע costume מוגדר באופן זה - על ידי int בודד.

Color c = Colors.Blue;
var wdc = (Microsoft.Office.Interop.Word.WdColor)(c.R + 0x100 * c.G + 0x10000 * c.B);

מקור
https://stackoverflow.com/a/13075575

תחומים - פורום חרדי מקצועי

pcinfogmach

פוסטים