/* ** MUI-Rechnung.c - alle Teile für die Rechnungsliste und die Rechnung 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_IL_BASE */ enum { /* Rechnungsliste */ ID_IL_LIST = ID_IL_BASE, /* Listview */ ID_IL_NEWINVOICE, /* Neue Rechnung */ ID_IL_DELINVOICE, /* Rechnung löschen */ ID_IL_EDITINVOICE, /* Rechnung edieren */ ID_IL_PAYINVOICE, /* Rechnung bezahlen */ ID_IL_LOOKORDER, /* Auftrag ansehen */ ID_IL_PRINTINVOICE, /* Rechnung drucken */ ID_IL_SHOWINVOICE, /* Rechnung ansehen */ ID_IL_PRINTLIST, /* Rechnungsliste drucken */ ID_IL_SELECTYEAR, /* Jahrgang wählen */ ID_IL_SELECTFILTER, /* Filter für Liste wählen */ /* Rechnung */ ID_I_OK, /* Änderung der Rechnung übernehmen */ ID_I_CANCEL, /* Abbruch */ ID_I_LIST, /* die Artikelliste in Rechnung wurde gewählt */ ID_I_CASH, /* kein Kunde, sondern Barverkauf */ ID_I_CUSTOMER, /* wähle Kunden aus Kundenliste für Rechnung */ ID_I_BRUTTONETTO, /* Modus für Darstellung Brutto/Netto */ ID_I_INSERT, /* neuen Artikel in Liste einfügen */ ID_I_CHANGE, /* Artikel in Liste ändern */ ID_I_DELETE, /* Artikel aus Liste löschen */ ID_I_CLEAR, /* lösche alle Eingabegadgets */ ID_I_CHOOSE, /* wähle Artikel aus Artikelliste */ ID_I_TODAY, /* heutiges Datum für Bezahlung eintragen */ ID_I_PAYALL, /* alles zahlen: in Stringgadget eintragen */ }; /********************************************************************* ** ** ** R E C H N U N G S L I S T E ** ** *********************************************************************/ /* Cycle Strings */ static char *CYA_IL_year[MAX_YEARS + 1]; /* Cycle-Array für MUI */ static char CYA_IL_year_buffer[5 * MAX_YEARS]; /* Puffer für Jahreszahlen */ static char *CYA_IL_mode[] = {"alle Rechnungen", /* DISP_IL_ALL */ "offene Rechnungen", /* DISP_IL_PAY */ "nicht gedruckte Rechnungen", /* DISP_IL_PRT */ NULL}; /* Ausgabemöglichkeiten für den DisplayHook */ enum { DISP_IL_ALL, DISP_IL_PAY, DISP_IL_PRT }; /* Gadgets der "Rechnungsliste" */ APTR CY_IL_year, CY_IL_mode; APTR LV_IL_list; APTR BT_IL_new, BT_IL_del, BT_IL_edit, BT_IL_lookord; APTR BT_IL_pay, BT_IL_prtinv, BT_IL_prtlist, BT_IL_showinv; /* ** Cycle-Gadget Jahreszahlen der Rechnungsliste: ** baue das String-Array für das Cycle-Gadget auf. */ void Build_IL_years (void) { UWORD i; UWORD year; i = IL_GetYearCount (); for (i = 0; i < IL_GetYearCount () && i < MAX_YEARS; i++) { IL_GetYear (i, &year); sprintf (&CYA_IL_year_buffer[5 * i], "%04d", year); CYA_IL_year[i] = &CYA_IL_year_buffer[5 * i]; } CYA_IL_year[i] = NULL; } /* ** Support-Funktionen für die "Rechnungsliste" ** ** MUI verwaltet eine eigene Liste, die intern alle Daten aufnimmt ** und über eine DisplayFunc am Bildschirm angezeigt wird. */ SAVEDS ASM APTR IL_ConstructFunc (REG (a1) struct MinInvoice *invoice, REG (a2) void *mempool) { struct MinInvoice *newitem; if (newitem = LibAllocPooled (mempool, sizeof (struct MinInvoice))) { newitem->invoiceNumber = invoice->invoiceNumber; newitem->invoiceYear = invoice->invoiceYear; strcpy (newitem->invoiceDate, invoice->invoiceDate); strcpy (newitem->Kunde, invoice->Kunde); newitem->orderNumber = invoice->orderNumber; newitem->orderYear = invoice->orderYear; strcpy (newitem->orderDate, invoice->orderDate); newitem->payment = invoice->payment; newitem->sum = invoice->sum; strcpy (newitem->payDate, invoice->payDate); } return ((APTR) newitem); } SAVEDS ASM VOID IL_DestructFunc (REG (a1) struct MinInvoice * invoice, REG (a2) void *mempool) { LibFreePooled (mempool, invoice, sizeof (struct MinInvoice)); } SAVEDS ASM LONG IL_DisplayFunc_All (REG (a2) char **array, REG (a1) struct MinInvoice *invoice) { static char buf1[30], buf2[30]; if (invoice) { /* zeige den Eintrag an. */ sprintf (buf1, "%04d/%d (%s)", invoice->invoiceYear, invoice->invoiceNumber, invoice->invoiceDate); *array++ = buf1; if (invoice->payment + 0.02 >= invoice->sum) { sprintf (buf2, "(%s)", invoice->payDate); *array++ = buf2; } else *array++ = ""; *array = invoice->Kunde; } else { /* zeige die Titel-Zeile an. */ *array++ = "\033bRechnung"; *array++ = "\033bBezahlt"; *array = "\033bKunde"; } return (0); } SAVEDS ASM LONG IL_DisplayFunc_Pay (REG (a2) char **array, REG (a1) struct MinInvoice * invoice) { static char buf1[30], buf2[30], buf3[30]; if (invoice) { /* zeige den Eintrag an. */ sprintf (buf1, "%04d/%d (%s)", invoice->invoiceYear, invoice->invoiceNumber, invoice->invoiceDate); *array++ = buf1; strcpy (buf2, "\033r"); PrintCurrency (&buf2[2], invoice->sum); *array++ = buf2; strcpy (buf3, "\033r"); PrintCurrency (&buf3[2], invoice->payment); *array++ = buf3; *array = invoice->Kunde; } else { /* zeige die Titel-Zeile an. */ *array++ = "\033bRechnung"; *array++ = "\033bBetrag"; *array++ = "\033bBezahlt"; *array = "\033bKunde"; } return (0); } SAVEDS ASM LONG IL_DisplayFunc_Prt (REG (a2) char **array, REG (a1) struct MinInvoice * invoice) { static char buf1[30]; if (invoice) { /* zeige den Eintrag an. */ sprintf (buf1, "%04d/%d (%s)", invoice->invoiceYear, invoice->invoiceNumber, invoice->invoiceDate); *array++ = buf1; *array = invoice->Kunde; } else { /* zeige die Titel-Zeile an. */ *array++ = "\033bRechnung"; *array = "\033bKunde"; } return (0); } /* Hooks für Auftragsliste */ static struct Hook IL_ConstructHook = { {NULL, NULL}, (VOID *) IL_ConstructFunc, NULL, NULL}; static struct Hook IL_DestructHook = { {NULL, NULL}, (VOID *) IL_DestructFunc, NULL, NULL}; static struct Hook IL_DisplayHook_All = { {NULL, NULL}, (VOID *) IL_DisplayFunc_All, NULL, NULL}; static struct Hook IL_DisplayHook_Pay = { {NULL, NULL}, (VOID *) IL_DisplayFunc_Pay, NULL, NULL}; static struct Hook IL_DisplayHook_Prt = { {NULL, NULL}, (VOID *) IL_DisplayFunc_Prt, NULL, NULL}; /* ** Beim Verändern der Einstellungen für die Rechnungsliste muß diese komplett ** neu aufgebaut werden. Der alte Inhalt wird gelöscht und je nach Modus ** die entsprechenden Einträge neu eingefügt. ** ** Es werden auch andere DisplayHooks verwendet, da verschiedene Daten ** angezeigt werden. */ void Redraw_IL_List (void) { UWORD year, actnum; int i, j, active; LONG mode, cyear; struct MinInvoice mininvoice; get (CY_IL_year, MUIA_Cycle_Active, &cyear); get (CY_IL_mode, MUIA_Cycle_Active, &mode); year = atoi (&CYA_IL_year_buffer[5 * cyear]); IL_SetYear (year); set (LV_IL_list, MUIA_List_Quiet, TRUE); DoMethod (LV_IL_list, MUIM_List_Clear); actnum = IL_GetCurrentInvoiceNumber (); active = -1; switch (mode) { case DISP_IL_ALL: set (LV_IL_list, MUIA_List_DisplayHook, &IL_DisplayHook_All); set (LV_IL_list, MUIA_List_Format, "D=8,D=8,"); for (j = 0, i = 0; i < IL_GetInvoiceCount (); i++) { IL_GetInvoice (i, &mininvoice); if (mininvoice.invoiceNumber == actnum) active = j; DoMethod (LV_IL_list, MUIM_List_InsertSingle, &mininvoice, MUIV_List_Insert_Bottom); j++; } break; case DISP_IL_PAY: set (LV_IL_list, MUIA_List_DisplayHook, &IL_DisplayHook_Pay); set (LV_IL_list, MUIA_List_Format, "D=8,D=8,D=8,"); for (j = 0, i = 0; i < IL_GetInvoiceCount (); i++) { IL_GetInvoice (i, &mininvoice); if (mininvoice.invoiceNumber == actnum) active = j; if (mininvoice.payment + 0.02 < mininvoice.sum) { DoMethod (LV_IL_list, MUIM_List_InsertSingle, &mininvoice, MUIV_List_Insert_Bottom); j++; } } break; case DISP_IL_PRT: set (LV_IL_list, MUIA_List_DisplayHook, &IL_DisplayHook_Prt); set (LV_IL_list, MUIA_List_Format, "D=8,"); for (j = 0, i = 0; i < IL_GetInvoiceCount (); i++) { IL_GetInvoice (i, &mininvoice); if (mininvoice.invoiceNumber == actnum) active = j; if (mininvoice.printDate[0] == 0) { DoMethod (LV_IL_list, MUIM_List_InsertSingle, &mininvoice, MUIV_List_Insert_Bottom); j++; } } break; } /* j ist die Anzahl der Einträge in der MUI-Liste */ if (j == 0) { set (LV_IL_list, MUIA_List_Quiet, FALSE); } else { set (LV_IL_list, MUIA_List_Active, active); set (LV_IL_list, MUIA_List_Quiet, FALSE); DoMethod (LV_IL_list, MUIM_List_Jump, MUIV_List_Jump_Active); } } APTR MUI_BuildInvoiceList (void) { #ifdef DEBUG printf ("in BuildInvoiceList()\n"); #endif return (VGroup, Child, HGroup, Child, CY_IL_year = Cycle (CYA_IL_year), Child, CY_IL_mode = Cycle (CYA_IL_mode), End, Child, LV_IL_list = ListviewObject, MUIA_Listview_List, ListObject, InputListFrame, MUIA_List_ConstructHook, &IL_ConstructHook, MUIA_List_DestructHook, &IL_DestructHook, MUIA_List_DisplayHook, &IL_DisplayHook_All, MUIA_List_Format, "D=8,D=8,", MUIA_List_Title, TRUE, End, End, Child, HGroup, Child, BT_IL_new = KeyButton ("Neu", 'n'), Child, BT_IL_del = KeyButton ("Löschen", 'l'), Child, BT_IL_edit = KeyButton ("Edieren", 'e'), End, Child, ColGroup (2), Child, BT_IL_lookord = KeyButton ("Auftrag ansehen", 'r'), Child, BT_IL_pay = KeyButton ("Rechnung bezahlen", 'b'), Child, BT_IL_prtinv = KeyButton ("Rechnung drucken", 'd'), Child, BT_IL_showinv = KeyButton ("Rechnungsvorschau...", 'g'), End, Child, BT_IL_prtlist = KeyButton ("Rechnungsliste drucken", 'i'), End); } /********************************************************************* ** ** ** R E C H N U N G ** ** *********************************************************************/ APTR TX_I_invnum, ST_I_invdate, TX_I_summe, REG_I_pages, BT_I_cash; APTR BT_I_payall; APTR BT_I_customer, ST_I_adr1, ST_I_adr2, ST_I_adr3, ST_I_adr4, ST_I_adr5; APTR ST_I_kundennr, ST_I_zeichen; APTR LV_I_list, BT_I_insert, BT_I_change, BT_I_delete; APTR ST_I_artnum, BT_I_choose, BT_I_clear; APTR ST_I_article, ST_I_einzel, ST_I_menge, CY_I_mwst, CY_I_mode; APTR TX_I_orddate, TX_I_ordnum; APTR CY_I_pay, ST_I_pay, ST_I_paydate, BT_I_today; APTR BT_I_ok, BT_I_cancel; static char *InvoicePages[] = {"Kunde", "Rechnung", "Bezahlung, Info", NULL}; static char *CYA_pay[] = {"Barzahlung", /* PAY_BAR */ "Banküberweisung", /* PAY_BANK */ "Nachnahme", /* PAY_NACHNAHME */ "Lieferschein", /* PAY_LIEFERSCHEIN */ NULL}; /* ** Support-Funktionen für die "Rechnung" ** ** MUI verwaltet eine eigene Liste, die intern alle Daten aufnimmt ** und über eine DisplayFunc am Bildschirm angezeigt wird. */ SAVEDS ASM APTR I_ConstructFunc (REG (a1) struct MinArticle *article, REG (a2) void *mempool) { struct Article *newitem; if (newitem = LibAllocPooled (mempool, sizeof (struct MinArticle))) { 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 I_DestructFunc (REG (a1) struct MinArticle * article, REG (a2) void *mempool) { LibFreePooled (mempool, article, sizeof (struct MinArticle)); } SAVEDS ASM LONG I_DisplayFunc (REG (a2) char **array, REG (a1) struct MinArticle *article) { static char buf2[30], buf3[24], buf4[20], 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], I_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 Rechnung */ static struct Hook I_ConstructHook = { {NULL, NULL}, (VOID *) I_ConstructFunc, NULL, NULL}; static struct Hook I_DestructHook = { {NULL, NULL}, (VOID *) I_DestructFunc, NULL, NULL}; static struct Hook I_DisplayHook = { {NULL, NULL}, (VOID *) I_DisplayFunc, NULL, NULL}; /* Cycle-Array mit den Mehrwertsteuersätzen, die pro Rechnung neu eingestellt ** werden können. */ static char CYA_I_MwSt1_buffer[12]; /* Puffer für MwSt-Strings */ static char CYA_I_MwSt2_buffer[12]; /* Puffer für MwSt-Strings */ static char *CYA_I_MwSt[] = {CYA_I_MwSt1_buffer, CYA_I_MwSt2_buffer, NULL}; /* von wo aus wurde das Fenster geöffnet, d.h. ** was passiert, wenn die Rechnung geschlossen wird */ UWORD closeInvoiceAction; /* lösche die Eingabefelder für einen neuen Artikel */ void Clear_I_Inputs (void) { char buffer[20]; set (ST_I_artnum, MUIA_String_Contents, ""); set (ST_I_article, MUIA_String_Contents, ""); I_GetInvoiceDate (buffer); set (ST_I_invdate, MUIA_String_Contents, buffer); set (ST_I_menge, MUIA_String_Contents, "1"); PrintCurrency (buffer, 0.0); set (ST_I_einzel, MUIA_String_Contents, buffer); set (CY_I_mwst, MUIA_Cycle_Active, 0); } /* ** prüfe, ob die Rechnung abgebrochen werden darf. Gib evtl. Requester aus. ** ** Rückgabe: ** ** TRUE - es darf abgebrochen werden. ** FALSE - nicht abbrechen, Rechnung weiter edieren */ BOOL I_CheckAbort (BOOL endok) { BOOL abort = TRUE; LONG isopen; char buffer[20]; struct MinArticle article; struct MinCustomer cust; BOOL diff = FALSE; LONG num; STRPTR str; float betrag; I_GetInvoiceNumber (buffer); get (WI_invoice, MUIA_Window_Open, &isopen); if (isopen) { article.Artikelnummer[0] = 0; article.Bezeichnung[0] = 0; article.Preistabelle = 1; article.Betrag = 0.0; I_GetCurrentItem (&article); get (ST_I_artnum, MUIA_String_Contents, &str); diff |= (strcmp (article.Artikelnummer, str) != 0); get (ST_I_article, MUIA_String_Contents, &str); diff |= (strcmp (article.Bezeichnung, str) != 0); get (CY_I_mwst, MUIA_Cycle_Active, &num); diff |= (article.Preistabelle != num + 1); get (ST_I_einzel, MUIA_String_Contents, &str); betrag = ScanMonetary (str); if (CO_GetInvoiceMwStMode ()) { /* Bruttobetrag in Netto wandeln */ betrag = Brutto2Netto (betrag, I_GetMwSt (article.Preistabelle)); } diff |= (abs (article.Betrag - betrag) > 0.01); if (!endok) { /* check address */ I_GetInvoiceAddress (&cust); get (ST_I_adr1, MUIA_String_Contents, &str); diff |= (strcmp (cust.Adresse1, str) != 0); get (ST_I_adr2, MUIA_String_Contents, &str); diff |= (strcmp (cust.Adresse2, str) != 0); get (ST_I_adr3, MUIA_String_Contents, &str); diff |= (strcmp (cust.Adresse3, str) != 0); get (ST_I_adr4, MUIA_String_Contents, &str); diff |= (strcmp (cust.Adresse4, str) != 0); get (ST_I_adr5, MUIA_String_Contents, &str); diff |= (strcmp (cust.Adresse5, str) != 0); get (ST_I_kundennr, MUIA_String_Contents, &str); diff |= (cust.KundenNummer != atoi (str)); get (ST_I_zeichen, MUIA_String_Contents, &str); diff |= (strcmp (cust.Zeichen, str) != 0); } diff = FALSE; if (diff && !MUI_Request (app, WI_invoice, 0, "Eingabe in Rechnung abbrechen...", "Verwerfen|Zurück", "\033cDie Eingabefelder in der Rechnung wurden verändert.\n" "Wollen Sie Ihre Änderungen wirklich verwerfen?")) { abort = FALSE; } if (!endok && abort) { if (I_GetStatus () && !MUI_Request (app, WI_invoice, 0, "Rechnung abbrechen...", "Verwerfen|Zurück", "\033cDie Rechnung %s wurde verändert.\n" "Wollen Sie Ihre Änderungen wirklich verwerfen?", buffer)) abort = FALSE; } if (abort) { /* 3.3.96, ss: wenn abgebrochen wird, dann muß die Rechnung */ /* nochmals geladen und gespeichert werden, damit die Mengen */ /* in der Artikelliste korrigiert werden. */ /* Laden ohne zu ändern und speichern mit Änderung */ IL_CorrectArticleCount (); IL_ResetLastLoaded (); } } if (abort && (closeCustomerAction == CCA_INVOICE)) { set (WI_customer, MUIA_Window_Title, "Adreßliste"); closeCustomerAction = CCA_MAIN; } if (abort && (closeArticleAction == CAA_INVOICE)) { set (WI_article, MUIA_Window_Title, "Artikelliste"); closeArticleAction = CAA_MAIN; } return (abort); } /* zeige einen Artikel in den Gadgets an */ void I_DisplayArticle (void) { LONG num; char buffer[20]; struct Article article; struct Article *active; DoMethod (LV_I_list, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &active); if (active) { get (LV_I_list, MUIA_List_Active, &num); I_SetCurrentItemNumber (num); I_GetCurrentItem ((struct MinArticle *) &article); set (ST_I_artnum, MUIA_String_Contents, article.Artikelnummer); set (ST_I_article, MUIA_String_Contents, article.Bezeichnung); PrintMonetary (buffer, article.Menge); set (ST_I_menge, MUIA_String_Contents, buffer); DisplayBetrag (buffer, article.Betrag, I_GetMwSt (article.Preistabelle), CO_GetInvoiceMwStMode ()); set (ST_I_einzel, MUIA_String_Contents, buffer); set (CY_I_mwst, MUIA_Cycle_Active, article.Preistabelle - 1); } } /* Neuaufbau der Liste in der Rechnung */ void Redraw_I_List (void) { struct Article art; int i; set (LV_I_list, MUIA_List_Quiet, TRUE); DoMethod (LV_I_list, MUIM_List_Clear); for (i = 0; i < I_GetInvoiceItemCount (); i++) { I_GetInvoiceItem (i, (struct MinArticle *) &art); DoMethod (LV_I_list, MUIM_List_InsertSingle, &art, MUIV_List_Insert_Bottom); } if (i == 0) { set (LV_I_list, MUIA_List_Quiet, FALSE); } else { set (LV_I_list, MUIA_List_Quiet, FALSE); set (LV_I_list, MUIA_List_Active, I_GetCurrentItemNumber ()); DoMethod (LV_I_list, MUIM_List_Jump, MUIV_List_Jump_Active); } } /* vor dem Öffnen werden die Daten aus dem Rechnungs-Modul in die ** MUI-Oberfläche übertragen.. */ void InitInvoiceWin (void) { struct MinCustomer mincust; struct MinInvoice mininvoice; char buffer[20]; double betrag; UWORD mode; /* allgemeine Daten */ I_GetMinInvoice (&mininvoice); set (ST_I_invdate, MUIA_String_Contents, mininvoice.invoiceDate); I_GetInvoiceNumber (buffer); set (TX_I_invnum, MUIA_Text_Contents, buffer); /* MwSt-Sätze für Cycle-Gadget erstellen */ PrintMonetary (CYA_I_MwSt1_buffer, I_GetMwSt (1)); PrintMonetary (CYA_I_MwSt2_buffer, I_GetMwSt (2)); strcat (CYA_I_MwSt1_buffer, "%"); strcat (CYA_I_MwSt2_buffer, "%"); /* Kundenseite */ I_GetInvoiceAddress (&mincust); set (ST_I_adr1, MUIA_String_Contents, mincust.Adresse1); set (ST_I_adr2, MUIA_String_Contents, mincust.Adresse2); set (ST_I_adr3, MUIA_String_Contents, mincust.Adresse3); set (ST_I_adr4, MUIA_String_Contents, mincust.Adresse4); set (ST_I_adr5, MUIA_String_Contents, mincust.Adresse5); if (mincust.KundenNummer) { sprintf (buffer, "%d", mincust.KundenNummer); set (ST_I_kundennr, MUIA_String_Contents, buffer); } else set (ST_I_kundennr, MUIA_String_Contents, ""); set (ST_I_zeichen, MUIA_String_Contents, mincust.Zeichen); /* Rechnungsseite */ Redraw_I_List (); Clear_I_Inputs (); /* auf jeden Fall ein Wechsel -> strings OK */ set (CY_I_mwst, MUIA_Cycle_Active, 1); set (CY_I_mwst, MUIA_Cycle_Active, 0); /* sonstige Seite */ if (mininvoice.orderYear && mininvoice.orderNumber) { set (TX_I_orddate, MUIA_Text_Contents, mininvoice.orderDate); I_GetOrderNumber (buffer); set (TX_I_ordnum, MUIA_Text_Contents, buffer); } else { set (TX_I_orddate, MUIA_Text_Contents, ""); set (TX_I_ordnum, MUIA_Text_Contents, ""); } /* Bezahlung */ I_GetPayment (&betrag, buffer, &mode); set (CY_I_pay, MUIA_Cycle_Active, mode); set (ST_I_paydate, MUIA_String_Contents, buffer); PrintCurrency (buffer, betrag); set (ST_I_pay, MUIA_String_Contents, buffer); I_GetInvoiceSum (NULL, NULL, NULL, NULL, &betrag); PrintCurrency (buffer, betrag); set (TX_I_summe, MUIA_Text_Contents, buffer); } APTR MUI_BuildInvoice (void) { #ifdef DEBUG printf ("in BuildInvoice()\n"); #endif return (VGroup, Child, HGroup, Child, Label2 ("Rechnungsnummer:"), Child, TX_I_invnum = TextObject, TextFrame, MUIA_Background, MUII_TextBack, MUIA_HorizWeight, 20, End, Child, Label2 ("Rechnungsdatum:"), Child, ST_I_invdate = String ("", 16), Child, Label2 ("Summe:"), Child, TX_I_summe = TextObject, TextFrame, MUIA_Background, MUII_TextBack, MUIA_HorizWeight, 20, End, End, Child, REG_I_pages = RegisterGroup (InvoicePages), MUIA_Register_Frame, TRUE, /* Register "Kunde" */ Child, VGroup, GroupFrameT ("Kunde"), MUIA_HelpNode, "invoicecust-register", Child, HGroup, Child, BT_I_customer = KeyButton ("Adresse auswählen...", 'a'), Child, BT_I_cash = KeyButton ("Barverkauf", 'b'), End, Child, ColGroup (2), Child, KeyLabel2 ("Anrede:", 'r'), Child, HGroup, Child, ST_I_adr1 = KeyString ("", 80, 'r'), Child, KeyLabel2 ("Zeichen:", 'z'), Child, ST_I_zeichen = KeyString ("", 20, 'z'), Child, KeyLabel2 ("Kundennr:", 'k'), Child, ST_I_kundennr = KeyString ("", 20, 'k'), End, Child, KeyLabel2 ("Adresse:", 'd'), Child, ST_I_adr2 = KeyString ("", 80, 'd'), Child, Label2 (""), Child, ST_I_adr3 = String ("", 80), Child, Label2 (""), Child, ST_I_adr4 = String ("", 80), Child, Label2 (""), Child, ST_I_adr5 = String ("", 80), End, End, /* Register "Rechnung" */ Child, VGroup, MUIA_HelpNode, "invoiceinv-register", Child, LV_I_list = ListviewObject, MUIA_Listview_List, ListObject, InputListFrame, MUIA_List_ConstructHook, &I_ConstructHook, MUIA_List_DestructHook, &I_DestructHook, MUIA_List_DisplayHook, &I_DisplayHook, MUIA_List_Format, "D=8,D=8,D=8,D=8,D=8,", MUIA_List_Title, TRUE, End, End, Child, HGroup, Child, BT_I_insert = KeyButton ("Einfügen", 'e'), Child, BT_I_change = KeyButton ("Ändern", 'ä'), Child, BT_I_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'), End, Child, VGroup, Child, HGroup, Child, ST_I_artnum = KeyString ("", 80, 'a'), Child, BT_I_choose = KeyButton ("Artikel wählen...", 'w'), Child, BT_I_clear = KeyButton ("Neu", 'n'), End, Child, ST_I_article = KeyString ("", 80, 'b'), Child, ColGroup (3), Child, ST_I_einzel = KeyMonetaryString ("", 20, 'v'), Child, KeyLabel2 ("Menge:", 'm'), Child, ST_I_menge = KeyString ("", 10, 'm'), Child, CY_I_mwst = KeyCycle (CYA_I_MwSt, 's'), Child, KeyLabel2 ("Eingabe:", 'i'), Child, CY_I_mode = KeyCycle (CYA_BruttoNetto, 'i'), End, End, End, End, /* Register "Sonstiges" */ Child, VGroup, MUIA_HelpNode, "invoicemisc-register", Child, VGroup, GroupFrameT ("Auftrag"), Child, ColGroup (2), Child, Label2 ("Auftragsdatum:"), Child, TX_I_orddate = TextObject, TextFrame, MUIA_Background, MUII_TextBack, End, Child, Label2 ("Auftragsnummer:"), Child, TX_I_ordnum = TextObject, TextFrame, MUIA_Background, MUII_TextBack, End, End, End, Child, ColGroup (2), GroupFrameT ("Bezahlung"), Child, VGroup, Child, KeyLabel2 ("Zahlungsart:", 'z'), Child, KeyLabel2 ("bezahlter Betrag:", 'b'), Child, KeyLabel2 ("Datum:", 'd'), End, Child, VGroup, Child, CY_I_pay = KeyCycle (CYA_pay, 'z'), Child, ColGroup (2), Child, ST_I_pay = KeyMonetaryString ("", 20, 'b'), Child, BT_I_payall = KeyButton ("Alles", 'a'), Child, ST_I_paydate = KeyDateString ("", 20, 'd'), Child, BT_I_today = KeyButton ("Heute", 'h'), End, End, End, End, End, Child, HGroup, Child, BT_I_ok = KeyButton ("OK", 'o'), Child, BT_I_cancel = KeyButton ("Abbruch", 'u'), End, End); } /* ** nachdem die MUI aufgebaut ist, müssen noch einige Methoden eingebaut ** werden. Diese Funktion wird vom Hauptprogramm aufgerufen. */ void DoInvoiceMethods (void) { /* Rechnung */ DoMethod (WI_invoice, MUIM_Notify, MUIA_Window_InputEvent, "rawkey -capslock -shift right", REG_I_pages, 3, MUIM_Set, MUIA_Group_ActivePage, MUIV_Group_ActivePage_Next); DoMethod (WI_invoice, MUIM_Notify, MUIA_Window_InputEvent, "rawkey -capslock -shift left", REG_I_pages, 3, MUIM_Set, MUIA_Group_ActivePage, MUIV_Group_ActivePage_Prev); DoMethod (LV_I_list, MUIM_Notify, MUIA_List_Active, MUIV_EveryTime, app, 2, MUIM_Application_ReturnID, ID_I_LIST); DoMethod (WI_invoice, MUIM_Notify, MUIA_Window_CloseRequest, TRUE, app, 2, MUIM_Application_ReturnID, ID_I_CANCEL); DoMethod (BT_I_ok, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_I_OK); DoMethod (BT_I_payall, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_I_PAYALL); DoMethod (BT_I_cancel, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_I_CANCEL); DoMethod (BT_I_customer, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_I_CUSTOMER); DoMethod (BT_I_cash, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_I_CASH); DoMethod (CY_I_mode, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, app, 2, MUIM_Application_ReturnID, ID_I_BRUTTONETTO); set (CY_I_mode, MUIA_Cycle_Active, CO_GetInvoiceMwStMode ()); /* 16.4.95: ghost the cycle gadget */ if (CO_GetIsNetto ()) set (CY_I_mode, MUIA_Disabled, TRUE); DoMethod (BT_I_insert, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_I_INSERT); DoMethod (BT_I_change, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_I_CHANGE); DoMethod (BT_I_delete, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_I_DELETE); DoMethod (BT_I_clear, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_I_CLEAR); DoMethod (BT_I_choose, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_I_CHOOSE); DoMethod (BT_I_today, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_I_TODAY); DoMethod (WI_invoice, MUIM_Window_SetCycleChain, ST_I_adr1, ST_I_zeichen, ST_I_kundennr, ST_I_adr2, ST_I_adr3, ST_I_adr4, ST_I_adr5, LV_I_list, ST_I_artnum, ST_I_article, ST_I_einzel, ST_I_menge, CY_I_mwst, CY_I_pay, ST_I_pay, ST_I_paydate, NULL); /* Rechnungsliste */ DoMethod (WI_invlist, MUIM_Notify, MUIA_Window_CloseRequest, TRUE, WI_invlist, 3, MUIM_Set, MUIA_Window_Open, FALSE); DoMethod (WI_invlist, MUIM_Notify, MUIA_Window_Open, TRUE, WI_invlist, 3, MUIM_Set, MUIA_Window_ActiveObject, LV_IL_list); DoMethod (LV_IL_list, MUIM_Notify, MUIA_List_Active, MUIV_EveryTime, app, 2, MUIM_Application_ReturnID, ID_IL_LIST); DoMethod (LV_IL_list, MUIM_Notify, MUIA_Listview_DoubleClick, TRUE, app, 2, MUIM_Application_ReturnID, ID_IL_EDITINVOICE); DoMethod (BT_IL_new, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_IL_NEWINVOICE); DoMethod (BT_IL_del, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_IL_DELINVOICE); DoMethod (BT_IL_edit, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_IL_EDITINVOICE); DoMethod (BT_IL_pay, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_IL_PAYINVOICE); DoMethod (BT_IL_lookord, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_IL_LOOKORDER); DoMethod (BT_IL_prtinv, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_IL_PRINTINVOICE); DoMethod (BT_IL_showinv, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_IL_SHOWINVOICE); DoMethod (BT_IL_prtlist, MUIM_Notify, MUIA_Pressed, FALSE, app, 2, MUIM_Application_ReturnID, ID_IL_PRINTLIST); DoMethod (CY_IL_year, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, app, 2, MUIM_Application_ReturnID, ID_IL_SELECTYEAR); DoMethod (CY_IL_mode, MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime, app, 2, MUIM_Application_ReturnID, ID_IL_SELECTFILTER); set (CY_IL_year, MUIA_Cycle_Active, IL_GetCurrentYearNumber ()); set (CY_IL_mode, MUIA_Cycle_Active, CO_GetInvoiceMode ()); } /* ** Falls InputEvents für die Rechnung(sliste) ankommen, werden sie über ** diese Funktion ausgewertet. */ void HandleInvoiceEvents (ULONG event) { /* Rechnungsliste */ switch (event) { case ID_IL_LIST: /* Benutzer wählt eine Rechnung aus der Liste aus */ { struct MinInvoice *active; DoMethod (LV_IL_list, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &active); if (active) { /* Button Auftrag ändern */ if (active->orderYear && active->orderNumber) set (BT_IL_lookord, MUIA_Disabled, FALSE); else set (BT_IL_lookord, MUIA_Disabled, TRUE); /* Button Bezahlung ändern */ if (active && (active->payment + 0.02 < active->sum)) set (BT_IL_pay, MUIA_Disabled, FALSE); else set (BT_IL_pay, MUIA_Disabled, TRUE); IL_SetCurrentInvoiceNumber (active->invoiceNumber); } } break; case ID_IL_SELECTYEAR: case ID_IL_SELECTFILTER: /* Jahrgang, Filter neu eingestellt: Liste neu aufbauen */ Redraw_IL_List (); /* in alten Jahrgängen keine neuen Rechnungen erstellen lassen */ if (IL_GetCurrentYear () < GetThisYear ()) set (BT_IL_new, MUIA_Disabled, TRUE); else set (BT_IL_new, MUIA_Disabled, FALSE); break; case ID_IL_NEWINVOICE: { char buf[16]; if (I_CheckAbort (FALSE)) { closeInvoiceAction = CIA_MAIN_NEW; /* Rechnung intern neu aufbauen */ I_NewInvoice (); IL_ResetLastLoaded (); sprintf (buf, "%04d/%d", IL_GetCurrentYear (), IL_GetNextInvoiceNumber ()); I_SetInvoiceNumber (buf); I_SetMwSt (CO_GetMwSt1 (), CO_GetMwSt2 ()); I_SetInvoiceAddress (&cashcust); InitInvoiceWin (); set (WI_invoice, MUIA_Window_Open, TRUE); } } break; case ID_IL_DELINVOICE: /* aktuelle Rechnung löschen */ { struct MinInvoice *active; DoMethod (LV_IL_list, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &active); if (active) { struct MinInvoice comp; BOOL del = TRUE, abort = FALSE; I_GetMinInvoice (&comp); if ((active->invoiceYear == comp.invoiceYear) && (active->invoiceNumber == comp.invoiceNumber)) abort = TRUE; if (abort && !I_CheckAbort (FALSE)) del = FALSE; if (abort && del) set (WI_invoice, MUIA_Window_Open, FALSE); if (del) { if (MUI_Request (app, WI_invlist, 0, "Rechnung löschen...", "Löschen|Abbruch", "\033cWollen Sie die Rechnung\n" "'%04ld/%ld %s'\nwirklich löschen?", active->invoiceYear, active->invoiceNumber, active->Kunde)) { /* 3.3.96, ss: korrektur Menge */ IL_LoadInvoice (active, TRUE); IL_DelInvoice (); Redraw_IL_List (); } } } } break; case ID_IL_EDITINVOICE: /* aktuelle Rechnung edieren */ { struct MinInvoice *active; if (I_CheckAbort (FALSE)) { closeInvoiceAction = CIA_MAIN_EDIT; DoMethod (LV_IL_list, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &active); if (active) { /* Rechnung einlesen */ if (!IL_LoadInvoice (active, TRUE)) { /* Rechnungsfenster vorbereiten */ InitInvoiceWin (); set (WI_invoice, MUIA_Window_Open, TRUE); } else { MUI_Request (app, WI_invlist, 0, "Fehlermeldung", "OK", "Rechnung laden\n%s", IL_GetErrorMsg ()); } } } } break; case ID_IL_LOOKORDER: /* Auftrag ansehen */ { struct MinInvoice *active; if (O_CheckAbort (FALSE)) { closeOrderAction = COA_MAIN_EDIT; DoMethod (LV_IL_list, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &active); if (active && active->orderYear && active->orderNumber) { struct MinOrder item; OL_SetYear (active->invoiceYear); if (!OL_SetCurrentOrderNumber (active->orderNumber)) { OL_GetCurrentOrder (&item); /* Auftrag einlesen */ if (!OL_LoadOrder (&item)) { /* Auftragsfenster vorbereiten */ InitOrderWin (); set (WI_order, MUIA_Window_Open, TRUE); } else { MUI_Request (app, WI_invlist, 0, "Fehlermeldung", "OK", "Auftrag laden\n%s", OL_GetErrorMsg ()); } } Redraw_OL_List (); } } } break; case ID_IL_PAYINVOICE: /* aktuelle Rechnung bezahlen */ { struct MinInvoice *active; if (I_CheckAbort (FALSE)) { closeInvoiceAction = CIA_MAIN_EDIT; DoMethod (LV_IL_list, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &active); if (active) { /* Rechnung einlesen */ if (!IL_LoadInvoice (active, TRUE)) { /* Rechnungsfenster vorbereiten */ InitInvoiceWin (); set (REG_I_pages, MUIA_Group_ActivePage, MUIV_Group_ActivePage_Last); set (WI_invoice, MUIA_Window_Open, TRUE); } else { MUI_Request (app, WI_invlist, 0, "Fehlermeldung", "OK", "Rechung laden\n%s", IL_GetErrorMsg ()); } } } } break; case ID_IL_PRINTINVOICE: /* Rechnung drucken */ { struct MinInvoice *active; STRPTR name; struct Screen *scr; if (I_CheckAbort (FALSE)) { closeInvoiceAction = CIA_MAIN_EDIT; set (WI_invoice, MUIA_Window_Open, FALSE); DoMethod (LV_IL_list, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &active); if (active) { /* Rechnung einlesen */ if (!IL_LoadInvoice (active, FALSE)) { struct MinCustomer cust; char orddate[12], invdate[12], number[12]; I_GetInvoiceAddress (&cust); I_GetOrderDate (orddate); I_GetInvoiceDate (invdate); I_GetInvoiceNumber (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_INVOICE, name, I_GetDummyInvoiceItem, &cust, I_GetInvoiceItemCount (), number, invdate, orddate, I_GetMwSt (1), I_GetMwSt (2), FALSE); else if (!P_Print (PRT_MODE_INVOICE, name, I_GetInvoiceItem, &cust, I_GetInvoiceItemCount (), number, invdate, orddate, I_GetMwSt (1), I_GetMwSt (2), FALSE)) { /* Rechnung gedruckt. Dies auch vermerken */ struct MinInvoice mininvoice; char date[12]; date[0] = 0; CorrectDate (date); I_SetPrintDate (date); I_GetMinInvoice (&mininvoice); if (IL_SaveInvoice (&mininvoice, FALSE)) MUI_Request (app, WI_invlist, 0, "Fehlermeldung", "OK", "Rechnung speichern\n%s", IL_GetErrorMsg ()); IL_ChangeInvoice (&mininvoice); Redraw_IL_List (); } #ifndef OUTPUTWIN set (app, MUIA_Application_Sleep, FALSE); #endif } else { MUI_Request (app, WI_invlist, 0, "Fehlermeldung", "OK", "Rechnung laden\n%s", IL_GetErrorMsg ()); } } } } break; case ID_IL_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 (0, name); #ifndef OUTPUTWIN set (app, MUIA_Application_Sleep, FALSE); #endif } break; case ID_IL_SHOWINVOICE: /* Rechnungsliste drucken */ { struct MinInvoice *active; STRPTR name; struct Screen *scr; if (I_CheckAbort (FALSE)) { closeInvoiceAction = CIA_MAIN_EDIT; set (WI_invoice, MUIA_Window_Open, FALSE); DoMethod (LV_IL_list, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &active); if (active) { /* Rechnung einlesen */ if (!IL_LoadInvoice (active, FALSE)) { struct MinCustomer cust; char invdate[12], orddate[12], number[12]; I_GetInvoiceAddress (&cust); I_GetOrderDate (orddate); I_GetInvoiceDate (invdate); I_GetInvoiceNumber (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_INVOICE, name, I_GetDummyInvoiceItem, &cust, I_GetInvoiceItemCount (), number, invdate, orddate, I_GetMwSt (1), I_GetMwSt (2), TRUE); else if (!P_Print (PRT_MODE_INVOICE, name, I_GetInvoiceItem, &cust, I_GetInvoiceItemCount (), number, invdate, orddate, I_GetMwSt (1), I_GetMwSt (2), TRUE)) { } #ifndef OUTPUTWIN set (app, MUIA_Application_Sleep, FALSE); #endif } else { MUI_Request (app, WI_invlist, 0, "Fehlermeldung", "OK", "Rechnung laden\n%s", IL_GetErrorMsg ()); } } } } break; /* Rechnung */ case ID_I_CUSTOMER: /* Kunden auswählen -> in Kundenliste gehen */ { struct Customer cust; if (C_CheckAbort (FALSE)) { closeCustomerAction = CCA_INVOICE; I_GetInvoiceAddress ((struct MinCustomer *) &cust); InitCustomerWin (cust.KundenNummer); set (WI_customer, MUIA_Window_Title, "Kunde für Rechnung"); set (WI_customer, MUIA_Window_Open, TRUE); } } break; case ID_I_CASH: /* kein Kunde, sondern Barverkauf */ I_SetInvoiceAddress (&cashcust); set (ST_I_adr1, MUIA_String_Contents, cashcust.Adresse1); set (ST_I_adr2, MUIA_String_Contents, cashcust.Adresse2); set (ST_I_adr3, MUIA_String_Contents, cashcust.Adresse3); set (ST_I_adr4, MUIA_String_Contents, cashcust.Adresse4); set (ST_I_adr5, MUIA_String_Contents, cashcust.Adresse5); set (ST_I_kundennr, MUIA_String_Contents, ""); set (ST_I_zeichen, MUIA_String_Contents, ""); break; case ID_I_LIST: /* Benutzer wählt einen Artikel aus der Liste aus */ I_DisplayArticle (); break; case ID_I_BRUTTONETTO: /* Darstellung Brutto/Netto ändern */ { LONG num, newmode; char buffer[20]; double betrag; STRPTR str; UWORD preistab; get (CY_I_mode, MUIA_Cycle_Active, &newmode); get (CY_I_mwst, MUIA_Cycle_Active, &num); preistab = num + 1; get (ST_I_einzel, MUIA_String_Contents, &str); betrag = ScanMonetary (str); if (CO_GetInvoiceMwStMode ()) { /* Bruttobetrag in Netto wandeln */ betrag = Brutto2Netto (betrag, I_GetMwSt (preistab)); } DisplayBetrag (buffer, betrag, I_GetMwSt (preistab), newmode); set (ST_I_einzel, MUIA_String_Contents, buffer); /* neuen Darstellungsmodus einstellen */ CO_SetInvoiceMwStMode (newmode); } break; case ID_I_INSERT: /* neuen Artikel in Liste übernehmen */ { struct Article art; LONG num; STRPTR str; double betrag; char buffer[20]; get (ST_I_artnum, MUIA_String_Contents, &str); strcpy (art.Artikelnummer, str); get (ST_I_article, MUIA_String_Contents, &str); strcpy (art.Bezeichnung, str); get (CY_I_mwst, MUIA_Cycle_Active, &num); art.Preistabelle = num + 1; get (ST_I_einzel, MUIA_String_Contents, &str); betrag = ScanMonetary (str); if (CO_GetInvoiceMwStMode ()) { /* Bruttobetrag in Netto wandeln */ betrag = Brutto2Netto (betrag, I_GetMwSt (art.Preistabelle)); } art.Betrag = betrag; get (ST_I_einzel, MUIA_String_Contents, &str); betrag = ScanMonetary (str); if (CO_GetInvoiceMwStMode ()) { /* Bruttobetrag in Netto wandeln */ betrag = Brutto2Netto (betrag, I_GetMwSt (art.Preistabelle)); } art.EKBetrag = betrag; art.Datum[0] = 0; get (ST_I_menge, MUIA_String_Contents, &str); art.Menge = ScanMonetary (str); I_AddInvoiceItem ((struct MinArticle *) &art); // Redraw_I_List(); DoMethod (LV_I_list, MUIM_List_InsertSingle, &art, MUIV_List_Insert_Bottom); set (LV_I_list, MUIA_List_Active, MUIV_List_Active_Bottom); DoMethod (LV_I_list, MUIM_List_Jump, MUIV_List_Jump_Active); I_GetInvoiceSum (NULL, NULL, NULL, NULL, &betrag); PrintCurrency (buffer, betrag); set (TX_I_summe, MUIA_Text_Contents, buffer); set (WI_invoice, MUIA_Window_ActiveObject, LV_I_list); } break; case ID_I_CHANGE: /* Artikel in Liste ändern */ { struct Article art; LONG num; STRPTR str; double betrag; char buffer[20]; get (ST_I_artnum, MUIA_String_Contents, &str); strcpy (art.Artikelnummer, str); get (ST_I_article, MUIA_String_Contents, &str); strcpy (art.Bezeichnung, str); get (CY_I_mwst, MUIA_Cycle_Active, &num); art.Preistabelle = num + 1; get (ST_I_einzel, MUIA_String_Contents, &str); betrag = ScanMonetary (str); if (CO_GetInvoiceMwStMode ()) { /* Bruttobetrag in Netto wandeln */ betrag = Brutto2Netto (betrag, I_GetMwSt (art.Preistabelle)); } art.Betrag = betrag; art.Datum[0] = 0; get (ST_I_menge, MUIA_String_Contents, &str); art.Menge = ScanMonetary (str); I_ChangeInvoiceItem ((struct MinArticle *) &art); Redraw_I_List (); I_GetInvoiceSum (NULL, NULL, NULL, NULL, &betrag); PrintCurrency (buffer, betrag); set (TX_I_summe, MUIA_Text_Contents, buffer); set (WI_invoice, MUIA_Window_ActiveObject, LV_I_list); } break; case ID_I_DELETE: /* Artikel aus Liste entfernen */ { struct Article *active; double betrag; char buffer[20]; DoMethod (LV_I_list, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &active); if (active) { I_DelInvoiceItem (); DoMethod (LV_I_list, MUIM_List_Remove, MUIV_List_Remove_Active); DoMethod (LV_I_list, MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &active); if (!active) { Clear_I_Inputs (); } } I_GetInvoiceSum (NULL, NULL, NULL, NULL, &betrag); PrintCurrency (buffer, betrag); set (TX_I_summe, MUIA_Text_Contents, buffer); set (WI_invoice, MUIA_Window_ActiveObject, LV_I_list); } break; case ID_I_CLEAR: /* Eingabefelder löschen */ Clear_I_Inputs (); set (WI_invoice, MUIA_Window_ActiveObject, ST_I_artnum); break; case ID_I_CHOOSE: /* Artikel auswählen -> in Artikelliste gehen */ if (A_CheckAbort (FALSE)) { closeArticleAction = CAA_INVOICE; InitArticleWin (); set (REG_A_mode, MUIA_Group_ActivePage, MUIV_Group_ActivePage_First); set (WI_article, MUIA_Window_Open, TRUE); set (WI_article, MUIA_Window_Title, "Artikel für Rechnung"); } break; case ID_I_TODAY: /* heutiges Datum in Zahldatum-Gadget eintragen */ { char buffer[12]; buffer[0] = 0; CorrectDate (buffer); set (ST_I_paydate, MUIA_String_Contents, buffer); } break; case ID_I_PAYALL: /* den ganzen Betrag zahlen: in Eingabegadget eintragen */ { char buffer[12]; double betrag; I_GetInvoiceSum (NULL, NULL, NULL, NULL, &betrag); PrintCurrency (buffer, betrag); set (ST_I_pay, MUIA_String_Contents, buffer); } break; case ID_I_OK: /* Rechnung speichern */ { struct MinInvoice mininvoice; struct MinOrder minorder; struct MinCustomer cust; LONG num; STRPTR str, date; double betrag; char buffer[20]; /* Zahlungsfelder einlesen */ get (CY_I_pay, MUIA_Cycle_Active, &num); get (ST_I_pay, MUIA_String_Contents, &str); betrag = ScanMonetary (str); get (ST_I_paydate, MUIA_String_Contents, &date); I_SetPayment (betrag, date, num); get (ST_I_invdate, MUIA_String_Contents, &str); I_SetInvoiceDate (str); get (ST_I_adr1, MUIA_String_Contents, &str); strcpy (cust.Adresse1, str); get (ST_I_adr2, MUIA_String_Contents, &str); strcpy (cust.Adresse2, str); get (ST_I_adr3, MUIA_String_Contents, &str); strcpy (cust.Adresse3, str); get (ST_I_adr4, MUIA_String_Contents, &str); strcpy (cust.Adresse4, str); get (ST_I_adr5, MUIA_String_Contents, &str); strcpy (cust.Adresse5, str); get (ST_I_kundennr, MUIA_String_Contents, &str); cust.KundenNummer = atoi (str); get (ST_I_zeichen, MUIA_String_Contents, &str); strcpy (cust.Zeichen, str); I_SetInvoiceAddress (&cust); I_GetMinInvoice (&mininvoice); if (!I_GetInvoiceItemCount ()) MUI_Request (app, WI_invoice, 0, "Fehlermeldung", "OK", "keine Artikel in der Rechnung vorhanden!"); else { if (IL_SaveInvoice (&mininvoice, TRUE)) MUI_Request (app, WI_invlist, 0, "Fehlermeldung", "OK", "Rechnung speichern\n%s", IL_GetErrorMsg ()); else { switch (closeInvoiceAction) { case CIA_MAIN_EDIT: IL_SetYear (mininvoice.invoiceYear); IL_SetCurrentInvoiceNumber (mininvoice.invoiceNumber); IL_ChangeInvoice (&mininvoice); Redraw_IL_List (); break; case CIA_MAIN_ORDINV: /* Änderung in Auftragsliste übernehmen */ OL_GetCurrentOrder (&minorder); minorder.invoiceYear = mininvoice.invoiceYear; minorder.invoiceNumber = mininvoice.invoiceNumber; strcpy (minorder.invoiceDate, mininvoice.invoiceDate); /* Änderung auch im Auftrag durchführen */ if (OL_LoadOrder (&minorder)) { MUI_Request (app, WI_invlist, 0, "Fehlermeldung", "OK", "Auftrag laden\n%s", OL_GetErrorMsg ()); } sprintf (buffer, "%04d/%d", minorder.invoiceYear, minorder.invoiceNumber); O_SetInvoiceNumber (buffer); O_SetInvoiceDate (minorder.invoiceDate); if (OL_SaveOrder (&minorder)) { MUI_Request (app, WI_invlist, 0, "Fehlermeldung", "OK", "Auftrag speichern\n%s", OL_GetErrorMsg ()); } OL_SetYear (minorder.orderYear); OL_SetCurrentOrderNumber (minorder.orderNumber); OL_ChangeOrder (&minorder); Redraw_OL_List (); case CIA_MAIN_NEW: /* neuen Eintrag in die Liste einfügen */ IL_SetYear (mininvoice.invoiceYear); IL_NewInvoice (&mininvoice); Redraw_IL_List (); break; } set (WI_invoice, MUIA_Window_Open, FALSE); } } } break; case ID_I_CANCEL: if (I_CheckAbort (FALSE)) { switch (closeInvoiceAction) { case CIA_MAIN_EDIT: case CIA_MAIN_NEW: case CIA_MAIN_ORDINV: break; } set (WI_invoice, MUIA_Window_Open, FALSE); } break; } }