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

אחר כך מצאתי כאןמשהו טוב, אבל אני לא יודע איך לתרגם את זה ל VB.

פורסם במקור בפורום CODE613 ב24/12/2013 10:36 (+02:00)

חיפשתי ב WPF מאפיין dropdownstyle כמו שיש בWIN-FORMS, בשביל להגדיר שהמשתמש יוכל להזין טקסט לתוך הקומבו, אבל לא מצאתי,
איך א''כ אפשר ב WPF לעשות קומבו כמו שיש באקסס ובכל מקום, שהמשתמש יכול גם לבחור מתוך הרשימה וגם להקליד ישירות לקומבו ולקבל השלמה אוטומטית ע''פ הרשימה של הקומבו?

תודה לכולם.

פורסם במקור בפורום CODE613 ב24/12/2013 09:51 (+02:00)

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

פורסם במקור בפורום CODE613 ב24/12/2013 14:22 (+02:00)

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

בכל מקרה מה ההבדל בין לשרשר לבין לכתוב ביחד?

פורסם במקור בפורום CODE613 ב23/12/2013 23:21 (+02:00)

התכוונתי לשתי שורות האלו

str = str.replace("י" + "ה", "טו");
    str = str.replace("י" + "ו", "טז");

פורסם במקור בפורום CODE613 ב23/12/2013 22:35 (+02:00)

magicode , תודה רבה, כמו תמיד קצר וקולע, [ואפי' הקפדת על שם השם שלא יופיע אפי' שזה רק על המסך.]

דוד, הקוד האחרון שהבאתי הוא לא שלי העתקתי אותו מכאן.

פורסם במקור בפורום CODE613 ב23/12/2013 22:05 (+02:00)

אז יש את זה שממיר מספר לאותיות כמו למשל 774 ל תשעד

public object HebrewNum(int n)
{
	int nX = 0;
	string sHundred = null;
	string sTen = null;
	string sOne = null;

	n = n % 1000;
	nX = n - (n % 100);
	switch (nX) {
		case 900:
			sHundred = Tuf_() + Tuf_() + Raish_();
			break;
		case 800:
			sHundred = Tuf_() + Tuf_() + Kuf_();
			break;
		case 700:
			sHundred = Tuf_() + Shin_();
			break;
		case 600:
			sHundred = Tuf_() + Raish_();
			break;
		case 500:
			sHundred = Tuf_() + Kuf_();
			break;
		case 400:
			sHundred = Tuf_();
			break;
		case 300:
			sHundred = Shin_();
			break;
		case 200:
			sHundred = Raish_();
			break;
		case 100:
			sHundred = Kuf_();
			break;
	}
	n = n - nX;
	if (n == 15) {
		sTen = Tes_();
		sOne = Vav_();
	} else if (n == 16) {
		sTen = Tes_();
		sOne = Ziyon_();
	} else {
		nX = n - (n % 10);
		switch (nX) {
			case 90:
				sTen = Tzodi_();
				break;
			case 80:
				sTen = Pai_();
				break;
			case 70:
				sTen = Iyin_();
				break;
			case 60:
				sTen = Samech_();
				break;
			case 50:
				sTen = Nun_();
				break;
			case 40:
				sTen = Mem_();
				break;
			case 30:
				sTen = Lamed_();
				break;
			case 20:
				sTen = Chaf_();
				break;
			case 10:
				sTen = Yud_();
				break;
		}
		nX = n - nX;
		switch (nX) {
			case 9:
				sOne = Tes_();
				break;
			case 8:
				sOne = Ches_();
				break;
			case 7:
				sOne = Ziyon_();
				break;
			case 6:
				sOne = Vav_();
				break;
			case 5:
				sOne = Hai_();
				break;
			case 4:
				sOne = Daled_();
				break;
			case 3:
				sOne = Gimmel_();
				break;
			case 2:
				sOne = Bais_();
				break;
			case 1:
				sOne = Alef_();
				break;
		}
	}

	return sHundred + sTen + sOne;
}


public object Alef_()
{
	return Strings.ChrW(1488);
}

public object Bais_()
{
	return Strings.ChrW(1489);
}

public object Gimmel_()
{
	return Strings.ChrW(1490);
}

public object Daled_()
{
	return Strings.ChrW(1491);
}

public object Hai_()
{
	return Strings.ChrW(1492);
}

public object Vav_()
{
	return Strings.ChrW(1493);
}

public object Ziyon_()
{
	return Strings.ChrW(1494);
}

public object Ches_()
{
	return Strings.ChrW(1495);
}

public object Tes_()
{
	return Strings.ChrW(1496);
}

public object Yud_()
{
	return Strings.ChrW(1497);
}

public object Chaf_End_()
{
	return Strings.ChrW(1498);
}

public object Chaf_()
{
	return Strings.ChrW(1499);
}

public object Lamed_()
{
	return Strings.ChrW(1500);
}

public object Mem_End_()
{
	return Strings.ChrW(1501);
}

public object Mem_()
{
	return Strings.ChrW(1502);
}

public object Nun_End_()
{
	return Strings.ChrW(1503);
}

public object Nun_()
{
	return Strings.ChrW(1504);
}

public object Samech_()
{
	return Strings.ChrW(1505);
}

public object Iyin_()
{
	return Strings.ChrW(1506);
}

public object Pai_End_()
{
	return Strings.ChrW(1507);
}

public object Pai_()
{
	return Strings.ChrW(1508);
}

public object Tzodi_End_()
{
	return Strings.ChrW(1509);
}

public object Tzodi_()
{
	return Strings.ChrW(1510);
}

public object Kuf_()
{
	return Strings.ChrW(1511);
}

public object Raish_()
{
	return Strings.ChrW(1512);
}

public object Shin_()
{
	return Strings.ChrW(1513);
}

public object Tuf_()
{
	return Strings.ChrW(1514);
}

פורסם במקור בפורום CODE613 ב23/12/2013 19:54 (+02:00)

יש לי ב C# כמה שינויים קטנים וזה מתאים ל JS

public class גימטריה
{

	public static int גימטריה_פשוטה(string aValue)
	{
		int Result = 0;
		CharEnumerator ce = aValue.GetEnumerator();

		while (ce.MoveNext()) {
			switch (ce.Current) {
				case "א":
					Result = Result + 1;
					break;
				case "ב":
					Result = Result + 2;
					break;
				case "ג":
					Result = Result + 3;
					break;
				case "ד":
					Result = Result + 4;
					break;
				case "ה":
					Result = Result + 5;
					break;
				case "ו":
					Result = Result + 6;
					break;
				case "ז":
					Result = Result + 7;
					break;
				case "ח":
					Result = Result + 8;
					break;
				case "ט":
					Result = Result + 9;
					break;
				case "י":
					Result = Result + 10;
					break;
				case "כ":
					Result = Result + 20;
					break;
				case "ך":
					Result = Result + 20;
					break;
				case "ל":
					Result = Result + 30;
					break;
				case "מ":
					Result = Result + 40;
					break;
				case "ם":
					Result = Result + 40;
					break;
				case "נ":
					Result = Result + 50;
					break;
				case "ן":
					Result = Result + 50;
					break;
				case "ס":
					Result = Result + 60;
					break;
				case "ע":
					Result = Result + 70;
					break;
				case "פ":
					Result = Result + 80;
					break;
				case "ף":
					Result = Result + 80;
					break;
				case "צ":
					Result = Result + 90;
					break;
				case "ץ":
					Result = Result + 90;
					break;
				case "ק":
					Result = Result + 100;
					break;
				case "ר":
					Result = Result + 200;
					break;
				case "ש":
					Result = Result + 300;
					break;
				case "ת":
					Result = Result + 400;
					break;
			}
		}
		return Result;
	}

	public static int גימטריה_סופיות(string aValue)
	{
		int Result = 0;
		CharEnumerator ce = aValue.GetEnumerator();

		while (ce.MoveNext()) {
			switch (ce.Current) {
				case "א":
					Result = Result + 1;
					break;
				case "ב":
					Result = Result + 2;
					break;
				case "ג":
					Result = Result + 3;
					break;
				case "ד":
					Result = Result + 4;
					break;
				case "ה":
					Result = Result + 5;
					break;
				case "ו":
					Result = Result + 6;
					break;
				case "ז":
					Result = Result + 7;
					break;
				case "ח":
					Result = Result + 8;
					break;
				case "ט":
					Result = Result + 9;
					break;
				case "י":
					Result = Result + 10;
					break;
				case "כ":
					Result = Result + 20;
					break;
				case "ל":
					Result = Result + 30;
					break;
				case "מ":
					Result = Result + 40;
					break;
				case "נ":
					Result = Result + 50;
					break;
				case "ס":
					Result = Result + 60;
					break;
				case "ע":
					Result = Result + 70;
					break;
				case "פ":
					Result = Result + 80;
					break;
				case "צ":
					Result = Result + 90;
					break;
				case "ק":
					Result = Result + 100;
					break;
				case "ר":
					Result = Result + 200;
					break;
				case "ש":
					Result = Result + 300;
					break;
				case "ת":
					Result = Result + 400;
					break;
				case "ך":
					Result = Result + 500;
					break;
				case "ם":
					Result = Result + 600;
					break;
				case "ן":
					Result = Result + 700;
					break;
				case "ף":
					Result = Result + 800;
					break;
				case "ץ":
					Result = Result + 900;
					break;
			}
		}
		return Result;
	}

	public static int גימטריה_קטנה(string aValue)
	{
		int Result = גימטריה_פשוטה(aValue);
		Result = Result % 9;
		if (Result == 0) {
			Result = 9;
		}
		return Result;
	}

	public static string גימטריה_במילוי(string aValue)
	{
		int Result = 0;
		CharEnumerator ce = aValue.GetEnumerator();

		while (ce.MoveNext()) {
			switch (ce.Current) {
				case "א":
					Result = Result + גימטריה_פשוטה("אלף");
					break;
				case "ב":
					Result = Result + גימטריה_פשוטה("בית");
					break;
				case "ג":
					Result = Result + גימטריה_פשוטה("גימל");
					break;
				case "ד":
					Result = Result + גימטריה_פשוטה("דלת");
					break;
				case "ה":
					Result = Result + גימטריה_פשוטה("הא");
					break;
				case "ו":
					Result = Result + גימטריה_פשוטה("וו");
					break;
				case "ז":
					Result = Result + גימטריה_פשוטה("זין");
					break;
				case "ח":
					Result = Result + גימטריה_פשוטה("חית");
					break;
				case "ט":
					Result = Result + גימטריה_פשוטה("טת");
					break;
				case "י":
					Result = Result + גימטריה_פשוטה("יוד");
					break;
				case "כ":
					Result = Result + גימטריה_פשוטה("כף");
					break;
				case "ך":
					Result = Result + גימטריה_פשוטה("כף");
					break;
				case "ל":
					Result = Result + גימטריה_פשוטה("למד");
					break;
				case "מ":
					Result = Result + גימטריה_פשוטה("מם");
					break;
				case "ם":
					Result = Result + גימטריה_פשוטה("מם");
					break;
				case "נ":
					Result = Result + גימטריה_פשוטה("נון");
					break;
				case "ן":
					Result = Result + גימטריה_פשוטה("נון");
					break;
				case "ס":
					Result = Result + גימטריה_פשוטה("סמך");
					break;
				case "ע":
					Result = Result + גימטריה_פשוטה("עין");
					break;
				case "פ":
					Result = Result + גימטריה_פשוטה("פא");
					break;
				case "ף":
					Result = Result + גימטריה_פשוטה("פא");
					break;
				case "צ":
					Result = Result + גימטריה_פשוטה("צדיק");
					break;
				case "ץ":
					Result = Result + גימטריה_פשוטה("צדיק");
					break;
				case "ק":
					Result = Result + גימטריה_פשוטה("קוף");
					break;
				case "ר":
					Result = Result + גימטריה_פשוטה("ריש");
					break;
				case "ש":
					Result = Result + גימטריה_פשוטה("שין");
					break;
				case "ת":
					Result = Result + גימטריה_פשוטה("תו");
					break;
			}
		}
		return Result;
	}

}

פורסם במקור בפורום CODE613 ב23/12/2013 17:47 (+02:00)

תודה רבה!
מאוד נעים להכיר את האובייקט הזה.

פורסם במקור בפורום CODE613 ב23/12/2013 13:18 (+02:00)

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

פורסם במקור בפורום CODE613 ב23/12/2013 12:56 (+02:00)

הגדרתי את ה ItemsSource של איזה קומבו לאוסף מסוג ObservableCollection
האוסף כולל אובייקטים מסוג 'איש קשר' ועשיתי Overrides על ה ToString

 Public Overrides Function ToString() As String
        Return   Last_name & " " & Name
    End Function

ובאמת הוא מציג לי את כל האוסף ורק מוסיף עוד שורה בסוף:
{NewItemPlaceHolder}
מדוע זה קורה ואיך אפשר למנוע את זה?

פורסם במקור בפורום CODE613 ב23/12/2013 11:15 (+02:00)

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

פורסם במקור בפורום CODE613 ב25/12/2013 19:44 (+02:00)

תודה רבה זה מצויין,

יש לי שתי שאלות לגבי הלחצן שבראש השורה:

1. איך אפשר להגדיר שאם הלחצן בשורה האחרונה של הדטה-גריד שבכפתור יהיה כתוב '*' במקום '+' כיון שזו שורה שמיועדת ליצירת שורה חדשה ולא שייך לפתוח שם גליון משנה.

2. איך אפשר לעשות שהלחצן עם ה '+' ישאר תמיד למעלה וכמו שכבר שאלתי באשכול אחר, ולא ירד תמיד לאמצע.

לגבי טפלט שונה לכל שורה בשביל ה RowDetailsTemplate, זה הרבה יותר מורכב, כיון שב RowDetailsTemplate אני צריך לדחוף גליון נתונים שזה פקד שלם שמקבל בבנאי שלו פרמטר של "טבלה גנארית OF TRecord" וגם צריך להגדיר שהגליון הזה הוא משנה ולא ראשי ולפי איזה ID הוא יציג את השורות.
אבל ישתבח שמו מצאתי פתרון בשיטה כזו:
בתוך ה XAML הגדרתי שה RowDetailsTemplate יהיה רק גריד פשוט, ואז בארוע LoadingRowDetails יצרתי מופע של פקד חדש של הגליון נתונים עם כל מה שהוא צריך ואז הוספתי את הפקד לילדים של הגריד הנ''ל, למדתי את זה מכאן.

פורסם במקור בפורום CODE613 ב25/12/2013 18:47 (+02:00)

עכשיו הגעתי לחלק הקשה...
אני צריך להיות מסוגל להכניס לכל דטה-רוב טמפלט אחר של DetailsTemplate, וזה לא בעיה אם הטמפלט היה איזה פקדים פשוטים, אבל מה שאני לא יודע איך להכניס לטמפלט את גליון הנתונים שיצרתי שהוא למעשה פקד מסוג UserControl שיש בו רק דטה-גריד אחד אבל הוא צריך לקבל פרמטרים בבנאי וגם הוא OF TRecord
בקיצור: בקוד דלעיל אחרי שורה 10 צריך להכניס עוד שורה כזו:

    dr.DetailsTemplate = GetRowDetailsTemplate(DC.ID)

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

פורסם במקור בפורום CODE613 ב25/12/2013 01:03 (+02:00)

בסוף מצאתי משהו כזה:
קוד ה XAML נשאר אותו דבר, ורק עוד כמה שורות שיופעלו בלחיצה על הלחצן:

Private Sub Button_Click(sender As System.Object, e As System.Windows.RoutedEventArgs)

        Dim btn As Button = DirectCast(sender, Button)
        Dim DC = DirectCast(DirectCast(btn.TemplatedParent, ContentPresenter).Parent, StackPanel).DataContext
        Dim FileOrFolder As FileOrFolder = DirectCast(DC, FileOrFolder)
        Dim dr As DataGridRow = DirectCast(dataGrid1.ItemContainerGenerator.ContainerFromItem(FileOrFolder), DataGridRow)

        If btn.Content = "+" Then
            dr.DetailsVisibility = Windows.Visibility.Visible
            btn.Content = Chr(150) ' מקף ארוך יותר מסימן '-' מינוס
        Else
            btn.Content = "+"
            dr.DetailsVisibility = Windows.Visibility.Collapsed
        End If

    End Sub

אם יש משהו יותר טוב לטווח הקצר ו/או הארוך אשמח לשומע.
תודה רבה.

פורסם במקור בפורום CODE613 ב22/12/2013 21:59 (+02:00)

אני מנסה ליצור לחצן בראש השורה בדטה-גריד בדומה למה שיש באקסס שלחצן זה יציג ויסתיר את גליון הנתונים המשני מה שנקרא ב WPF:
RowDetails

אולם כאשר עשיתי טמפלט ראש השורה כזה:

<DataGrid.RowHeaderTemplate>
    <DataTemplate>
        <Button Content="+" Click="Button_Click"> 
        </Button>
    </DataTemplate>
</DataGrid.RowHeaderTemplate>

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

Private Sub Button_Click(sender As System.Object, e As System.Windows.RoutedEventArgs)
    Dim btn As Button = DirectCast(sender, Button)
    Dim row As DataGridRow = ???
    If btn.Content = "+" Then
        btn.Content = "-"
    Else
        btn.Content = "+"
    End If
End Sub

תודה לכולם,
ושבוע טוב.

פורסם במקור בפורום CODE613 ב21/12/2013 20:13 (+02:00)

@דוד ל.ט.

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

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

פורסם במקור בפורום CODE613 ב23/12/2013 13:09 (+02:00)

@דוד ל.ט.

לבעיה שכתבת אתה צריך לקבוע את _id (לפי מקור נתוניך) מתוך קונסטרקטור סטטי:

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

@דוד ל.ט.

אבל זה ממש לא פיתרון טוב עבור מסד נתונים, מכמה וכמה סיבות.

תוכל לפרט בבקשה אני חייב לדעת.

@דוד ל.ט.

אם זה ממש מסד, אל תטפל במספור אוטומטי, בשביל מה לך.

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

פורסם במקור בפורום CODE613 ב22/12/2013 21:50 (+02:00)

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

פורסם במקור בפורום CODE613 ב21/12/2013 18:05 (+02:00)

כל כך גאוני כל כך פשוט!
תודה רבה.

נ.ב
צריך לתקן בקוד במקום Return ID
Return _id

פורסם במקור בפורום CODE613 ב19/12/2013 22:31 (+02:00)