דילוג לתוכן
  • דף הבית
  • קטגוריות
  • פוסטים אחרונים
  • משתמשים
  • חיפוש
  • חוקי הפורום
כיווץ
תחומים

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

💡 רוצה לזכור קריאת שמע בזמן? לחץ כאן!
pcinfogmachP

pcinfogmach

@pcinfogmach
אודות
פוסטים
778
נושאים
197
שיתופים
0
קבוצות
0
עוקבים
3
עוקב אחרי
1

פוסטים

פוסטים אחרונים הגבוה ביותר שנוי במחלוקת

  • איך לבדוק אם 'קיים חלק ממחרוזת (ברצף) בתוך מסמך. בC#
    pcinfogmachP pcinfogmach

    @dovid כתב באיך לבדוק אם 'קיים חלק ממחרוזת (ברצף) בתוך מסמך. בC#:

    @pcinfogmach כן, אתה צריך לבנות אינדקס כמו שתיארתי לך בעבר.
    ואז זה לא בעיה כי כל התאמת מילה מעלה את הציון של התוצאה, ואתה מציג את התוצאות הטובות ביותר.

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

    תכנות

  • איך לבדוק אם 'קיים חלק ממחרוזת (ברצף) בתוך מסמך. בC#
    pcinfogmachP pcinfogmach

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

    המטרה הסופית שלי היא ליצור תוכנה שתוכל ליצור דפי מקורות עבור טקסט מסויים מתוך מאגר של טקסטים בדומה למה שיש בספריא.

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

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

    תכנות

  • איך לבדוק אם 'קיים חלק ממחרוזת (ברצף) בתוך מסמך. בC#
    pcinfogmachP pcinfogmach

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

    תכנות

  • page או usercontrol בwpf
    pcinfogmachP pcinfogmach

    אני רוצה לבנות תוכנה עם חלון צד בו יהיה אפשרות להציג אפשרויות ופעולות שונות. קצת בדומה לחלונות צד שבוורד.
    מה שקורה בוורד שהחלונות צד לא נסגרים אלא מוסתרים בלבד.
    אם הייתי עושה זאת בwinforms הייתי עושה כמה userform ופועל עם הסתר הצג ו-bring to front.
    השאלה בwpf מ הדרך הכי טובה userform page או משהו אחר לגמרי. ועם איזה פקודות מומלץ להשתמש בwpf כי הצג הסתר עובד שם קצת אחרת.
    תודה מראש.

    תכנות

  • wpf קובץ xaml ארוך
    pcinfogmachP pcinfogmach

    רציתי לשאול אם מישהו יודע מה אפשר לעשות כשיש קובץ xaml מאוד ארוך
    האם יש צורה (חוץ מליצור userform) לפרק את הxaml לחתיכות יותר קטנות.
    מדובר גם בxaml עם קודים וכו' ולא רק עיצוב בעלמא.

    תכנות

  • למנוע ממשתמשים לסגור תוכנה.
    pcinfogmachP pcinfogmach

    @פלורידה כתב בלמנוע ממשתמשים לסגור תוכנה.:

    אני מחפש תוכנה / כלי, שתמנע את האפשרות של משתמשים לסגור תוכנה פעילה.
    תודה רבה. וחנוכה שמח!

    כלומר כלי שמונע מלסגור תוכנה שאה מגדיר שלא תוכל להיסגר? זה צריך להיות מובנה בתוכנה.

    תוכנה

  • רווח לא רצוי מעל ומתחת הטסקסט של כפתור wpf
    pcinfogmachP pcinfogmach

    אשמח לקבל עזרה בערכת כפתור wpf:

    בעיקרון מה שאמור לקרות בכפתורים של wpf שהטקסט צמוד לשוליים אלא א"כ הגדרתי padding.
    כמתואר כאן https://wpf-tutorial.com/el/435/basic-controls/the-button-control/

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

    מצו"ב תמונה
    3c59eca3-3efc-4ae9-9fe3-75be0b9c29dd-image.png

    מצו"ב הקוד

    <Window x:Class="WpfApp3.MainWindow"
            xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
            xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
            xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
            xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
            xmlns:local="clr-namespace:WpfApp3"
            mc:Ignorable="d"
            Title="MainWindow" Height="450" Width="800">
        <Grid Background="#F4F4F4">
            <Grid.ColumnDefinitions>
                <ColumnDefinition Width="Auto"/>
                <ColumnDefinition Width="Auto"/>
               
                <ColumnDefinition Width="*"/>
            </Grid.ColumnDefinitions>
    
            <!-- Sidebar 1 -->
            <Border Grid.Column="0" Background="#3498DB" Width="Auto" >
                <StackPanel>
                    <Button
            FontSize="36" 
            Background="{x:Null}"
            Foreground="White" 
            BorderBrush="{x:Null}" HorizontalAlignment="Center" VerticalAlignment="Center">
                    +
                    </Button>
                    <!-- Add sidebar 1 options as needed -->
                </StackPanel>
            </Border>
    
            <!-- Sidebar 2 -->
            <Border x:Name="sidePanel" Grid.Column="1" Background="#3498DB" Width="200" Visibility="Collapsed">
                <StackPanel>
                    <TextBlock Text="Sidebar 2" Foreground="White" FontSize="24" Margin="10"/>
                    <!-- Add sidebar 2 options as needed -->
                </StackPanel>
            </Border>
    
            <!-- Main Content Area with Border -->
            <Border  Grid.Column="2" Grid.Row="1" Background="White"  Margin="10">
                <Grid>
                    <Grid.RowDefinitions>
                        <RowDefinition Height="Auto"/>
                        <RowDefinition Height="*"/>
                    </Grid.RowDefinitions>
                </Grid>
            </Border>
        </Grid>
    </Window>
    
    
    תכנות

  • שאלה בwpf האם יש דרך להסיר את הצל שסביב האובייקט window
    pcinfogmachP pcinfogmach

    @pcinfogmach כתב בשאלה בwpf האם יש דרך להסיר את הצל שסביב האובייקט window:

    אבל מסתבר שאם עושים את זה אז מאבדים את היכולת לשנות את הגודל של החלון.

    עריכה: צריך לעשות כך במקום

    <WindowChrome.WindowChrome>
        <WindowChrome GlassFrameThickness="0"
                      CornerRadius="0"
                      CaptionHeight="0"/>
    </WindowChrome.WindowChrome>
    

    מצו"ב על הדרך קוד לuserform עם אפשרות דומה לחלון של הגדלה וגרירה (לא מושלם אבל עובד)

    using System.Windows;
    using System.Windows.Controls;
    using System.Windows.Input;
    
    namespace newresizableusercontrol
    {
        public partial class MainWindow : Window
        {
            private enum HitType
            {
                None, Body, UL, UR, LR, LL, L, R, B, T
            };
    
            private HitType MouseHitType = HitType.None;
            private bool DragInProgress = false;
            private Point LastPoint;
    
            public MainWindow()
            {
                InitializeComponent();
            }
    
            private HitType SetHitType(Grid grid, Point point)
            {
                double left = Canvas.GetLeft(grid);
                double top = Canvas.GetTop(grid);
                double right = left + grid.Width;
                double bottom = top + grid.Height;
                const double GAP = 10;
    
                if (point.X < left || point.X > right || point.Y < top || point.Y > bottom)
                    return HitType.None;
    
                if (point.X - left < GAP)
                {
                    if (point.Y - top < GAP) return HitType.UL;
                    if (bottom - point.Y < GAP) return HitType.LL;
                    return HitType.L;
                }
                else if (right - point.X < GAP)
                {
                    if (point.Y - top < GAP) return HitType.UR;
                    if (bottom - point.Y < GAP) return HitType.LR;
                    return HitType.R;
                }
    
                if (point.Y - top < GAP) return HitType.T;
                if (bottom - point.Y < GAP) return HitType.B;
                return HitType.Body;
            }
    
            private void SetMouseCursor()
            {
                Cursor desiredCursor = Cursors.Arrow;
    
                switch (MouseHitType)
                {
                    case HitType.None:
                        desiredCursor = Cursors.Arrow;
                        break;
                    case HitType.Body:
                        desiredCursor = Cursors.ScrollAll;
                        break;
                    case HitType.UL:
                    case HitType.LR:
                        desiredCursor = Cursors.SizeNWSE;
                        break;
                    case HitType.LL:
                    case HitType.UR:
                        desiredCursor = Cursors.SizeNESW;
                        break;
                    case HitType.T:
                    case HitType.B:
                        desiredCursor = Cursors.SizeNS;
                        break;
                    case HitType.L:
                    case HitType.R:
                        desiredCursor = Cursors.SizeWE;
                        break;
                }
    
                if (Cursor != desiredCursor) Cursor = desiredCursor;
            }
    
            private void canvas1_MouseDown(object sender, MouseButtonEventArgs e)
            {
                MouseHitType = SetHitType(rectangle1, e.GetPosition(canvas1));
                SetMouseCursor();
                if (MouseHitType == HitType.None) return;
    
                LastPoint = e.GetPosition(canvas1);
                DragInProgress = true;
            }
    
            private void canvas1_MouseMove(object sender, MouseEventArgs e)
            {
                if (DragInProgress)
                {
                    Point point = e.GetPosition(canvas1);
                    double offsetX = point.X - LastPoint.X;
                    double offsetY = point.Y - LastPoint.Y;
    
                    double newX = Canvas.GetLeft(rectangle1);
                    double newY = Canvas.GetTop(rectangle1);
                    double newWidth = rectangle1.Width;
                    double newHeight = rectangle1.Height;
    
                    switch (MouseHitType)
                    {
                        case HitType.Body:
                            newX += offsetX;
                            newY += offsetY;
                            break;
                        case HitType.UL:
                            newX += offsetX;
                            newY += offsetY;
                            newWidth -= offsetX;
                            newHeight -= offsetY;
                            break;
                        case HitType.UR:
                            newY += offsetY;
                            newWidth += offsetX;
                            newHeight -= offsetY;
                            break;
                        case HitType.LR:
                            newWidth += offsetX;
                            newHeight += offsetY;
                            break;
                        case HitType.LL:
                            newX += offsetX;
                            newWidth -= offsetX;
                            newHeight += offsetY;
                            break;
                        case HitType.L:
                            newX += offsetX;
                            newWidth -= offsetX;
                            break;
                        case HitType.R:
                            newWidth += offsetX;
                            break;
                        case HitType.B:
                            newHeight += offsetY;
                            break;
                        case HitType.T:
                            newY += offsetY;
                            newHeight -= offsetY;
                            break;
                    }
    
                    if ((newWidth > 0) && (newHeight > 0))
                    {
                        Canvas.SetLeft(rectangle1, newX);
                        Canvas.SetTop(rectangle1, newY);
                        rectangle1.Width = newWidth;
                        rectangle1.Height = newHeight;
                        LastPoint = point;
                    }
                }
                else
                {
                    MouseHitType = SetHitType(rectangle1, e.GetPosition(canvas1));
                    SetMouseCursor();
                }
            }
    
            private void canvas1_MouseUp(object sender, MouseButtonEventArgs e)
            {
                DragInProgress = false;
            }
        }
    }
    
    

    היה מעניין אבל מרגיש לי קצת בזבוז זמן. שוין.

    תכנות

  • שאלה בwpf האם יש דרך להסיר את הצל שסביב האובייקט window
    pcinfogmachP pcinfogmach

    @קומפיונט כתב בשאלה בwpf האם יש דרך להסיר את הצל שסביב האובייקט window:

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

    לא עזר בשביל הצל רק לשאר הדברים
    צריך לעשות גם AllowsTransparency = true;
    כמו ש@קומפיונט כתב
    אבל מסתבר שאם עושים את זה אז מאבדים את היכולת לשנות את הגודל של החלון.

    תכנות

  • תורת אמת בוורד - עכשיו בvsto
    pcinfogmachP pcinfogmach

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

    תוכנה

  • עזרה בקוד C# wpf
    pcinfogmachP pcinfogmach

    @dovid
    לא הסברתי את שאלתי בצורה מספיק ברורה. סליחה.
    בקוד הנ"ל הוספתי תכונה ליוזר פורם שאפשר להוזיז אותו (זה נמצא בclass של היוזרפורם).
    ועוד תכונה (בclass נפרד) שכאשר המשתמש מתחיל להזיז את היוזרפורם אז מופיעים ארבעה כפתורים באיזור של העכבר (התפקיד של הכפתורים הוא להצמיד את היוזר פורם לאחד מן הצדדים של החלון המרכזי אם המתשמש עוזב את העכבר כאשר הוא מעל אחד מהכפתורים).
    המראה של הכפתורים אמור להיות ככה:
    bd2042ed-f110-49f0-b1ba-561bdcc37e7c-image.png
    אבל זה משתבש לי בפעם הראשונה שמשתמש לוחץ על היוזר פורם
    219a2221-5b81-4b76-bb2b-1cbea67a8620-image.png
    כמו שאתה רואים הכפתורים לא מופיעים כמו שרציתי. - משום מה זה קורה רק בפעם הראשונה ואני לא מצליח להבין למה.

    תכנות

  • שאלה בwpf האם יש דרך להסיר את הצל שסביב האובייקט window
    pcinfogmachP pcinfogmach

    שאלה בwpf האם יש דרך להסיר את הצל שסביב האובייקט window

    תכנות

  • איך ליצור childform יותר יפה כאשר משתמשים בmdi
    pcinfogmachP pcinfogmach

    @dovid כתב באיך ליצור childform יותר יפה כאשר משתמשים בmdi:

    תבדוק את זה:
    https://github.com/Dirkster99/AvalonDock

    בדקתי
    הוא מושלם תודה.

    תכנות

  • עזרה בקוד C# wpf
    pcinfogmachP pcinfogmach

    עשיתי קוד שיוצר תכונת snap על ידי כפתורים דינמיים עבור usercontrol בwpf
    נתקלתי בבעיה שבפעם הרשונה שהכפתורים נטענים המיקום שלהם משובש.

    מצו:ב הקוד

    <UserControl x:Class="test_wpf_snap.UserControl3"
                 xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
                 xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
                 xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
                 xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
                 mc:Ignorable="d" 
                 MouseLeftButtonDown="UserControl_MouseLeftButtonDown"
                 MouseMove="UserControl_MouseMove"
                 MouseLeftButtonUp="UserControl_MouseLeftButtonUp"
                 BorderBrush="Black" 
                 d:DesignHeight="100" d:DesignWidth="100">
    
        <UserControl.Background>
            <SolidColorBrush Color="{DynamicResource {x:Static SystemColors.ControlColorKey}}"/>
        </UserControl.Background>
        <Grid Width="100" Height="100">
            <Grid.RowDefinitions>
                <RowDefinition Height="25"/>
                <RowDefinition Height="*"/>
            </Grid.RowDefinitions>
    
            <ToolBar Grid.Row="0">
    
            </ToolBar>
            <DockPanel >
                <DockPanel.Background>
                    <SolidColorBrush Color="{DynamicResource {x:Static SystemColors.WindowColorKey}}"/>
                </DockPanel.Background>
    
                <Button Style="{StaticResource {x:Static ToolBar.ButtonStyleKey}}"
          Content="X" Width="25"  DockPanel.Dock="Right" HorizontalAlignment="Right"/>
    
            </DockPanel>
        </Grid>
    </UserControl>
    
    using System;
    using System.Collections.Generic;
    using System.Text;
    using System.Windows;
    using System.Windows.Controls;
    using System.Windows.Data;
    using System.Windows.Documents;
    using System.Windows.Input;
    
    
    namespace test_wpf_snap
    {
        /// <summary>
        /// Interaction logic for UserControl3.xaml
        /// </summary>
        public partial class UserControl3 : UserControl
        {
            private bool inDrag = false;
            private Point anchorPoint;
            private bool showSnapButtons = false;
            SnapButtons snapButtons;
    
            public UserControl3()
            {
                InitializeComponent();
                snapButtons = new SnapButtons(this);
            }
    
            private void UserControl_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
            {
                if (!inDrag)
                {
                    anchorPoint = e.GetPosition(null);
                    CaptureMouse();
                    inDrag = true;
    
                    snapButtons.ShowSnapButtons();
    
                    e.Handled = true;
                }
            }
    
            private void UserControl_MouseMove(object sender, MouseEventArgs e)
            {           
                if (inDrag)
                {
                    Point currentPoint = e.GetPosition(null);
    
                    // Move the UserControl
                    Canvas.SetLeft(this, Canvas.GetLeft(this) + (currentPoint.X - anchorPoint.X));
                    Canvas.SetTop(this, Canvas.GetTop(this) + (currentPoint.Y - anchorPoint.Y));
                    anchorPoint = currentPoint;
    
                    snapButtons.HighlightSnapButtonIfMouseOver(snapButtons.snapTopButton, e);
                    snapButtons.HighlightSnapButtonIfMouseOver(snapButtons.snapBottomButton, e);
                    snapButtons.HighlightSnapButtonIfMouseOver(snapButtons.snapLeftButton, e);
                    snapButtons.HighlightSnapButtonIfMouseOver(snapButtons.snapRightButton, e);
                }
    
                e.Handled = true;
            }
    
            private void UserControl_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
            {
                if (inDrag)
                {
                    ReleaseMouseCapture();
                    inDrag = false;
    
                    snapButtons.HideSnapButtons();
                    e.Handled = true;
                }
            }
        }
    }
    
    
    using System;
    using System.Windows;
    using System.Windows.Controls;
    using System.Windows.Input;
    using System.Windows.Media;
    using System.Windows.Threading;
    
    namespace test_wpf_snap
    {
        public class SnapButtons
        {
            public Button snapTopButton;
            public Button snapBottomButton;
            public Button snapLeftButton;
            public Button snapRightButton;
            private UserControl snapControl;
            private bool showSnapButtons;
    
            public SnapButtons(UserControl control)
            {
                InitializeSnapButtons();
                snapControl = control;
            }
    
            private void InitializeSnapButtons()
            {
                snapTopButton = CreateSnapButton("Snap\r\nTop", "SnapToTop");
                snapBottomButton = CreateSnapButton("Snap\r\nBottom", "SnapToBottom");
                snapLeftButton = CreateSnapButton("Snap\r\nLeft", "SnapToLeft");
                snapRightButton = CreateSnapButton("Snap\r\nRight", "SnapToRight");
    
                HideSnapButtons();
            }
    
            private Button CreateSnapButton(string buttonText, string tag)
            {
                var button = new Button { Content = CreateCenteredTextBlock(buttonText), Tag = tag };
                SetButtonStyle(button);
                return button;
            }
    
            private TextBlock CreateCenteredTextBlock(string text)
            {
                var textBlock = new TextBlock
                {
                    FontSize = 9,
                    Text = text,
                    TextAlignment = TextAlignment.Center,
                    VerticalAlignment = VerticalAlignment.Center,
                    HorizontalAlignment = HorizontalAlignment.Stretch
                };
    
                return textBlock;
            }
    
            private void SetButtonStyle(Button button)
            {
                button.Background = Brushes.Transparent;
                button.Foreground = Brushes.Black;
    
                button.Width = 30;
                button.Height = 30;
    
                button.MouseEnter += (sender, e) => SnapToPosition((Button)sender);
            }
    
            private void SnapToPosition(Button button)
            {
                double targetLeft = Canvas.GetLeft(snapControl);
                double targetTop = Canvas.GetTop(snapControl);
    
                switch (button.Tag.ToString())
                {
                    case "SnapToTop":
                        targetTop = 0;
                        break;
                    case "SnapToBottom":
                        targetTop = ((Canvas)snapControl.Parent).ActualHeight - snapControl.ActualHeight;
                        break;
                    case "SnapToLeft":
                        targetLeft = 0;
                        break;
                    case "SnapToRight":
                        targetLeft = ((Canvas)snapControl.Parent).ActualWidth - snapControl.ActualWidth;
                        break;
                }
    
                Canvas.SetLeft(snapControl, targetLeft);
                Canvas.SetTop(snapControl, targetTop);
            }
    
            public void HighlightSnapButtonIfMouseOver(Button button, MouseEventArgs e)
            {
                Point mousePosition = e.GetPosition(button);
    
                if (mousePosition.X >= 0 && mousePosition.X <= button.ActualWidth &&
                    mousePosition.Y >= 0 && mousePosition.Y <= button.ActualHeight)
                {
                    // Use system default highlight color
                    button.Background = SystemColors.ActiveCaptionBrush;
                }
                else
                {
                    // Remove highlighting if the mouse is not over the button
                    button.Background = Brushes.Transparent;
                }
            }
    
            public void ShowSnapButtons()
            {
                if (showSnapButtons)
                    return;
    
                Canvas canvas = snapControl.Parent as Canvas;
                if (canvas == null)
                    return;
    
                double centerX = Canvas.GetLeft(snapControl) + snapControl.ActualWidth / 2;
                double centerY = Canvas.GetTop(snapControl) + snapControl.ActualHeight / 2;
    
                double buttonSeparation = 10;
    
                // Set the position of the imaginary center button
                SetSnapButtonPosition(snapBottomButton, centerX, centerY);
    
                // Adjust other buttons relative to the imaginary center button
                SetSnapButtonPosition(snapTopButton, centerX, centerY - snapTopButton.ActualHeight - buttonSeparation);
                SetSnapButtonPosition(snapLeftButton, centerX - snapLeftButton.ActualWidth - buttonSeparation, centerY);
                SetSnapButtonPosition(snapRightButton, centerX + snapBottomButton.ActualWidth + buttonSeparation, centerY);
    
                // Apply styles and add buttons to the canvas
                foreach (Button button in new[] { snapTopButton, snapBottomButton, snapLeftButton, snapRightButton })
                {
                    canvas.Children.Add(button);
                }
    
                showSnapButtons = true;
            }
    
            private void SetSnapButtonPosition(Button button, double left, double top)
            {
                Canvas.SetLeft(button, left - button.ActualWidth / 2);
                Canvas.SetTop(button, top - button.ActualHeight / 2);
            }
    
            public void HideSnapButtons()
            {
                if (showSnapButtons)
                {
                    // Remove snap buttons from the Canvas
                    Canvas canvas = snapControl.Parent as Canvas;
                    canvas?.Children.Remove(snapTopButton);
                    canvas?.Children.Remove(snapBottomButton);
                    canvas?.Children.Remove(snapLeftButton);
                    canvas?.Children.Remove(snapRightButton);
    
                    showSnapButtons = false;
                }
            }
        }
    }
    
    
    תכנות

  • האם יש צורה לסדר קבצים בסייר של חלונות בלי למספר אותם?
    pcinfogmachP pcinfogmach

    האם יש צורה לסדר קבצים בסייק של חלונות בלי למספר אותם
    לדוגמא אם יש לי את הקבצים
    בראשית
    שמות
    ויקרא
    במדבר
    דברים

    גומלין - כללי

  • מה ההבדל בין שני סוגי הפרויקטים הללו בויז'ואל סטודיו?
    pcinfogmachP pcinfogmach

    @קומפיונט כתב במה ההבדל בין שני סוגי הפרויקטים הללו בויז'ואל סטודיו?:

    אפשר לשאול הפוך: מה היתרון לפתח ב net framework?

    ב net framework בעיקרון בגלל שהוא יותר ותיק יש פקדים שאין ב.net core.

    הכל תלוי בצרכים. כדאי לבדוק מראש שיש את הפקדים שאתה צריך.

    תכנות

  • יצירת קובץ exe יחיד לאחר הקימפול בויזו'אל סטודיו
    pcinfogmachP pcinfogmach

    @מוטי-מן
    תבדוק בnuget את Costura.Fody בעבר השתמשתי איתו כעת לא בדקתי מספיק. אבל הוא אמור ליצור תוכנה ניידת.
    אחרי ההתקנה שלו יש ללחוץ על build ואז אתה מקבל exe מוכן להפצה בתיקיית הbin > debug
    שים לב שהוא עלול לדפוק את האפשרות של debug מתוך vs
    שים לב - אנטי וירוסים לא כל כך אוהבים תוכנות מסוג כזה

    תכנות

  • תורת אמת בוורד - עכשיו בvsto
    pcinfogmachP pcinfogmach

    @פלורידה

    2
    3
    תוקן

    1
    בבדיקה

    תודה

    תוכנה

  • בעיה עם הפקד webview בC# winforms
    pcinfogmachP pcinfogmach

    נתקלתי בבעיה עם הפקד wbeview2 כאשר יש כמה controls אז הוא לא מצליח להיטען. אשמח לכל עזרה
    בפרוייקט שלי יש
    חלון ראשי
    בחלון הראשי יש
    splitcontainer
    ו- toolstrip
    בתוך panel2 אני מעלה userform עם webview2 וזה לא עולה

    תכנות

  • שאלה בVsto בC# איך אפשר להוסיף תמיכה לתוסף שלי עבור דארק מוד
    pcinfogmachP pcinfogmach

    שאלה בVsto בC# איך אפשר להוסיף תמיכה לתוסף שלי עבור דארק מוד

    ככה אמור להיראות

    https://tchumim.com/assets/uploads/files/1700939066142-c195b348-15d4-4c4b-9169-6ea38a38fafc-86d02530-38cc-414b-ae1f-6ad53e4667a8-image.png

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

    https://tchumim.com/assets/uploads/files/1700940365410-47b5af8c-b452-4c89-9aad-3255e8a3bab0-תמונה.png

    תכנות
  • 1
  • 2
  • 28
  • 29
  • 30
  • 31
  • 32
  • 38
  • 39
  • 30 / 39
  • התחברות

  • אין לך חשבון עדיין? הרשמה

  • התחברו או הירשמו כדי לחפש.
  • פוסט ראשון
    פוסט אחרון
0
  • דף הבית
  • קטגוריות
  • פוסטים אחרונים
  • משתמשים
  • חיפוש
  • חוקי הפורום