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

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

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

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

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

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

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

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

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

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

מצו"ב תמונה

מצו"ב הקוד

<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>

@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:

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

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

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

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

אבל זה משתבש לי בפעם הראשונה שמשתמש לוחץ על היוזר פורם

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

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

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

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

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

עשיתי קוד שיוצר תכונת 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;
            }
        }
    }
}

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

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

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

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

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

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

@פלורידה

2
3
תוקן

1
בבדיקה

תודה

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

שאלה ב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

תוסף חדש לוורד - תורת אמת בוורד
המאגר התורני החינמי בתוך וורד
להורדת התוסף לחץ כאן
לפני החילוץ של הקובץ לחץ לחיצה ימנית על הקובץ והסר חסימה אינטרנטית
באפשרויות הקובץ

כדי להשתמש בתוסף יש להתקין את תורת אמת במחשב. להריץ את התוכנה כמנהל מערכת לכה"פ פעם אחת.

תודה מיוחדת ל:
@האדם-החושב
@dovid
שעזרו רבות בבניית התוסף.

הערה: קיצור מקשים Cntrl + T אמור להעביר את הפוקוס חזרה למסמך הפתוח (לא תמיד עובד תלוי אם הפוקוס באמת נמצא בתוך התוסף או לא).

שיחקתי עם זה קצת והוספתי לו תכונות snap פשוטות (לקצוות של הparentform ולקצוות של אחד לשני)

static class MyDictionary
{
    public static List<SizeableUserControl> userControlCollection = new List<SizeableUserControl>();
}

class SizeableUserControl : UserControl
{
    Form parentForm;
    private const int grab = 16;
    public SizeableUserControl(Form form)
    {
        parentForm = form;
        MyDictionary.userControlCollection.Add(this);
        this.ResizeRedraw = true;
        InitializeComponent();
    }

    private void InitializeComponent()
    {
        this.SuspendLayout();
        this.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
        this.Name = "SizeableUserControl";
        this.Size = new System.Drawing.Size(100, 100);
        
        Panel titleBar = new Panel();
        titleBar.Dock = DockStyle.Top;
        titleBar.BackColor = Color.White;

        titleBar.Height = 20;
        Controls.Add(titleBar);
        titleBar.MouseDown += TitleBar_MouseDown;
        titleBar.MouseMove += TitleBar_MouseMove;
        titleBar.MouseUp += TitleBar_MouseUp;

        // Minimize button
        Button minimizeButton = new Button();
        minimizeButton.Text = "─";
        minimizeButton.TextAlign = ContentAlignment.MiddleCenter;
        minimizeButton.Width = 20;
        minimizeButton.Height = 20;
        minimizeButton.Dock = DockStyle.Right;
        minimizeButton.FlatStyle = FlatStyle.Flat;
        minimizeButton.FlatAppearance.BorderSize = 0;
        titleBar.Controls.Add(minimizeButton);

        minimizeButton.Click += (sender, e) =>
        {
            if (minimizeButton.Text == "─")
            { 
            minimizeButton.Text = "＋";
            this.Height = 20;
            this.Width = 60;
            }
            else
            {
                minimizeButton.Text = "─";
                this.Height = 100;
                this.Width = 100;
            }
        };

        // Maximize button
        Button maximizeButton = new Button();
        maximizeButton.Text = "⬜"; // Larger square Unicode character
        maximizeButton.TextAlign = ContentAlignment.MiddleCenter;
        maximizeButton.Width = 20;
        maximizeButton.Height = 20;
        maximizeButton.Dock = DockStyle.Right;
        maximizeButton.FlatStyle = FlatStyle.Flat;
        maximizeButton.FlatAppearance.BorderSize = 0;

        // Store the original DockStyle
        DockStyle originalDockStyle = DockStyle.None;

        maximizeButton.Click += (sender, e) =>
        {
            if (this.Dock == DockStyle.None)
            {
                // Maximize the form
                originalDockStyle = this.Dock;
                this.Dock = DockStyle.Fill;
                maximizeButton.Text = "❐"; // Change text to indicate restore
            }
            else
            {
                // Restore the original DockStyle
                this.Dock = originalDockStyle;
                maximizeButton.Text = "⬜"; // Change text to indicate maximize
            }
        };

        titleBar.Controls.Add(maximizeButton);


        // X button
        Button xButton = new Button();
        xButton.Text = "X";
        xButton.Dock = DockStyle.Right;
        xButton.Width = 20;
        xButton.Height = 20;
        xButton.FlatStyle = FlatStyle.Flat;
        xButton.FlatAppearance.BorderSize = 0;
        xButton.Click += (sender, e) => this.Dispose();
        titleBar.Controls.Add(xButton);

        this.ResumeLayout(false);
    }

    protected override void WndProc(ref Message m)
    {
        base.WndProc(ref m);
        const int WM_NCHITTEST = 0x84;
        const int HT_LEFT = 10;
        const int HT_RIGHT = 11;
        const int HT_TOP = 12;
        const int HT_TOPLEFT = 13;
        const int HT_TOPRIGHT = 14;
        const int HT_BOTTOM = 15;
        const int HT_BOTTOMLEFT = 16;
        const int HT_BOTTOMRIGHT = 17;

        if (m.Msg == WM_NCHITTEST)
        {
            var pos = this.PointToClient(new Point(m.LParam.ToInt32()));

            if (pos.X <= grab && pos.Y <= grab)
                m.Result = new IntPtr(HT_TOPLEFT);
            else if (pos.X >= this.ClientSize.Width - grab && pos.Y <= grab)
                m.Result = new IntPtr(HT_TOPRIGHT);
            else if (pos.X <= grab && pos.Y >= this.ClientSize.Height - grab)
                m.Result = new IntPtr(HT_BOTTOMLEFT);
            else if (pos.X >= this.ClientSize.Width - grab && pos.Y >= this.ClientSize.Height - grab)
                m.Result = new IntPtr(HT_BOTTOMRIGHT);
            else if (pos.X <= grab)
                m.Result = new IntPtr(HT_LEFT);
            else if (pos.X >= this.ClientSize.Width - grab)
                m.Result = new IntPtr(HT_RIGHT);
            else if (pos.Y <= grab)
                m.Result = new IntPtr(HT_TOP);
            else if (pos.Y >= this.ClientSize.Height - grab)
                m.Result = new IntPtr(HT_BOTTOM);
        }
    }



    bool isMouseDown = false;
    private Point mouseDownLocation;

    private void TitleBar_MouseUp(object sender, MouseEventArgs e)
    {
        isMouseDown = false;
    }

    private void TitleBar_MouseMove(object sender, MouseEventArgs e)
    {
        if (isMouseDown)
        {
            // Check proximity on all sides (adjust the threshold as needed)
            int proximityThreshold = 10;

            // Calculate the new position of the control based on the mouse movement
            int newX = this.Left - mouseDownLocation.X + e.X;
            int newY = this.Top - mouseDownLocation.Y + e.Y;

            // Ensure the new position is within the boundaries of the parent form
            newX = Math.Max(0, Math.Min(newX, parentForm.ClientSize.Width - this.Width));
            newY = Math.Max(0, Math.Min(newY, parentForm.ClientSize.Height - this.Height));

            // Iterate through other controls and check if snapping is possible
            foreach (var kvp in MyDictionary.userControlCollection)
            {
                if (kvp != this)
                {
                    // Check top side
                    if (Math.Abs(newY - kvp.Bottom) < proximityThreshold)
                    {
                        newY = kvp.Bottom + 1;

                        // Align right and left if they are close enough
                        if (Math.Abs(newX - kvp.Left) < proximityThreshold)
                        {
                            newX = kvp.Left;
                        }
                        else if (Math.Abs(newX + this.Width - kvp.Right) < proximityThreshold)
                        {
                            newX = kvp.Right - this.Width;
                        }
                    }

                    // Check bottom side
                    else if (Math.Abs(newY + this.Height - kvp.Top) < proximityThreshold)
                    {
                        newY = kvp.Top - this.Height - 1;

                        // Align right and left if they are close enough
                        if (Math.Abs(newX - kvp.Left) < proximityThreshold)
                        {
                            newX = kvp.Left;
                        }
                        else if (Math.Abs(newX + this.Width - kvp.Right) < proximityThreshold)
                        {
                            newX = kvp.Right - this.Width;
                        }
                    }

                    // Check left side
                    if (Math.Abs(newX - kvp.Right) < proximityThreshold)
                    {
                        newX = kvp.Right + 1;

                        // Align tops if they are close enough
                        if (Math.Abs(newY - kvp.Top) < proximityThreshold)
                        {
                            newY = kvp.Top;
                        }
                        // Align bottoms if they are close enough
                        else if (Math.Abs(newY + this.Height - kvp.Bottom) < proximityThreshold)
                        {
                            newY = kvp.Bottom - this.Height;
                        }
                    }

                    // Check right side
                    else if (Math.Abs(newX + this.Width - kvp.Left) < proximityThreshold)
                    {
                        newX = kvp.Left - this.Width - 1;

                        // Align tops if they are close enough
                        if (Math.Abs(newY - kvp.Top) < proximityThreshold)
                        {
                            newY = kvp.Top;
                        }
                        // Align bottoms if they are close enough
                        else if (Math.Abs(newY + this.Height - kvp.Bottom) < proximityThreshold)
                        {
                            newY = kvp.Bottom - this.Height;
                        }
                    }
                }
            }

            // Snap to parent form edges
            if (Math.Abs(newX) < proximityThreshold)
            {
                newX = 0;
            }
            else if (Math.Abs(newX + this.Width - parentForm.ClientSize.Width) < proximityThreshold)
            {
                newX = parentForm.ClientSize.Width - this.Width;
            }

            if (Math.Abs(newY) < proximityThreshold)
            {
                newY = 0;
            }
            else if (Math.Abs(newY + this.Height - parentForm.ClientSize.Height) < proximityThreshold)
            {
                newY = parentForm.ClientSize.Height - this.Height;
            }

            this.Location = new Point(newX, newY);

            // Forces the control to repaint for a smoother visual experience
            this.Invalidate();
        }
    }



    

    private void TitleBar_MouseDown(object sender, MouseEventArgs e)
    {
        isMouseDown = true;
        mouseDownLocation = e.Location;
    }
}