/* ** MUI-Auftrag.c - alle Teile für die Auftragsliste und den Auftrag in MUI ** ** Copyright (C) 1996 by Stefan Scherer. ** ** Permission to use, copy, modify, and distribute this software and its ** documentation for non-commerical use and without fee is hereby granted, ** provided that the above copyright notice appear in all copies and that ** both that copyright notice and this permission notice appear in ** supporting documentation. This software is provided "as is" without ** express or implied warranty. */ #include "MUI_Main.h" /* die Input Event Codes mit der Basis ID_OL_BASE */ enum { /* Auftragsliste */ ID_OL_LIST = ID_OL_BASE, /* Listview */ ID_OL_NEWORDER, /* Neuer Auftrag */ ID_OL_DELORDER, /* Auftrag löschen */ ID_OL_EDITORDER, /* Auftrag edieren */ ID_OL_LOOKINVOICE, /* Rechnung ansehen */ ID_OL_MAKEINVOICE, /* Rechnung aus dem Auftrag erstellen */ ID_OL_PRINTORDER, /* Auftrag drucken */ ID_OL_SHOWORDER, /* Auftrag ansehen */ ID_OL_PRINTLIST, /* Auftragsliste drucken */ ID_OL_SELECTYEAR, /* Jahrgang wählen */ ID_OL_SELECTFILTER, /* Filter für Liste wählen */ /* Auftrag */ ID_O_OK, /* Änderung des Auftrags übernehmen */ ID_O_CANCEL, /* Abbruch */ ID_O_LIST, /* die Artikelliste im Auftrag wurde gewählt */ ID_O_CASH, /* keine Adresse, sondern Barverkauf */ ID_O_CUSTOMER, /* wähle Adresse aus Adreßliste für Auftrag */ ID_O_BRUTTONETTO, /* Modus für Darstellung Brutto/Netto */ ID_O_INSERT, /* neuen Artikel in Liste einfügen */ ID_O_CHANGE, /* Artikel in Liste ändern */ ID_O_DELETE, /* Artikel aus Liste löschen */ ID_O_CLEAR, /* lösche alle Eingabegadgets */ ID_O_CHOOSE, /* wähle Artikel aus Artikelliste */ }; /********************************************************************* ** ** ** A U F T R A G S L I S T E ** ** *********************************************************************/ /* Cycle Strings */ static char *CYA_OL_year[MAX_YEARS + 1]; /* Cycle-Array für MUI */ static char CYA_OL_year_buffer[5 * MAX_YEARS]; /* Puffer für Jahreszahlen */ static char *CYA_OL_mode[] = {"alle Aufträge", /* DISP_OL_ALL */ "Aufträge ohne Rechnung", /* DISP_OL_INV */ NULL}; /* Ausgabemöglichkeiten für den DisplayHook */ enum { DISP_OL_ALL, DISP_OL_INV }; /* Gadgets der "Auftragsliste" */ APTR CY_OL_year, CY_OL_mode; APTR LV_OL_list; APTR BT_OL_makeinv, BT_OL_new, BT_OL_del, BT_OL_edit; APTR BT_OL_lookinv, BT_OL_prtord, BT_OL_prtlist, BT_OL_showord; /* ** Cycle-Gadget Jahreszahlen der Auftragsliste: ** baue das String-Array für das Cycle-Gadget auf. */ void Build_OL_years (void) { UWORD i; UWORD year; i = OL_GetYearCount (); for (i = 0; i < OL_GetYearCount () && i < MAX_YEARS; i++) { OL_GetYear (i, &year); sprintf (&CYA_OL_year_buffer[5 * i], "%04d", year); CYA_OL_year[i] = &CYA_OL_year_buffer[5 * i]; } CYA_OL_year[i] = NULL; } /* ** Support-Funktionen für die "Auftragsliste" ** ** MUI verwaltet eine eigene Liste, die intern alle Daten aufnimmt ** und über eine DisplayFunc am Bildschirm angezeigt wird. */ SAVEDS ASM APTR OL_ConstructFunc (REG (a1) struct MinOrder *order, REG (a2) void *mempool) { struct MinOrder *newitem; if (newitem = LibAllocPooled (mempool, sizeof (struct MinOrder))) { newitem->orderNumber = order->orderNumber; newitem->orderYear = order->orderYear; strcpy (newitem->orderDate, order->orderDate); strcpy (newitem->Kunde, order->Kunde); newitem->invoiceNumber = order->invoiceNumber; newitem->invoiceYear = order->invoiceYear; strcpy (newitem->invoiceDate, order->invoiceDate); } return ((APTR) newitem); } SAVEDS ASM VOID OL_DestructFunc (REG (a1) struct MinOrder * order, REG (a2) void *mempool) { LibFreePooled (mempool, order, sizeof (struct MinOrder)); } SAVEDS ASM LONG OL_DisplayFunc_All (REG (a2) char **array, REG (a1) struct MinOrder *order) { static char buf1[30], buf2[30]; if (order) { /* zeige den Eintrag an. */ sprintf (buf1, "%04d/%d (%s)", order->orderYear, order->orderNumber, order->orderDate); *array++ = buf1; if (order->invoiceNumber && order->invoiceYear) { sprintf (buf2, "%04d/%d (%s)", order->invoiceYear, order->invoiceNumber, order->invoiceDate); *array++ = buf2; } else *array++ = ""; *array = order->Kunde; } else { /* zeige die Titel-Zeile an. */ *array++ = "\033bAuftrag"; *array++ = "\033bRechnung"; *array = "\033bKunde"; } return (0); } SAVEDS ASM LONG OL_DisplayFunc_Inv (REG (a2) char **array, REG (a1) struct MinOrder * order) { static char buf1[30]; if (order) { /* zeige den Eintrag an. */ sprintf (buf1, "%04d/%d (%s)", order->orderYear, order->orderNumber, order->orderDate); *array++ = buf1; *array = order->Kunde; } else { /* zeige die Titel-Zeile an. */ *array++ = "\033bAuftrag"; *array = "\033bKunde"; } return (0); } /* Hooks für Auftragsliste */ static const struct Hook OL_ConstructHook = { {NULL, NULL}, (VOID *) OL_ConstructFunc, NULL, NULL}; static const struct Hook OL_DestructHook = { {NULL, NULL}, (VOID *) OL_DestructFunc, NULL, NULL}; static const struct Hook OL_DisplayHook_All = { {NULL, NULL}, (VOID *) OL_DisplayFunc_All, NULL, NULL}; static const struct Hook OL_DisplayHook_Inv = { {NULL, NULL}, (VOID *) OL_DisplayFunc_Inv, NULL, NULL}; /* ** Beim Verändern der Einstellungen für die Auftragsliste muß diese komplett ** neu aufgebaut werden. Der alte Inhalt wird gelöscht und je nach Modus ** die entsprechenden Einträge neu eingefügt. */ void Redraw_OL_List (void) { UWORD year, actnum; int i, j, active; LONG mode, cyear; struct MinOrder minorder; get (CY_OL_year, MUIA_Cycle_Active, &cyear); get (CY_OL_mode, MUIA_Cycle_Active, &mode); year = atoi (&CYA_OL_year_buffer[5 * cyear]); OL_SetYear (year); set (LV_OL_list, MUIA_List_Quiet, TRUE); DoMethod (LV_OL_list, MUIM_List_Clear); actnum = OL_GetCurrentOrderNumber (); active = -1; switch (mode) { case DISP_OL_ALL: set (LV_OL_list, MUIA_List_DisplayHook, &OL_DisplayHook_All); set (LV_OL_list, MUIA_List_Format, "D=8,D=8,"); for (j = 0, i = 0; i < OL_GetOrderCount (); i++) { OL_GetOrder (i, &minorder); if (minorder.orderNumber == actnum) active = j; DoMethod (LV_OL_list, MUIM_List_InsertSingle, &minorder, MUIV_List_Insert_Bottom); j++; } break; case DISP_OL_INV: set (LV_OL_list, MUIA_List_DisplayHook, &OL_DisplayHook_Inv); set (LV_OL_list, MUIA_List_Format, "D=8,"); for (j = 0, i = 0; i < OL_GetOrderCount (); i++) { OL_GetOrder (i, &minorder); if (minorder.orderNumber == actnum) active = j; if (!(minorder.invoiceNumber || minorder.invoiceYear)) { DoMethod (LV_OL_list, MUIM_List_InsertSingle, &minorder, MUIV_List_Insert_Bottom); j++; } } break; } /* j ist die Anzahl der Einträge in der MUI-Liste */ if (j == 0) { set (LV_OL_list, MUIA_List_Quiet, FALSE); } else { set (LV_OL_list, MUIA_List_Active, active); set (LV_OL_list, MUIA_List_Quiet, FALSE); DoMethod (LV_OL_list, MUIM_List_Jump, MUIV_List_Jump_Active); } } APTR MUI_BuildOrderList (void) { #ifdef DEBUG printf ("in BuildOrderList()\n"); #endif return (VGroup, Child, HGroup, Child, CY_OL_year = Cycle (CYA_OL_year), Child, CY_OL_mode = Cycle (CYA_OL_mode), End, Child, LV_OL_list = ListviewObject, MUIA_Listview_List, ListObject, InputListFrame, MUIA_List_ConstructHook, &OL_ConstructHook, MUIA_List_DestructHook, &OL_DestructHook, MUIA_List_DisplayHook, &OL_DisplayHook_All, MUIA_List_Format, "D=8,D=8,", MUIA_List_Title, TRUE, End, End, Child, HGroup, Child, BT_OL_new = KeyButton ("Neu", 'n'), Child, BT_OL_del = KeyButton ("Löschen", 'l'), Child, BT_OL_edit = KeyButton ("Edieren", 'e'), End, Child, ColGroup (2), Child, BT_OL_lookinv = KeyButton ("Rechnung ansehen", 'a'), Child, BT_OL_makeinv = KeyButton ("Erstelle Rechnung", 'r'), Child, BT_OL_prtord = KeyButton ("Auftrag drucken", 'd'), #ifndef SHOW_DVI #else Child, BT_OL_showord = KeyButton ("Auftragsvorschau...", 'g'), #endif End, #if 0 Child, BT_OL_prtlist = KeyButton ("Auftragsliste drucken", 'i'), #endif End); } /********************************************************************* ** ** ** A U F T R A G ** ** *********************************************************************/ APTR TX_O_summe, ST_O_orddate, TX_O_ordnum, REG_O_mode, BT_O_customer; APTR ST_O_adr1, ST_O_adr2, ST_O_adr3, ST_O_adr4, ST_O_adr5, ST_O_kundennr, ST_O_zeichen, BT_O_cash; APTR LV_O_list, BT_O_insert, BT_O_delete, BT_O_choose; APTR ST_O_artnum, ST_O_article, ST_O_VKeinzel, ST_O_menge; APTR CY_O_mwst, CY_O_mode, ST_O_firma, ST_O_note; APTR TX_O_invdate, TX_O_invnum; APTR BT_O_clear, BT_O_change, BT_O_ok, BT_O_cancel; static char *OrderPages[] = {"Kunde", "Auftrag", "Info", NULL}; /* ** Support-Funktionen für den "Auftrag" und die "Rechnung" ** ** MUI verwaltet eine eigene Liste, die intern alle Daten aufnimmt ** und über eine DisplayFunc am Bildschirm angezeigt wird. */ SAVEDS ASM APTR O_ConstructFunc (REG (a1) struct Article *article, REG (a2) void *mempool) { struct Article *newitem; if (newitem = LibAllocPooled (mempool, sizeof (struct Article))) { newitem->Betrag = article->Betrag; newitem->Preistabelle = article->Preistabelle; newitem->Menge = article->Menge; strcpy (newitem->Artikelnummer, article->Artikelnummer); strcpy (newitem->Bezeichnung, article->Bezeichnung); } return ((APTR) newitem); } SAVEDS ASM VOID O_DestructFunc (REG (a1) struct Article * article, REG (a2) void *mempool) { LibFreePooled (mempool, article, sizeof (struct Article)); } SAVEDS ASM LONG O_DisplayFunc (REG (a2) char **array, REG (a1) struct Article *article) { static char buf2[30], buf3[24], buf4[16], buf5[24]; if (article) { /* zeige den Eintrag an. */ *array++ = article->Artikelnummer; *array++ = article->Bezeichnung; sprintf (buf2, "\033r"); PrintMonetary (&buf2[2], article->Menge); *array++ = buf2; strcpy (buf3, "\033r"); PrintCurrency (&buf3[2], article->Betrag); *array++ = buf3; strcpy (buf4, "\033r"); PrintMonetary (&buf4[2], O_GetMwSt (article->Preistabelle)); *array++ = buf4; strcpy (buf5, "\033r"); PrintCurrency (&buf5[2], article->Betrag * article->Menge); *array = buf5; } else { /* zeige die Titel-Zeile an. */ *array++ = "\033bArt.-Nr."; *array++ = "\033bBezeichnung"; *array++ = "\033bMenge"; *array++ = "\033bEinzel"; *array++ = "\033bMwSt"; *array = "\033bGesamt"; } return (0); } /* Hooks für Auftrag */ static struct Hook O_ConstructHook = { {NULL, NULL}, (VOID *) O_ConstructFunc, NULL, NULL}; static struct Hook O_DestructHook = { {NULL, NULL}, (VOID *) O_DestructFunc, NULL, NULL}; static struct Hook O_DisplayHook = { {NULL, NULL}, (VOID *) O_DisplayFunc, NULL, NULL}; /* Cycle-Array mit den Mehrwertsteuersätzen, die pro Auftrag neu eingestellt ** werden können. */ static char CYA_O_MwSt1_buffer[12]; /* Puffer für MwSt-Strings */ static char CYA_O_MwSt2_buffer[12]; /* Puffer für MwSt-Strings */ static char *CYA_O_MwSt[] = {CYA_O_MwSt1_buffer, CYA_O_MwSt2_buffer, NULL}; /* von wo aus wurde das Fenster geöffnet, d.h. ** was passiert, wenn der Auftrag geschlossen wird */ UWORD closeOrderAction; /* lösche die Eingabefelder für einen neuen Artikel */ static void Clear_O_Inputs (void) { char buffer[20]; set (ST_O_artnum, MUIA_String_Contents, ""); set (ST_O_article, MUIA_String_Contents, ""); O_GetOrderDate (buffer); set (ST_O_orddate, MUIA_String_Contents, buffer); set (ST_O_menge, MUIA_String_Contents, "1"); PrintCurrency (buffer, 0.0); #ifdef ORDER_EK set (ST_O_EKeinzel, MUIA_String_Contents, buffer); #endif set (ST_O_VKeinzel, MUIA_String_Contents, buffer); set (CY_O_mwst, MUIA_Cycle_Active, 0); set (ST_O_firma, MUIA_String_Contents, ""); set (ST_O_note, MUIA_String_Contents, ""); } /* ** prüfe, ob der Auftrag abgebrochen werden darf. Gib evtl. Requester aus. ** ** Rückgabe: ** ** TRUE - es darf abgebrochen werden. ** FALSE - nicht abbrechen, Rechnung weiter edieren */ BOOL O_CheckAbort (BOOL endok) { BOOL abort = TRUE; LONG isopen; char buffer[20]; BOOL diff = FALSE; struct Article article; struct MinCustomer cust; LONG num; STRPTR str; float betrag; O_GetOrderNumber (buffer); get (WI_order, MUIA_Window_Open, &isopen); if (isopen) { article.Artikelnummer[0] = 0; article.Bezeichnung[0] = 0; article.Preistabelle = 1; article.Betrag = 0.0; article.Lieferfirma[0] = 0; article.Notiz[0] = 0; O_GetCurrentItem (&article); get (ST_O_artnum, MUIA_String_Contents, &str); diff |= (strcmp (article.Artikelnummer, str) != 0); get (ST_O_article, MUIA_String_Contents, &str); diff |= (strcmp (article.Bezeichnung, str) != 0); get (CY_O_mwst, MUIA_Cycle_Active, &num); diff |= (article.Preistabelle != num + 1); get (ST_O_VKeinzel, MUIA_String_Contents, &str); betrag = ScanMonetary (str); if (CO_GetOrderMwStMode ()) { /* Bruttobetrag in Netto wandeln */ betrag = Brutto2Netto (betrag, O_GetMwSt (article.Preistabelle)); } diff |= (abs (article.Betrag - betrag) > 0.01); get (ST_O_firma, MUIA_String_Contents, &str); diff |= (strcmp (article.Lieferfirma, str) != 0); get (ST_O_note, MUIA_String_Contents, &str); diff |= (strcmp (article.Notiz, str) != 0); if (!endok) { /* check address */ O_GetOrderAddress (&cust); get (ST_O_adr1, MUIA_String_Contents, &str); diff |= (strcmp (cust.Adresse1, str) != 0); get (ST_O_adr2, MUIA_String_Contents, &str); diff |= (strcmp (cust.Adresse2, str) != 0); get (ST_O_adr3, MUIA_String_Contents, &str); diff |= (strcmp (cust.Adresse3, str) != 0); get (ST_O_adr4, MUIA_String_Contents, &str); diff |= (strcmp (cust.Adresse4, str) != 0); get (ST_O_adr5, MUIA_String_Contents, &str); diff |= (strcmp (cust.Adresse5, str) != 0); get (ST_O_kundennr, MUIA_String_Contents, &str); diff |= (cust.KundenNummer != atoi (str)); get (ST_O_zeichen, MUIA_String_Contents, &str); diff |= (strcmp (cust.Zeichen, str) != 0); } diff = FALSE; if (diff && !MUI_Request (app, WI_order, 0, "Eingabe im Auftrag abbrechen...", "Verwerfen|Zurück", "\033cDie Eingabefelder im Auftrag wurden verändert.\n" "Wollen Sie Ihre Änderungen wirklich verwerfen?")) { abort = FALSE; } if (!endok && abort) { if (O_GetStatus () && !MUI_Request (app, WI_order, 0, "Auftrag abbrechen...", "Verwerfen|Zurück", "\033cDer Auftrag %s wurde verändert.\n" "Wollen Sie Ihre Änderungen wirklich verwerfen?", buffer)) abort = FALSE; } } if (abort && (closeCustomerAction == CCA_ORDER)) { set (WI_customer, MUIA_Window_Title, "Adreßliste"); closeCustomerAction = CCA_MAIN; } if (abort && (closeArticleAction == CAA_ORDER)) { set (WI_article, MUIA_Window_Title, "Artikelliste"); closeArticleAction = CAA_MAIN; } return (abort); } /* zeige einen Artikel in den Gadgets an */ static void O_DisplayArticle (void) { LONG num; char buffer[20]; struct Article article; struct Article *active; DoMethod (LV_O_list, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &active); if (active) { get (LV_O_list, MUIA_List_Active, &num); O_SetCurrentItemNumber (num); O_GetCurrentItem (&article); set (ST_O_artnum, MUIA_String_Contents, article.Artikelnummer); set (ST_O_article, MUIA_String_Contents, article.Bezeichnung); PrintMonetary (buffer, article.Menge); set (ST_O_menge, MUIA_String_Contents, buffer); #ifdef ORDER_EK DisplayBetrag (buffer, article.EKBetrag, O_GetMwSt (article.Preistabelle), CO_GetOrderMwStMode ()); set (ST_O_EKeinzel, MUIA_String_Contents, buffer); #endif DisplayBetrag (buffer, article.Betrag, O_GetMwSt (article.Preistabelle), CO_GetOrderMwStMode ()); set (ST_O_VKeinzel, MUIA_String_Contents, buffer); set (CY_O_mwst, MUIA_Cycle_Active, article.Preistabelle - 1); set (ST_O_firma, MUIA_String_Contents, article.Lieferfirma); set (ST_O_note, MUIA_String_Contents, article.Notiz); } } /* Neuaufbau der Liste im Auftrag */ static void Redraw_O_List (void) { struct Article art; int i; set (LV_O_list, MUIA_List_Quiet, TRUE); DoMethod (LV_O_list, MUIM_List_Clear); for (i = 0; i < O_GetOrderItemCount (); i++) { O_GetOrderItem (i, &art); DoMethod (LV_O_list, MUIM_List_InsertSingle, &art, MUIV_List_Insert_Bottom); } if (i == 0) { set (LV_O_list, MUIA_List_Quiet, FALSE); } else { set (LV_O_list, MUIA_List_Quiet, FALSE); set (LV_O_list, MUIA_List_Active, O_GetCurrentItemNumber ()); DoMethod (LV_O_list, MUIM_List_Jump, MUIV_List_Jump_Active); } } /* vor dem Öffnen werden die Daten aus dem Auftrags-Modul in die ** MUI-Oberfläche übertragen.. */ void InitOrderWin (void) { struct MinCustomer mincust; struct MinOrder minorder; char buffer[20]; double betrag; /* allgemeine Daten */ O_GetMinOrder (&minorder); set (ST_O_orddate, MUIA_String_Contents, minorder.orderDate); O_GetOrderNumber (buffer); set (TX_O_ordnum, MUIA_Text_Contents, buffer); /* MwSt-Sätze für Cycle-Gadget erstellen */ PrintMonetary (CYA_O_MwSt1_buffer, O_GetMwSt (1)); PrintMonetary (CYA_O_MwSt2_buffer, O_GetMwSt (2)); strcat (CYA_O_MwSt1_buffer, "%"); strcat (CYA_O_MwSt2_buffer, "%"); /* Kundenseite */ O_GetOrderAddress (&mincust); set (ST_O_adr1, MUIA_String_Contents, mincust.Adresse1); set (ST_O_adr2, MUIA_String_Contents, mincust.Adresse2); set (ST_O_adr3, MUIA_String_Contents, mincust.Adresse3); set (ST_O_adr4, MUIA_String_Contents, mincust.Adresse4); set (ST_O_adr5, MUIA_String_Contents, mincust.Adresse5); if (mincust.KundenNummer) { sprintf (buffer, "%d", mincust.KundenNummer); set (ST_O_kundennr, MUIA_String_Contents, buffer); } else set (ST_O_kundennr, MUIA_String_Contents, ""); set (ST_O_zeichen, MUIA_String_Contents, mincust.Zeichen); /* Auftragsseite */ Redraw_O_List (); Clear_O_Inputs (); /* auf jeden Fall ein Wechsel -> strings OK */ set (CY_O_mwst, MUIA_Cycle_Active, 1); set (CY_O_mwst, MUIA_Cycle_Active, 0); /* sonstige Seite */ if (minorder.invoiceYear && minorder.invoiceNumber) { set (TX_O_invdate, MUIA_Text_Contents, minorder.invoiceDate); O_GetInvoiceNumber (buffer); set (TX_O_invnum, MUIA_Text_Contents, buffer); } else { set (TX_O_invdate, MUIA_Text_Contents, ""); set (TX_O_invnum, MUIA_Text_Contents, ""); } O_GetOrderSum (NULL, NULL, NULL, NULL, &betrag); PrintCurrency (buffer, betrag); set (TX_O_summe, MUIA_Text_Contents, buffer); set (WI_order, MUIA_Window_ActiveObject, LV_O_list); } APTR MUI_BuildOrder (void) { #ifdef DEBUG printf ("in BuildOrder()\n"); #endif return (VGroup, Child, HGroup, Child, Label2 ("Auftragsnummer:"), Child, TX_O_ordnum = TextObject, TextFrame, MUIA_Background, MUII_TextBack, MUIA_HorizWeight, 20, End, Child, Label2 ("Auftragsdatum:"), Child, ST_O_orddate = String ("01.01.1978", 16), Child, Label2 ("Summe:"), Child, TX_O_summe = TextObject, TextFrame, MUIA_Background, MUII_TextBack, MUIA_HorizWeight, 20, End, End, Child, REG_O_mode = RegisterGroup (OrderPages), MUIA_Register_Frame, TRUE, /* Register "Kunde" */ Child, VGroup, GroupFrameT ("Kunde"), MUIA_HelpNode, "ordercust-register", Child, HGroup, Child, BT_O_customer = KeyButton ("Adresse auswählen...", 'a'), Child, BT_O_cash = KeyButton ("Barverkauf", 'b'), End, Child, ColGroup (2), Child, KeyLabel2 ("Anrede:", 'r'), Child, HGroup, Child, ST_O_adr1 = KeyString ("", 80, 'r'), Child, KeyLabel2 ("Zeichen:", 'z'), Child, ST_O_zeichen = KeyString ("", 20, 'z'), Child, KeyLabel2 ("Kundennr:", 'k'), Child, ST_O_kundennr = KeyString ("", 20, 'k'), End, Child, KeyLabel2 ("Adresse:", 'd'), Child, ST_O_adr2 = KeyString ("", 80, 'd'), Child, Label2 (""), Child, ST_O_adr3 = String ("", 80), Child, Label2 (""), Child, ST_O_adr4 = String ("", 80), Child, Label2 (""), Child, ST_O_adr5 = String ("", 80), End, End, /* Register "Auftrag" */ Child, VGroup, MUIA_HelpNode, "orderord-register", Child, LV_O_list = ListviewObject, MUIA_Listview_List, ListObject, InputListFrame, MUIA_List_ConstructHook, &O_ConstructHook, MUIA_List_DestructHook, &O_DestructHook, MUIA_List_DisplayHook, &O_DisplayHook, MUIA_List_Format, "D=8,D=8,D=8,D=8,D=8,", MUIA_List_Title, TRUE, End, End, Child, HGroup, Child, BT_O_insert = KeyButton ("Einfügen", 'e'), Child, BT_O_change = KeyButton ("Ändern", 'ä'), Child, BT_O_delete = KeyButton ("Löschen", 'l'), End, Child, ColGroup (2), GroupFrameT ("gewählter Artikel"), Child, VGroup, Child, KeyLabel2 ("Artikelnummer:", 'a'), Child, KeyLabel2 ("Bezeichnung:", 'b'), Child, KeyLabel2 ("Verkaufspreis:", 'v'), Child, KeyLabel2 ("MwSt:", 's'), Child, KeyLabel2 ("Lieferfirma:", 'f'), Child, KeyLabel2 ("Notiz:", 't'), End, Child, VGroup, Child, HGroup, Child, ST_O_artnum = KeyString ("", 80, 'a'), Child, BT_O_choose = KeyButton ("Artikel wählen...", 'w'), Child, BT_O_clear = KeyButton ("Neu", 'n'), End, Child, ST_O_article = KeyString ("", 80, 'b'), Child, ColGroup (3), Child, ST_O_VKeinzel = KeyMonetaryString ("", 20, 'v'), Child, KeyLabel2 ("Menge:", 'm'), Child, ST_O_menge = KeyString ("", 10, 'm'), Child, CY_O_mwst = KeyCycle (CYA_O_MwSt, 's'), Child, KeyLabel2 ("Eingabe:", 'i'), Child, CY_O_mode = KeyCycle (CYA_BruttoNetto, 'i'), End, Child, ST_O_firma = KeyString ("", 80, 'f'), Child, ST_O_note = KeyString ("", 80, 't'), End, End, End, /* Register "Sonstiges" */ Child, VGroup, MUIA_HelpNode, "ordermisc-register", Child, VGroup, GroupFrameT ("Rechnung"), Child, ColGroup (2), Child, Label2 ("Rechnungsdatum:"), Child, TX_O_invdate = TextObject, TextFrame, MUIA_Background, MUII_TextBack, End, Child, Label2 ("Rechnungsnummer:"), Child, TX_O_invnum = TextObject, TextFrame, MUIA_Background, MUII_TextBack, End, End, End, End, End, Child, HGroup, Child, BT_O_ok = KeyButton ("OK", 'o'), Child, BT_O_cancel = KeyButton ("Abbruch", 'u'), End, End); } /* nach dem Erstellen der MUI müssen noch einige Methoden ausgeführt werden. ** Diese Funktion wird vom Hauptprogramm aus aufgerufen */ void DoOrderMethods (void) { /* Auftragsliste */ DoMethod (WI_ordlist, MUIM_Notify, MUIA_Window_CloseRequest, TRUE, WI_ordlist, 3, MUIM_Set, MUIA_Window_Open, FALSE); DoMethod (WI_ordlist, MUIM_Notify, MUIA_Window_Open, TRUE, WI_ordlist, 3, MUIM_Set, MUIA_Window_ActiveObject, LV_OL_list); DoMethod (LV_OL_list, MUIM_Notify, MUIA_List_Active, MUIV_EveryTime, app, 2, MUIM_Application_ReturnID, ID_OL_LIST); DoMethod (LV_OL_list, MUIM_Notify, MUIA_Listview_DoubleClick, TRUE, app, 2, MUIM_Application_ReturnID, ID_OL_EDITORDER); DoMethod (BT_OL_new, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_OL_NEWORDER); DoMethod (BT_OL_del, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_OL_DELORDER); DoMethod (BT_OL_edit, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_OL_EDITORDER); DoMethod (BT_OL_makeinv, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_OL_MAKEINVOICE); DoMethod (BT_OL_lookinv, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_OL_LOOKINVOICE); DoMethod (BT_OL_prtord, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_OL_PRINTORDER); DoMethod (BT_OL_showord, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_OL_SHOWORDER); #if 0 DoMethod (BT_OL_prtlist, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_OL_PRINTLIST); #endif DoMethod (CY_OL_year, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, app, 2, MUIM_Application_ReturnID, ID_OL_SELECTYEAR); DoMethod (CY_OL_mode, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, app, 2, MUIM_Application_ReturnID, ID_OL_SELECTFILTER); set (CY_OL_year, MUIA_Cycle_Active, OL_GetCurrentYearNumber ()); set (CY_OL_mode, MUIA_Cycle_Active, CO_GetOrderMode ()); /* Auftrag */ DoMethod (WI_order, MUIM_Notify, MUIA_Window_InputEvent, "rawkey -capslock -shift right", REG_O_mode, 3, MUIM_Set, MUIA_Group_ActivePage, MUIV_Group_ActivePage_Next); DoMethod (WI_order, MUIM_Notify, MUIA_Window_InputEvent, "rawkey -capslock -shift left", REG_O_mode, 3, MUIM_Set, MUIA_Group_ActivePage, MUIV_Group_ActivePage_Prev); DoMethod (LV_O_list, MUIM_Notify, MUIA_List_Active, MUIV_EveryTime, app, 2, MUIM_Application_ReturnID, ID_O_LIST); DoMethod (WI_order, MUIM_Notify, MUIA_Window_CloseRequest, TRUE, app, 2, MUIM_Application_ReturnID, ID_O_CANCEL); DoMethod (BT_O_ok, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_O_OK); DoMethod (BT_O_cancel, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_O_CANCEL); DoMethod (BT_O_customer, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_O_CUSTOMER); DoMethod (BT_O_cash, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_O_CASH); DoMethod (CY_O_mode, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, app, 2, MUIM_Application_ReturnID, ID_O_BRUTTONETTO); set (CY_O_mode, MUIA_Cycle_Active, CO_GetOrderMwStMode ()); /* 16.4.95: ghost the cycle gadget */ if (CO_GetIsNetto ()) set (CY_O_mode, MUIA_Disabled, TRUE); DoMethod (BT_O_insert, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_O_INSERT); DoMethod (BT_O_change, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_O_CHANGE); DoMethod (BT_O_delete, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_O_DELETE); DoMethod (BT_O_clear, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_O_CLEAR); DoMethod (BT_O_choose, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_O_CHOOSE); DoMethod (WI_order, MUIM_Window_SetCycleChain, ST_O_adr1, ST_O_zeichen, ST_O_kundennr, ST_O_adr2, ST_O_adr3, ST_O_adr4, ST_O_adr5, LV_O_list, ST_O_artnum, ST_O_article, ST_O_VKeinzel, ST_O_menge, CY_O_mwst, ST_O_firma, ST_O_note, NULL); } /* falls Input Events für den Auftrag eintreffen, werden sie über diese ** Funktion ausgewertet. */ void HandleOrderEvents (ULONG event) { switch (event) { /* Auftragsliste */ case ID_OL_LIST: /* Benutzer wählt einen Auftrag aus der Liste aus */ { struct MinOrder *active; DoMethod (LV_OL_list, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &active); if (active) { if (active->invoiceYear && active->invoiceNumber) { set (BT_OL_makeinv, MUIA_Disabled, TRUE); set (BT_OL_lookinv, MUIA_Disabled, FALSE); } else { set (BT_OL_makeinv, MUIA_Disabled, FALSE); set (BT_OL_lookinv, MUIA_Disabled, TRUE); } OL_SetCurrentOrderNumber (active->orderNumber); } } break; case ID_OL_SELECTYEAR: case ID_OL_SELECTFILTER: /* Jahrgang, Filter neu eingestellt: Liste neu aufbauen */ Redraw_OL_List (); /* in alten Jahrgängen keine neuen Aufträge erstellen lassen */ if (OL_GetCurrentYear () < GetThisYear ()) set (BT_OL_new, MUIA_Disabled, TRUE); else set (BT_OL_new, MUIA_Disabled, FALSE); break; case ID_OL_NEWORDER: /* neuen Auftrag erstellen */ { char buf[16]; if (O_CheckAbort (FALSE)) { closeOrderAction = COA_MAIN_NEW; /* Auftrag intern neu aufbauen */ O_NewOrder (); sprintf (buf, "%04d/%d", OL_GetCurrentYear (), OL_GetNextOrderNumber ()); O_SetOrderNumber (buf); O_SetMwSt (CO_GetMwSt1 (), CO_GetMwSt2 ()); O_SetOrderAddress (&cashcust); InitOrderWin (); set (WI_order, MUIA_Window_Open, TRUE); } } break; case ID_OL_DELORDER: /* aktuellen Auftrag löschen */ { struct MinOrder *active; closeOrderAction = COA_MAIN_EDIT; DoMethod (LV_OL_list, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &active); if (active) { struct MinOrder comp; BOOL del = TRUE, abort = FALSE; O_GetMinOrder (&comp); if ((active->orderYear == comp.orderYear) && (active->orderNumber == comp.orderNumber)) abort = TRUE; if (abort && !O_CheckAbort (FALSE)) del = FALSE; if (abort && del) set (WI_order, MUIA_Window_Open, FALSE); if (del) { if (MUI_Request (app, WI_ordlist, 0, "Auftrag löschen...", "Löschen|Abbruch", "\033cWollen Sie den Auftrag\n" "'%04ld/%ld %s'\nwirklich löschen?", active->orderYear, active->orderNumber, active->Kunde)) { OL_DelOrder (); Redraw_OL_List (); } } } } break; case ID_OL_EDITORDER: /* aktuellen Auftrag edieren */ { struct MinOrder *active; if (O_CheckAbort (FALSE)) { closeOrderAction = COA_MAIN_EDIT; DoMethod (LV_OL_list, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &active); if (active) { /* Auftrag einlesen */ if (!OL_LoadOrder (active)) { /* Auftragsfenster vorbereiten */ InitOrderWin (); set (WI_order, MUIA_Window_Open, TRUE); } else { MUI_Request (app, WI_ordlist, 0, "Fehlermeldung", "OK", "Auftrag laden\n%s", OL_GetErrorMsg ()); } } } } break; case ID_OL_LOOKINVOICE: /* Rechnung ansehen */ { struct MinOrder *active; closeInvoiceAction = CIA_MAIN_EDIT; DoMethod (LV_OL_list, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &active); if (active && active->invoiceYear && active->invoiceNumber) { struct MinInvoice item; if (I_CheckAbort (FALSE)) { IL_SetYear (active->invoiceYear); if (!IL_SetCurrentInvoiceNumber (active->invoiceNumber)) { IL_GetCurrentInvoice (&item); /* Rechnung einlesen */ if (!IL_LoadInvoice (&item, TRUE)) { /* Rechnungsfenster vorbereiten */ InitInvoiceWin (); set (WI_invoice, MUIA_Window_Open, TRUE); } else { MUI_Request (app, WI_ordlist, 0, "Fehlermeldung", "OK", "Rechnung laden\n%s", IL_GetErrorMsg ()); } } Redraw_IL_List (); } } } break; case ID_OL_MAKEINVOICE: /* Rechnung aus Auftrag erstellen */ { struct MinOrder *active; struct MinCustomer mincust; struct Article art; char buf[16]; int i; if (I_CheckAbort (FALSE)) { closeInvoiceAction = CIA_MAIN_ORDINV; DoMethod (LV_OL_list, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &active); if (active && !(active->invoiceYear || active->invoiceNumber)) { /* Auftrag einlesen */ if (!OL_LoadOrder (active)) { /* Rechnung intern neu aufbauen */ I_NewInvoice (); sprintf (buf, "%04d/%d", IL_GetCurrentYear (), IL_GetNextInvoiceNumber ()); I_SetInvoiceNumber (buf); I_SetMwSt (CO_GetMwSt1 (), CO_GetMwSt2 ()); sprintf (buf, "%04d/%d", active->orderYear, active->orderNumber); I_SetOrderNumber (buf); I_SetOrderDate (active->orderDate); O_GetOrderAddress (&mincust); I_SetInvoiceAddress (&mincust); for (i = 0; i < O_GetOrderItemCount (); i++) { O_GetOrderItem (i, &art); I_AddInvoiceItem ((struct MinArticle *) &art); } InitInvoiceWin (); set (WI_invoice, MUIA_Window_Open, TRUE); } else { MUI_Request (app, WI_ordlist, 0, "Fehlermeldung", "OK", "Auftrag laden\n%s", OL_GetErrorMsg ()); } } } } break; case ID_OL_PRINTORDER: /* Auftrag drucken */ { struct MinOrder *active; struct Screen *scr; STRPTR name; DoMethod (LV_OL_list, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &active); if (active) { /* Auftrag einlesen */ if (!OL_LoadOrder (active)) { struct MinCustomer cust; char date[12], number[12]; O_GetOrderAddress (&cust); O_GetOrderDate (date); O_GetOrderNumber (number); get (WI_main, MUIA_Window_Screen, &scr); name = GetPublicScreenName (scr); #ifndef OUTPUTWIN set (app, MUIA_Application_Sleep, TRUE); #endif if (!CheckSum (Benutzer, oldchecksum)) P_Print (PRT_MODE_CONFIRMATION, name, O_GetDummyOrderItem, &cust, O_GetOrderItemCount (), number, date, NULL, O_GetMwSt (1), O_GetMwSt (2), FALSE); else P_Print (PRT_MODE_CONFIRMATION, name, O_GetOrderItem, &cust, O_GetOrderItemCount (), number, date, NULL, O_GetMwSt (1), O_GetMwSt (2), FALSE); #ifndef OUTPUTWIN set (app, MUIA_Application_Sleep, FALSE); #endif } else { MUI_Request (app, WI_ordlist, 0, "Fehlermeldung", "OK", "Auftrag laden\n%s", OL_GetErrorMsg ()); } } } break; #if 0 case ID_OL_PRINTLIST: { STRPTR name; struct Screen *scr; get (WI_main, MUIA_Window_Screen, &scr); name = GetPublicScreenName (scr); #ifndef OUTPUTWIN set (app, MUIA_Application_Sleep, TRUE); #endif P_PrintList (1, name); #ifndef OUTPUTWIN set (app, MUIA_Application_Sleep, FALSE); #endif } break; #endif case ID_OL_SHOWORDER: /* Auftragsliste drucken */ { struct MinOrder *active; struct Screen *scr; STRPTR name; DoMethod (LV_OL_list, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &active); if (active) { /* Auftrag einlesen */ if (!OL_LoadOrder (active)) { struct MinCustomer cust; char date[12], number[12]; O_GetOrderAddress (&cust); O_GetOrderDate (date); O_GetOrderNumber (number); get (WI_main, MUIA_Window_Screen, &scr); name = GetPublicScreenName (scr); #ifndef OUTPUTWIN set (app, MUIA_Application_Sleep, TRUE); #endif if (!CheckSum (Benutzer, oldchecksum)) P_Print (PRT_MODE_CONFIRMATION, name, O_GetDummyOrderItem, &cust, O_GetOrderItemCount (), number, date, NULL, O_GetMwSt (1), O_GetMwSt (2), TRUE); else P_Print (PRT_MODE_CONFIRMATION, name, O_GetOrderItem, &cust, O_GetOrderItemCount (), number, date, NULL, O_GetMwSt (1), O_GetMwSt (2), TRUE); #ifndef OUTPUTWIN set (app, MUIA_Application_Sleep, FALSE); #endif } else { MUI_Request (app, WI_ordlist, 0, "Fehlermeldung", "OK", "Auftrag laden\n%s", OL_GetErrorMsg ()); } } } break; /* Auftrag */ case ID_O_CUSTOMER: /* Kunden auswählen -> in Kundenliste gehen */ { struct Customer cust; if (C_CheckAbort (FALSE)) { closeCustomerAction = CCA_ORDER; O_GetOrderAddress ((struct MinCustomer *) &cust); InitCustomerWin (cust.KundenNummer); set (WI_customer, MUIA_Window_Title, "Kunde für Auftrag"); set (WI_customer, MUIA_Window_Open, TRUE); } } break; case ID_O_CASH: /* kein Kunde, sondern Barverkauf */ O_SetOrderAddress (&cashcust); set (ST_O_adr1, MUIA_String_Contents, cashcust.Adresse1); set (ST_O_adr2, MUIA_String_Contents, cashcust.Adresse2); set (ST_O_adr3, MUIA_String_Contents, cashcust.Adresse3); set (ST_O_adr4, MUIA_String_Contents, cashcust.Adresse4); set (ST_O_adr5, MUIA_String_Contents, cashcust.Adresse5); set (ST_O_kundennr, MUIA_String_Contents, ""); set (ST_O_zeichen, MUIA_String_Contents, ""); break; case ID_O_LIST: /* Benutzer wählt einen Artikel aus der Liste aus */ O_DisplayArticle (); break; case ID_O_BRUTTONETTO: /* Darstellung Brutto/Netto ändern */ { LONG num, newmode; char buffer[20]; double betrag; STRPTR str; UWORD preistab; get (CY_O_mode, MUIA_Cycle_Active, &newmode); get (CY_O_mwst, MUIA_Cycle_Active, &num); preistab = num + 1; #ifdef ORDER_EK get (ST_O_EKeinzel, MUIA_String_Contents, &str); betrag = ScanMonetary (str); if (CO_GetOrderMwStMode ()) { /* Bruttobetrag in Netto wandeln */ betrag = Brutto2Netto (betrag, O_GetMwSt (preistab)); } DisplayBetrag (buffer, betrag, O_GetMwSt (preistab), newmode); set (ST_O_EKeinzel, MUIA_String_Contents, buffer); #endif get (ST_O_VKeinzel, MUIA_String_Contents, &str); betrag = ScanMonetary (str); if (CO_GetOrderMwStMode ()) { /* Bruttobetrag in Netto wandeln */ betrag = Brutto2Netto (betrag, O_GetMwSt (preistab)); } DisplayBetrag (buffer, betrag, O_GetMwSt (preistab), newmode); set (ST_O_VKeinzel, MUIA_String_Contents, buffer); /* neuen Darstellungsmodus einstellen */ CO_SetOrderMwStMode (newmode); } break; case ID_O_INSERT: /* neuen Artikel in Liste übernehmen */ { struct Article art; LONG num; STRPTR str; double betrag; char buffer[20]; get (ST_O_artnum, MUIA_String_Contents, &str); strcpy (art.Artikelnummer, str); get (ST_O_article, MUIA_String_Contents, &str); strcpy (art.Bezeichnung, str); get (CY_O_mwst, MUIA_Cycle_Active, &num); art.Preistabelle = num + 1; get (ST_O_VKeinzel, MUIA_String_Contents, &str); betrag = ScanMonetary (str); if (CO_GetOrderMwStMode ()) { /* Bruttobetrag in Netto wandeln */ betrag = Brutto2Netto (betrag, O_GetMwSt (art.Preistabelle)); } art.Betrag = betrag; #ifdef ORDER_EK get (ST_O_EKeinzel, MUIA_String_Contents, &str); betrag = ScanMonetary (str); if (CO_GetOrderMwStMode ()) { /* Bruttobetrag in Netto wandeln */ betrag = Brutto2Netto (betrag, O_GetMwSt (art.Preistabelle)); } art.EKBetrag = betrag; #else art.EKBetrag = 0.0; #endif art.Datum[0] = 0; get (ST_O_menge, MUIA_String_Contents, &str); art.Menge = ScanMonetary (str); get (ST_O_firma, MUIA_String_Contents, &str); strcpy (art.Lieferfirma, str); get (ST_O_note, MUIA_String_Contents, &str); strcpy (art.Notiz, str); O_AddOrderItem (&art); // Redraw_O_List(); DoMethod (LV_O_list, MUIM_List_InsertSingle, &art, MUIV_List_Insert_Bottom); set (LV_O_list, MUIA_List_Active, MUIV_List_Active_Bottom); DoMethod (LV_O_list, MUIM_List_Jump, MUIV_List_Jump_Active); O_GetOrderSum (NULL, NULL, NULL, NULL, &betrag); PrintCurrency (buffer, betrag); set (TX_O_summe, MUIA_Text_Contents, buffer); set (WI_order, MUIA_Window_ActiveObject, LV_O_list); } break; case ID_O_CHANGE: /* Artikel in Liste ändern */ { struct Article art; LONG num; STRPTR str; double betrag; char buffer[20]; get (ST_O_artnum, MUIA_String_Contents, &str); strcpy (art.Artikelnummer, str); get (ST_O_article, MUIA_String_Contents, &str); strcpy (art.Bezeichnung, str); get (CY_O_mwst, MUIA_Cycle_Active, &num); art.Preistabelle = num + 1; get (ST_O_VKeinzel, MUIA_String_Contents, &str); betrag = ScanMonetary (str); if (CO_GetOrderMwStMode ()) { /* Bruttobetrag in Netto wandeln */ betrag = Brutto2Netto (betrag, O_GetMwSt (art.Preistabelle)); } art.Betrag = betrag; #ifdef ORDER_EK get (ST_O_EKeinzel, MUIA_String_Contents, &str); betrag = ScanMonetary (str); if (CO_GetOrderMwStMode ()) { /* Bruttobetrag in Netto wandeln */ betrag = Brutto2Netto (betrag, O_GetMwSt (art.Preistabelle)); } art.EKBetrag = betrag; #else art.EKBetrag = 0.0; #endif art.Datum[0] = 0; get (ST_O_menge, MUIA_String_Contents, &str); art.Menge = ScanMonetary (str); get (ST_O_firma, MUIA_String_Contents, &str); strcpy (art.Lieferfirma, str); get (ST_O_note, MUIA_String_Contents, &str); strcpy (art.Notiz, str); O_ChangeOrderItem (&art); Redraw_O_List (); O_GetOrderSum (NULL, NULL, NULL, NULL, &betrag); PrintCurrency (buffer, betrag); set (TX_O_summe, MUIA_Text_Contents, buffer); set (WI_order, MUIA_Window_ActiveObject, LV_O_list); } break; case ID_O_DELETE: /* Artikel aus Liste entfernen */ if (O_CheckAbort (TRUE)) { struct Article *active; double betrag; char buffer[20]; DoMethod (LV_O_list, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &active); if (active) { O_DelOrderItem (); DoMethod (LV_O_list, MUIM_List_Remove, MUIV_List_Remove_Active); DoMethod (LV_O_list, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &active); if (!active) { Clear_O_Inputs (); } } O_GetOrderSum (NULL, NULL, NULL, NULL, &betrag); PrintCurrency (buffer, betrag); set (TX_O_summe, MUIA_Text_Contents, buffer); set (WI_order, MUIA_Window_ActiveObject, LV_O_list); } break; case ID_O_CLEAR: /* Eingabefelder löschen */ if (O_CheckAbort (TRUE)) { Clear_O_Inputs (); set (WI_order, MUIA_Window_ActiveObject, ST_O_artnum); } break; case ID_O_CHOOSE: /* Artikel auswählen -> in Artikelliste gehen */ if (A_CheckAbort (FALSE)) { closeArticleAction = CAA_ORDER; InitArticleWin (); set (REG_A_mode, MUIA_Group_ActivePage, MUIV_Group_ActivePage_First); set (WI_article, MUIA_Window_Title, "Artikel für Auftrag"); set (WI_article, MUIA_Window_Open, TRUE); } break; case ID_O_OK: /* Auftrag speichern */ if (O_CheckAbort (TRUE)) { struct MinOrder minorder; struct MinCustomer cust; STRPTR str; get (ST_O_orddate, MUIA_String_Contents, &str); O_SetOrderDate (str); get (ST_O_adr1, MUIA_String_Contents, &str); strcpy (cust.Adresse1, str); get (ST_O_adr2, MUIA_String_Contents, &str); strcpy (cust.Adresse2, str); get (ST_O_adr3, MUIA_String_Contents, &str); strcpy (cust.Adresse3, str); get (ST_O_adr4, MUIA_String_Contents, &str); strcpy (cust.Adresse4, str); get (ST_O_adr5, MUIA_String_Contents, &str); strcpy (cust.Adresse5, str); get (ST_O_kundennr, MUIA_String_Contents, &str); cust.KundenNummer = atoi (str); get (ST_O_zeichen, MUIA_String_Contents, &str); strcpy (cust.Zeichen, str); O_SetOrderAddress (&cust); O_GetMinOrder (&minorder); if (!O_GetOrderItemCount ()) MUI_Request (app, WI_order, 0, "Fehlermeldung", "OK", "keine Artikel im Auftrag vorhanden!"); else { if (OL_SaveOrder (&minorder)) MUI_Request (app, WI_ordlist, 0, "Fehlermeldung", "OK", "Auftrag speichern\n%s", OL_GetErrorMsg ()); else { switch (closeOrderAction) { case COA_MAIN_EDIT: OL_SetYear (minorder.orderYear); OL_SetCurrentOrderNumber (minorder.orderNumber); OL_ChangeOrder (&minorder); Redraw_OL_List (); break; case COA_MAIN_NEW: /* neuen Eintrag in die Liste einfügen */ OL_SetYear (minorder.orderYear); OL_NewOrder (&minorder); Redraw_OL_List (); break; } set (WI_order, MUIA_Window_Open, FALSE); } } } break; case ID_O_CANCEL: if (O_CheckAbort (FALSE)) { switch (closeOrderAction) { case COA_MAIN_EDIT: case COA_MAIN_NEW: break; } set (WI_order, MUIA_Window_Open, FALSE); } break; } }