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

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

האם DIALOGS לא שייכים ל-WINAPI ?

כדי לעצב חלון ווינדוס רגיל? שהוא לא דיאלוג?
שוב - אני רוצה להשתמש ב-WINAPI בלבד...

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

זה הזמן להכיר את MFC שנותן לך שלד של תכנית מוכוונת עצמים ב-++C לתכנות עבור windows
כולל תמיכה בממשקים טבעיים של windows.

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

בהצלחה,

[ זיו ]
[ fat fish ]

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

/* נקודה היא שאני באמת מחפש יעילות מבחינת מהירות, וחושש שהממשקים של MFC יוסיפו יותר מדי שורות קוד ודברים שונים ומשונים שאינם בשליטתי הבלעדית - מה שיגרום לתוכנה להיתקע או לעבוד באיטיות. */

אז נכון ש-WinAPI ייתפקד מהר יותר - הריי זה שכבה מתחת ל-MFC.
הייתי מחכה שזיו (או כל אחד אחר, שמבין בתכנות ל-windows), יגיב ויוכל לענות לגביי עד כמה ההבדלים משמעותיים.

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

תוכל לפרט קצת על התוכנה שאתה כותב?
יום טוב.

C pogrammers never die. They are just cast into void.

תכנון GUI נכון לא צריך להפריע לביצועים של המערכת.

תכנון נכון של מערכת עם GUI יחולק תמיד לשני חלקים - backend וfrontend
הbackend יהיה החלק במערכת שיעשה את העבודה שאתה רוצה לעשות - המנוע.
יספק ממשק שכל רכיב UI לרבות GUI וכד' יוכל להתממשק אליו, לקרוא לפונקציות שאתה רוצה שהמשתמש יוכל לבצע.

הGUI, הוא רכיב UI שמסתמך על הצגה גרפית של האופציות. כל מה שהוא עושה זה להציג למשתמש תצוגה כלשהי, שממנה הוא יוכל לבצע בחירות, ועל הGUI לתרגם את בחירות המשתמש וקביעותיו לקריאות לפונקציות הממשק שמיצא הBACKEND.

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

הפגיעה היחידה בביצועים תוכל להיות בגלל שתצוגה של נתונים תתעקב... וwell.... MFC לא יהווה פגיעה בביצועים - לפחות לא כזו שתהיה גדולה יותר משימוש בGUI בכלל.

בגדול, GUI בMFC זו גישה עתיקה.
אין שום סיבה לעשות את זה ככה....
תכתוב BACKEND ב++C וFRONTEND ב#C או בסביבה אחרת שהיא נוחה יותר לעיצוב GUI מאשר MFC. (אפילו pyGtk טוב יותר מMFC)

Subtle and insubstantial, the expert leaves no trace; divinely mysterious, he is inaudible.
Thus he is the master of his enemy's fate.

ל-SCRIPTER - אני בונה תוכנה שחלק גדול מהפעילות שלה הוא תיקשור דרך WINDOW MESSAGES. דרך שם היא מקבלת את הנתונים הדרושים לפעילותה, מעבדת אותם במהירות הגבוהה ביותר ומבצעת פעולות לפי תוצאות העיבוד.
ממשק החלונות יכול להיות מינימליסטי מאוד מצידי. הוא אפילו מפריע ולא ממש מעניין אותי איך הוא יראה. למעשה, הייתי מוותר עליו לחלוטין ומתכנת SERVICE או תוכנת COMMAND LINE אם לא הייתי זקוק למידע של ה-WINDOW MESSAGE. איך התוכנה נראית ויזואלית זו הדאגה האחרונה שלי.

CYBERIA - ההגיון העומד מאחורי הדברים שאתה אומר נהיר לי. אומנם לקח לי קצת זמן להתרגל לזה, משום שאת התיכנות למדתי על לינוקס שם ההגיון שונה - ולא נחשפתי בכלל לשימוש במערכת שהיא EVENT DRIVEN. כמו שכבר כתבתי לעיל, הממשק לא ממש מעניין אותי ואני רק רוצה שהוא יהיה מינימליסטי ולא יפריע למהירות הפעולה של התוכנה. לגבי תיכנות בת'רדים - אשמח אם תפנה אותי לאיזה מדריך בנושא עבור VISUAL C++.

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

1. יוצר תפריט ושומור אותו ב-resources.
2. יוצר Window Class - WNDCLASSEX
3. ממלא את המבנה שיצרת בשלב הקודם - שים לב לשדה lpszMenuName, פה אתה אמור "להכניס" את התפריט שלך. בטח למדת כבר איך לעשות זאת -

your_window_class.lpszMenuName = MAKEINTRESOURCE( your_menu_id );

4. מבצע Register Class (RegisterClassEx)
5. יוצר את החלון CreateWindowEx
6. ומפה כל שאר הירקות... show window, get message, updatewindow וכו' וכו'.

http://msdn.microsoft.com/library/d.../wndclassex.asp

C pogrammers never die. They are just cast into void.

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

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

למה התוכנית שלך, לא נפתחת כבר עם דיאלוג על ההתחלה?
ככה אין צורך ליצור את הפקדים on the fly, פשוט תעצב את הדיאלוג ותפעיל אותו על ההתחלה, במקום החלון הראשי.

במקום ליצור דיאלוג מודאלי (בעזרת DialogBox) תיצור Modeless דיאלוג בעזרת CreateDialog.

C pogrammers never die. They are just cast into void.

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

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

לגביי קליטת מס' ולצייר כמות שורות בהתאם לקלט -> קלוט את המס' תשתמש ב-CreateWindow/CreateWindowEx ע"מ ליצור N לייבלים (Labels) או תוות טקסט.

לגביי יצירת Modeless Dialog (אודה אם מישהו ייתרגם זאת לעברית )

CreateDialog(GetModuleHandle(NULL), MAKEINTRESOURCE(ID_OF_DIALOG),
NULL/*parent window*/, DialogProcedure);

את הפרמטרים אתה יכול לקרוא באתר של MSDN.
בקצרה, התהליך הוא די דומה ליצירת חלון, רק תשכח מכל הסיבוך של WNDCLASSEX.
את הדיאלוג תייצר ותכניס אותו ב-resource.
תפעיל את התוכנית, הגדר Handle, MSG וכו'.
תיצור את הדיאלוג בעזרת הפונקציה הנ"ל (לא בעזרת DialogBox, זכור)
תקבל את ה"הודעות" כרגיל, רק זכור דבר נוסף, בלולאת GetMessage, אתה חייב לזרוק את כל ההודעות שלא קשורות לדיאלוג, תשתמש ב-IsDialogMessage.

while(GetMessage(&Msg, NULL, 0, 0) > 0)
{
if(!IsDialogMessage(g_hToolbar, &Msg))
{
TranslateMessage(&Msg);
DispatchMessage(&Msg);
}
}

לגביי יצירת פקדים on the fly, אחרי שהבנת שהעקרון מאחורי WINAPI זה שהכל חלון, אמור להיות משימה קלה - פשוט ליצור אותם בעזרת CreateWindow.

נניח אתה רוצה ליצור תוות טקסט בצורה דינאמית

hEdit = CreateWindowEx(WS_EX_CLIENTEDGE, "EDIT", "",
WS_CHILD | WS_VISIBLE | WS_VSCROLL | WS_HSCROLL | ES_MULTILINE | ES_AUTOVSCROLL | ES_AUTOHSCROLL, 0, 0, 100, 100, hwnd, /* HMENU*/NULL, GetModuleHandle(NULL), NULL);

אין הרבה מה לזכור פה, תקרא על הכל ב-MSDN.
בכללי, הפרמטר השני מציין את ה"טיפוס" של ה"חלון" שאתה רוצה לייצר.
במקרה שלנו, שמתי EDIT, כלומר, EDIT BOX.

אני אצרף דוגמא עוד הערב, כרגע אין לי מי יודע מה זמן.
בהצלחה.

C pogrammers never die. They are just cast into void.