Dialog.c

/*
        Advanved Dialogs v1.0.7
        Copyright (C) 2005-2008 Jonas Gehring

        Advanced Dialogs is free software; you can redistribute it and/or modify
        it under the terms of the GNU Lesser General Public License as published by
        the Free Software Foundation; either version 2 of the License, or
        (at your option) any later version.

        Advanced Dialogs is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU Lesser General Public License for more details.

        You should have received a copy of the GNU Lesser General Public License
        along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/


// C Source File
// Created 23.11.2005; 03:58:13


#include <extgraph.h>                                                   // ExtGraph by TI-Chess Team

#include "AdvDialogs.h"                                                 // This should be obvious ;)
#include "Internal.h"                                                   // This header should not be included in programs using Advanced Dialogs


// Temporary screen buffers
void *tscr = NULL;

// Counters
uchar tabcounter;
short elcounter;

// CheckBox indicators
BOOL AD_CHECKED[6][6];

// Button text
const char *bttext[4] = {"OK", "ESC", "YES", "NO"};

// These pseudo-constants make sure the dialog is centered                                            
// on a TI92+/V200 display as well                                                                    
#define CENTER_XL(x) ((LCD_WIDTH-x)/2)                                                                
#define CENTER_YT(y) ((LCD_HEIGHT-y)/2)                                                               
#define CENTER_XR(x) ((LCD_WIDTH+x)/2)                                                                
#define CENTER_YB(y) ((LCD_HEIGHT+y)/2)

// Button graphics for dialogs
const unsigned short gbutton[18] =
{
         0x0002,0x0002,0x0002,0x0002,0x0002,0x0002,0x0002,0x0002
        ,0x7FFE,0x0003,0x7FFF,0x7FFF,0x7FFF,0x7FFF,0x7FFF,0x7FFF
        ,0x7FFF,0x7FFF
};



// Creates and allocates space for a new dialog
ADVDIALOG *AdvDlgNew(short width, short height, const char *title, BOOL savescreen)
{
        uchar i, s;
        ADVDIALOG *_dialog = malloc(sizeof(ADVDIALOG));
        
        if (_dialog == NULL)
        {
                return NULL;
        }

        memset(_dialog, 0x00, sizeof(ADVDIALOG));

        // Set position vars
        _dialog->left_x = CENTER_XL(width);
        _dialog->top_y = CENTER_YT(height);
        _dialog->right_x = CENTER_XR(width);
        _dialog->bottom_y = CENTER_YB(height);
                
        // Set all elements to AD_NONE
        for (i = 6; i--; )
        {
                for (s = 6; s--; )
                {
                        _dialog->tabs[i].elements[s].element = AD_NONE;
                }
                _dialog->tabs[i].numelements = 6;
        }
        
        // Set the title
        strcpy(_dialog->title, title);
        
        // Check if screen should be saved
        _dialog->savescreen = savescreen;
        
        return _dialog;
}


// Frees a pointer for a dialog 
void AdvDlgFree(ADVDIALOG *dialog)
{
        short i, j;
        
        // Free possible bitmaps
        for (i = 6; i--; )
        {
                for (j = dialog->tabs[i].numbitmaps; j--; )
                {
                        FreeBitmap(dialog->tabs[i].bitmaps[j]);
                }
        }
        
        free(dialog);
}


// Adds a Tab to a dialog
void AdvDlgAddTab(ADVDIALOG *dialog, uchar tab, const char *title)
{
        strcpy(dialog->tabs[tab].title, title);
        
        dialog->numtabs++;
}


// Adds a button to a Dialog
void AdvDlgAddButton(ADVDIALOG *dialog, uchar pos, uchar button)
{
        dialog->buttons[pos] = button;
}


// Adds a Text element to a dialog
void AdvDlgAddText(ADVDIALOG *dialog, uchar tab, uchar line, 
                                   const char *text, uchar attr, uchar color)
{
        dialog->tabs[tab].elements[line].element = AD_TEXT;
        strcpy(dialog->tabs[tab].elements[line].text, text);
        dialog->tabs[tab].elements[line].flag = attr;
        dialog->tabs[tab].elements[line].color = color;
} 


// Adds an Input element to a dialog
void AdvDlgAddInputBox(ADVDIALOG *dialog, uchar tab, uchar line, const char *text,
                                    char *buffer, short maxsize, uchar mode, uchar color)
{
        dialog->tabs[tab].elements[line].element = AD_INPUT;
        strcpy(dialog->tabs[tab].elements[line].text, text);
        dialog->tabs[tab].elements[line].inputbuffer = buffer;
        dialog->tabs[tab].elements[line].inputsize = maxsize;
        dialog->tabs[tab].elements[line].flag = mode;
        dialog->tabs[tab].elements[line].color = color;
}


// Adds a Checkbox element to a dialog
void AdvDlgAddCheckBox(ADVDIALOG *dialog, uchar tab, uchar line, const char *text,
                                       BOOL checked, uchar color)
{
        dialog->tabs[tab].elements[line].element = AD_CHECKBOX;
        strcpy(dialog->tabs[tab].elements[line].text, text);
        dialog->tabs[tab].elements[line].flag = checked;
        dialog->tabs[tab].elements[line].color = color;
}


// Adds a DropDown menu to a dialog
void AdvDlgAddDropDown(ADVDIALOG *dialog, uchar tab, uchar line, const char *text,
                                           const char **itemlist, short numitems, short *selected, uchar color)
{
        dialog->tabs[tab].elements[line].element = AD_DROPDOWN;
        strcpy(dialog->tabs[tab].elements[line].text, text);
        dialog->tabs[tab].elements[line].itemlist = itemlist;
        dialog->tabs[tab].elements[line].flag = numitems;
        dialog->tabs[tab].elements[line].selected = selected;   
        dialog->tabs[tab].elements[line].color = color; 
}
 

// Adds a Bitmap to a dialog
char AdvDlgAddBitmap(ADVDIALOG *dialog, uchar tab, short x, short y, ADVBITMAP *bitmap)
{
        if (dialog->tabs[tab].numbitmaps > 5)
        {
                return -1;
        }
        dialog->tabs[tab].bitmaps[dialog->tabs[tab].numbitmaps] = bitmap;
        bitmap->x = x;
        bitmap->y = y;
        return ++dialog->tabs[tab].numbitmaps;
}


// Draws the basic things (window, buttons, title)
void AdvDlgDrawBasic(ADVDIALOG *dialog)
{
        // Draw Dialog window
        GrayDrawRect(dialog->left_x, dialog->top_y, dialog->right_x, dialog->bottom_y, COLOR_LIGHTGRAY, RECT_FILLED);
        GrayDrawRect(dialog->left_x, dialog->top_y, dialog->right_x, dialog->top_y+7, COLOR_BLACK, RECT_FILLED);
        GrayFastDrawLine(dialog->left_x+1, dialog->bottom_y+1, dialog->right_x+1, dialog->bottom_y+1, COLOR_BLACK);
        GrayFastDrawLine(dialog->right_x+1, dialog->top_y+1, dialog->right_x+1, dialog->bottom_y+1, COLOR_BLACK);

        // Add title
        GrayDrawStrExt(0, dialog->top_y+1, dialog->title, A_XOR | A_CENTERED, F_4x6);
        
        // Add buttons
        if (dialog->buttons[0] != B_NONE)
        {
                // Using sprites for buttons is faster and saves a few bytes
                GraySprite16_RPLC_R(dialog->left_x+10, dialog->bottom_y-9, 9, &gbutton[0], &gbutton[9],
                                                        GRAYPLANES);
                GrayDrawStrExt(dialog->left_x+17-2*strlen(bttext[dialog->buttons[0]-1]), dialog->bottom_y-7, bttext[dialog->buttons[0]-1], A_NORMAL, F_4x6);
        }
        if (dialog->buttons[1] != B_NONE)
        {
                GraySprite16_RPLC_R(dialog->right_x-24, dialog->bottom_y-9, 9, &gbutton[0], &gbutton[9],
                                                        GRAYPLANES);
                GrayDrawStrExt(dialog->right_x-17-2*strlen(bttext[dialog->buttons[1]-1]), dialog->bottom_y-7, bttext[dialog->buttons[1]-1], A_NORMAL,  F_4x6);
        }
}


// Draws a tab of a Dialog
void AdvDlgDrawTab(ADVDIALOG *dialog, uchar tab)
{
        short i;
        BOOL drawastab = (dialog->numtabs > 0);

        AdvDlgDrawBasic(dialog);
        
        if (drawastab)
        {
                GrayDrawRect(dialog->left_x+2, dialog->top_y+17, dialog->right_x-2, dialog->bottom_y-11, COLOR_BLACK, RECT_EMPTY);
                GrayFastDrawLine(dialog->left_x+2, dialog->top_y+17, dialog->left_x+2, dialog->bottom_y-11, COLOR_WHITE);
                GrayFastDrawLine(dialog->left_x+2, dialog->top_y+17, dialog->right_x-3, dialog->top_y+17, COLOR_WHITE);
                
                short xp = 0;
                
                for (i = 0; i < dialog->numtabs; i++)
                {                       
                        short drwidth = DrawStrWidth(dialog->tabs[i].title, F_4x6);
                        
                        // Active tab
                        if (i == tab)
                        {
                                GrayDrawRect(dialog->left_x+3+xp, dialog->top_y+9, dialog->left_x+5+xp+drwidth,
                                                         dialog->top_y+17, COLOR_WHITE, RECT_EMPTY);
                                GrayFastDrawLine(dialog->left_x+4+xp, dialog->top_y+17, dialog->left_x+4+xp+drwidth, dialog->top_y+17, COLOR_LIGHTGRAY);
                                GrayFastDrawLine(dialog->left_x+5+xp+drwidth, dialog->top_y+9, dialog->left_x+5+xp+drwidth, dialog->top_y+16, COLOR_BLACK);
                                GrayDrawStrExt(dialog->left_x+4+xp, dialog->top_y+11, dialog->tabs[i].title, A_NORMAL, F_4x6);
                        }
                        // Inactive tab
                        else
                        {
                                GrayDrawRect(dialog->left_x+3+xp, dialog->top_y+10, dialog->left_x+6+xp+drwidth,
                                                         dialog->top_y+17, COLOR_WHITE, RECT_EMPTY);
                                GrayDrawStrExt(dialog->left_x+4+xp, dialog->top_y+11, dialog->tabs[i].title, A_NORMAL, F_4x6);
                        }
                        
                        xp += DrawStrWidth(dialog->tabs[i].title, F_4x6)+3;
                }
        }
        
        for (i = 0; i < dialog->tabs[tab].numelements; i++)
        {
                switch (dialog->tabs[tab].elements[i].element)
                {
                        // Text
                        case AD_TEXT:
                        {
                                short tx = dialog->left_x+2+(drawastab*3);
                        
                                if (dialog->tabs[tab].elements[i].flag == TXT_ALIGNRIGHT)
                                {
                                        tx = dialog->right_x-5-(drawastab*3) - DrawStrWidth(dialog->tabs[tab].elements[i].text, F_4x6);
                                }
                        
                                GrayDrawColorString(tx, dialog->top_y+9+2+(drawastab*10)+(i*8), dialog->tabs[tab].elements[i].text, 
                                                                dialog->tabs[tab].elements[i].color, dialog->tabs[tab].elements[i].flag);
                        }
                        break;
                
                        // InputBox
                        case AD_INPUT:
                        {
                                GrayDrawColorString(dialog->left_x+2+(drawastab*3), dialog->top_y+9+2+(drawastab*10)+8*i, dialog->tabs[tab].elements[i].text, 
                                                                        dialog->tabs[tab].elements[i].color, TXT_STANDARD);
                                GrayDrawRect(dialog->left_x+2+(drawastab*3)+DrawStrWidth(dialog->tabs[tab].elements[i].text, F_4x6) + 4, dialog->top_y+8+2+(drawastab*10)+(i*8), dialog->right_x-5-(drawastab*3), dialog->top_y+14+2+(drawastab*10)+(i*8), COLOR_WHITE, RECT_FILLED);   
                                
                                short show = 0;
                                
                                while ((unsigned short)DrawStrWidth(&dialog->tabs[tab].elements[i].inputbuffer[show], F_4x6)
                                           > (dialog->right_x-10-(drawastab*3) - 4 -(dialog->left_x+5+DrawStrWidth(dialog->tabs[tab].elements[i].text, F_4x6))))
                                {
                                        show++;
                                }
                                                
                                GrayDrawStrExt(dialog->left_x+3+(drawastab*2)+DrawStrWidth(dialog->tabs[tab].elements[i].text, F_4x6) + 4, dialog->top_y+9+2+(drawastab*10)+(i*8), &dialog->tabs[tab].elements[i].inputbuffer[show], A_NORMAL, F_4x6);
                        }
                        break;
                        
                        // CheckBox
                        case AD_CHECKBOX:
                        {
                                GrayDrawColorString(dialog->left_x+2+(drawastab*3), dialog->top_y+9+2+(drawastab*10)+8*i, dialog->tabs[tab].elements[i].text, 
                                                                dialog->tabs[tab].elements[i].color, TXT_STANDARD);
                                GrayDrawRect(dialog->right_x-11-(drawastab*3), dialog->top_y+8+2+(drawastab*10)+(i*8), dialog->right_x-5-(drawastab*3), dialog->top_y+14+2+(drawastab*10)+(i*8), COLOR_WHITE, RECT_FILLED);     
                                
                                if (dialog->tabs[tab].elements[i].flag)
                                {
                                        GrayFastDrawLine(dialog->right_x-11-(drawastab*3), dialog->top_y+11+2+(drawastab*10)+(i*8), dialog->right_x-9-(drawastab*3), dialog->top_y+14+2+(drawastab*10)+(i*8), COLOR_BLACK);     
                                        GrayFastDrawLine(dialog->right_x-9-(drawastab*3), dialog->top_y+14+2+(drawastab*10)+(i*8), dialog->right_x-5-(drawastab*3), dialog->top_y+8+2+(drawastab*10)+(i*8), COLOR_BLACK);       
                                }
                        }
                        break;
                
                        // DropDown
                        case AD_DROPDOWN:
                        {
                                char tstr[60];
                        
                                GrayDrawColorString(dialog->left_x+2+(drawastab*3), dialog->top_y+9+2+(drawastab*10)+8*i, dialog->tabs[tab].elements[i].text, 
                                                                        dialog->tabs[tab].elements[i].color, TXT_STANDARD);
                                GrayDrawRect(dialog->left_x+10+(drawastab*3)+DrawStrWidth(dialog->tabs[tab].elements[i].text, F_4x6), dialog->top_y+8+2+(drawastab*10)+(i*8), dialog->right_x-5-(drawastab*3), dialog->top_y+14+2+(drawastab*10)+(i*8), COLOR_WHITE, RECT_FILLED);      
                                GrayDrawChar(dialog->right_x-10-(drawastab*3), dialog->top_y+9+2+(drawastab*10)+8*i, 22, A_XOR);

                                strncpy(tstr, dialog->tabs[tab].elements[i].itemlist[*dialog->tabs[tab].elements[i].selected], 59);
                        
                                while ((unsigned short)DrawStrWidth(tstr, F_4x6)
                                        > ((dialog->right_x-5-(drawastab*3)) - (dialog->left_x+10+(drawastab*3)+DrawStrWidth(dialog->tabs[tab].elements[i].text, F_4x6)) - 5))
                                {
                                        tstr[strlen(tstr)-1] = 0;
                                }

                                GrayDrawStrExt(dialog->left_x+10+(drawastab*3)+DrawStrWidth(dialog->tabs[tab].elements[i].text, F_4x6), dialog->top_y+9+2+(drawastab*10)+(i*8), tstr, A_XOR, F_4x6);
                        }
                        break;
                
                        default: break;
                }
        }
        
        // Check for possible bitmaps
        for (i = 0; i < dialog->tabs[tab].numbitmaps; i++)
        {
                DrawBitmap(dialog, dialog->tabs[tab].bitmaps[i]);
        }
}


// Executes a dialog
BOOL AdvDlgDo(ADVDIALOG *dialog, INT_HANDLER tempint1)
{
        short key;
        uchar i, ccheck = 0;
        BOOL returnvalue = TRUE;
        BOOL nexttab;
        void *kbq = kbd_queue();
        
        dialog->inthandler = tempint1;
        
        // Temporarily reinstall the original AUTO_INT_1
        if (dialog->inthandler != DUMMY_HANDLER)
        {
                GraySetInt1Handler(dialog->inthandler);
        }
        
        // Save LCD contents if neccessary
        if (dialog->savescreen) 
        {
                SaveScreen();
        }
        
        // Set system font to small
        char oldfont = FontSetSys(F_4x6);
                
        // Reset counters
        tabcounter = elcounter = 0;

        // Loop through the tabs
        do 
        {
                BOOL interactive = FALSE;
                nexttab = FALSE;
                elcounter = ccheck = 0;
                        
                AdvDlgDrawTab(dialog, tabcounter);

                // Loop through the interactive elements
                do 
                {
                        interactive = dialog->tabs[tabcounter].elements[elcounter].element > AD_TEXT;
                        
                        // Execute element interaction function
                        switch (dialog->tabs[tabcounter].elements[elcounter].element)
                        {
                                case AD_INPUT:
                                        elcounter = AdvDlgInputBox(dialog, tabcounter, elcounter);
                                        break;
                                
                                case AD_CHECKBOX:
                                        elcounter = AdvDlgCheckBox(dialog, tabcounter, elcounter);
                                        break;
                                        
                                case AD_DROPDOWN:
                                        elcounter = AdvDlgDropDown(dialog, tabcounter, elcounter);
                                        break;
                                        
                                default:        // AD_NONE and AD_TEXT
                                        ++elcounter;
                                        break;
                        }
                        
                        // Activate next tab
                        if (elcounter == NEXTTAB)
                        {
                                nexttab = TRUE;
                                tabcounter = (tabcounter+1) % dialog->numtabs;
                                break;
                        }               
                        
                        // The user has pressed ESC
                        if (elcounter < 0)
                        {
                                returnvalue = FALSE;
                                break;
                        }
                        
                } while (elcounter < dialog->tabs[tabcounter].numelements);
                                                
                // Save Checkboxes
                for (i = 0; i < dialog->tabs[tabcounter].numelements; i++)
                {
                        if (dialog->tabs[tabcounter].elements[i].element == AD_CHECKBOX)
                        {
                                AD_CHECKED[tabcounter][ccheck++] = dialog->tabs[tabcounter].elements[i].flag;
                        }
                }

                // If there was no interactive element (just text or nothing)
                if (!interactive)
                {
                        // Wait for keypress
                        do
                        {
                                GetKey(kbq, &key);
                                
                                if (key == KEY_ESC)
                                {
                                        returnvalue = FALSE;
                                        break;
                                }
                                else if (key == KEY_ENTER)
                                {
                                        returnvalue = TRUE;
                                        break;
                                }                               
                                // Switch tabs
                                else if (key == KEY_APPS)
                                {
                                        tabcounter = (tabcounter+1) % dialog->numtabs;
                                        nexttab = TRUE;
                                        break;
                                }               
                        } while (TRUE); 
                }
        } while (nexttab);
        
        // Set AUTO_INT_1 to dummy again
        if (dialog->inthandler != DUMMY_HANDLER)
        {
                GraySetInt1Handler(DUMMY_HANDLER);
        }

        RestoreScreen();
        
        // Restore previous font
        FontSetSys(oldfont);
        
        return returnvalue;
}

---