dialogs.h

/***************************************************************************
 *   Copyright (C) 2007 by Mike Polan                                      *
 *   kanadakid@gmail.com                                                   *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program 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 General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
// dialogs.h: various small dialogs

#ifndef DIALOGS_H
#define DIALOGS_H

#include <gtkmm/button.h>
#include <gtkmm/comboboxtext.h>
#include <gtkmm/dialog.h>
#include <gtkmm/entry.h>
#include <gtkmm/image.h>
#include <gtkmm/label.h>
#include <gtkmm/liststore.h>
#include <gtkmm/listviewtext.h>
#include <gtkmm/notebook.h>
#include <gtkmm/progressbar.h>
#include <gtkmm/scale.h>
#include <gtkmm/scrolledwindow.h>
#include <gtkmm/textbuffer.h>
#include <gtkmm/textview.h>
#include <gtkmm/togglebutton.h>

#include "case.h"
#include "casecombobox.h"
#include "character.h"
#include "colorwidget.h"
#include "hotspotwidget.h"

class ChangeSpeedDialog: public Gtk::Dialog {
        public:
                ChangeSpeedDialog();
                
                Glib::ustring get_text_speed();
                
        private:
                // build the ui
                void construct();
                
                // handler for value changes in slider
                void on_value_changed();
                
                // buttons
                Gtk::Button *m_OKButton;
                
                // labels
                Gtk::Label *m_SlowerLabel;
                Gtk::Label *m_FasterLabel;
                
                // scale for selecting value
                Gtk::HScale *m_Scale;
};

/***************************************************************************/

class ChangeColorDialog: public Gtk::Dialog {
        public:
                ChangeColorDialog();
                
                Glib::ustring get_color();
                
        private:
                // build the ui
                void construct();
                
                // buttons containing colors
                Gtk::RadioButton *m_BlueButton;
                Gtk::RadioButton *m_GreenButton;
                Gtk::RadioButton *m_OrangeButton;
                Gtk::RadioButton *m_WhiteButton;
                
                // radio buttons
                Gtk::RadioButtonGroup m_Group;
};

/***************************************************************************/

class ProgressDialog: public Gtk::Dialog {
        public:
                ProgressDialog(const Glib::ustring &label);
                
                void set_progress(double amount);
                
        private:
                // build the ui
                void construct();
                
                // label
                Gtk::Label *m_Label;
                
                // progress bar
                Gtk::ProgressBar *m_ProgBar;
};

/***************************************************************************/

class TestimonyManager: public Gtk::Dialog {
        public:
                TestimonyManager(const TestimonyMap &tmap, const StringVector &testimonyIds);
                
                TestimonyMap get_testimonies() const { return m_Testimonies; }
                
        private:
                // build the ui
                void construct();
                
                // add button click handler
                void on_add_button_clicked();
                
                // edit button click handler
                void on_edit_button_clicked();
                
                // delete button click handler
                void on_delete_button_clicked();
                
                // selection change handler
                void on_selection_changed();
                
                // labels
                Gtk::Label *m_TitleLabel;
                Gtk::Label *m_PreviewLabel;
                
                // buttons
                Gtk::Button *m_AddButton;
                Gtk::Button *m_EditButton;
                Gtk::Button *m_DeleteButton;
                
                // list view for list and its container
                Gtk::ScrolledWindow *m_SWindow;
                Gtk::ListViewText *m_ListView;
                
                // internal record of testimonies
                TestimonyMap m_Testimonies;
                StringVector m_Ids;
};

/***************************************************************************/

class ImageDialog: public Gtk::Dialog {
        public:
                ImageDialog(const ImageMap &imap, const StringVector &imgIds);
                
                ImageMap get_images() const { return m_Images; }
                
        private:
                // build the ui
                void construct();
                
                // add image handler
                void on_add_clicked();
                
                // remove image handler
                void on_delete_clicked();
                
                // selection change handler
                void on_selection_changed();
                
                // labels
                Gtk::Label *m_ImageLabel;
                Gtk::Label *m_PreviewLabel;
                
                // buttons
                Gtk::Button *m_AddButton;
                Gtk::Button *m_DeleteButton;
                
                // scrolled window container
                Gtk::ScrolledWindow *m_SWindow;
                
                // list of images
                Gtk::ListViewText *m_ImageList;
                
                // preview image
                Gtk::Image *m_Image;
                
                // record of images
                ImageMap m_Images;
                StringVector m_ImageIds;
};

/***************************************************************************/

class NewHotspotDialog: public Gtk::Dialog {
        public:
                NewHotspotDialog();
                
                void set_pixbuf(const Glib::RefPtr<Gdk::Pixbuf> &pixbuf) { m_HSWidget->set_image(pixbuf); }
                
                Case::Hotspot get_hotspot();
                
        private:
                // build the ui
                void construct();
                
                // signal handler for point changes
                void on_point_changed(int x, int y);
                
                // signal handler for dimension changes
                void on_dimensions_changed(int w, int h);
                
                // handler for coordinate entry changes
                void on_coord_entry_changed();
                
                // handler for dimension entry changes
                void on_dimension_entry_changed();
                
                // labels
                Gtk::Label *m_XLabel;
                Gtk::Label *m_YLabel;
                Gtk::Label *m_WLabel;
                Gtk::Label *m_HLabel;
                Gtk::Label *m_BlockLabel;
                
                // entries
                Gtk::Entry *m_XEntry;
                Gtk::Entry *m_YEntry;
                Gtk::Entry *m_WEntry;
                Gtk::Entry *m_HEntry;
                Gtk::Entry *m_BlockEntry;
                
                // widget to visually edit the hotspot
                HotspotWidget *m_HSWidget;
};

/***************************************************************************/

class LocationsDialog: public Gtk::Dialog {
        public:
                LocationsDialog(const LocationMap &locations, const BackgroundMap &bgs, const StringVector &usedIds);
                
                LocationMap get_locations() const { return m_Locations; }
                
        private:
                // build the ui
                void construct();
                
                // add a location
                void on_add();
                
                // remove a location
                void on_delete();
                
                // add a hotspot
                void on_add_hotspot();
                
                // remove a hotspot
                void on_delete_hotspot();
                
                // amend button click handler
                void on_amend_button_clicked();
                
                // row changes handler
                void on_selection_changed();
                
                // buttons
                Gtk::Button *m_AddButton;
                Gtk::Button *m_DeleteButton;
                Gtk::Button *m_AddHSButton;
                Gtk::Button *m_DeleteHSButton;
                Gtk::Button *m_AmendButton;
                
                // labels
                Gtk::Label *m_LocationsLabel;
                Gtk::Label *m_DetailsLabel;
                Gtk::Label *m_IdLabel;
                Gtk::Label *m_NameLabel;
                Gtk::Label *m_BGLabel;
                Gtk::Label *m_HotspotsLabel;
                
                // entries
                Gtk::Entry *m_IdEntry;
                Gtk::Entry *m_NameEntry;
                Gtk::Entry *m_BGEntry;
                
                // scrolled windows
                Gtk::ScrolledWindow *m_SWindow;
                Gtk::ScrolledWindow *m_HotspotSWindow;
                
                // tree model and view
                Gtk::TreeView *m_TreeView;
                Glib::RefPtr<Gtk::ListStore> m_Model;
                
                // column record
                class ColumnRec: public Gtk::TreeModel::ColumnRecord {
                        public:
                                // constructor
                                ColumnRec() {
                                        add(m_Column);
                                }
                                
                                // columns
                                Gtk::TreeModelColumn<Glib::ustring> m_Column;
                };
                
                // column record instance
                ColumnRec m_ColumnRec;
                
                // list view for hotspots
                Gtk::ListViewText *m_HotspotList;
                
                // stored location data
                LocationMap m_Locations;
                BackgroundMap m_Backgrounds;
                StringVector m_UsedIds;
};

/***************************************************************************/

class SpriteChooserDialog: public Gtk::Dialog {
        public:
                enum SpriteMode { SPRITE_NEW=0, SPRITE_EXISTING, SPRITE_FROM_GIFS };
                
                SpriteChooserDialog();
                
                SpriteMode get_sprite_mode() const;
                
                Glib::ustring get_path() const { return m_PathEntry->get_text(); }
                
        private:
                // build the ui
                void construct();
                
                // browse button click handler
                void on_browse_button_clicked();
                
                // new sprite radio button toggle handler
                void on_new_sprite_toggled();
                
                // open sprite radio button toggle handler
                void on_open_sprite_toggled();
                
                // from gif files radio buttons toggle handler
                void on_from_gifs_toggled();
                
                // radio buttons
                Gtk::RadioButtonGroup m_Group;
                Gtk::RadioButton *m_NewSpriteRB;
                Gtk::RadioButton *m_OpenSpriteRB;
                Gtk::RadioButton *m_CreateFromGifsRB;
                
                // labels
                Gtk::Label *m_SpriteLabel;
                Gtk::Label *m_PathLabel;
                
                // entry
                Gtk::Entry *m_PathEntry;
                
                // buttons
                Gtk::Button *m_BrowseButton;
};

/***************************************************************************/

class TextInputDialog: public Gtk::Dialog {
        public:
                TextInputDialog(const Glib::ustring &label="Input text:", const Glib::ustring &defaultValue="");
                
                Glib::ustring get_text() const { return m_Entry->get_text(); }
                
        private:
                // build the ui
                void construct(const Glib::ustring &label, const Glib::ustring &defaultValue);
                
                // labels
                Gtk::Label *m_Label;
                
                // entries
                Gtk::Entry *m_Entry;
};

/***************************************************************************/

class AudioDialog: public Gtk::Dialog {
        public:
                AudioDialog();
                
                void set_audio(const AudioMap &audio);
                
                AudioMap get_audio_data();
                
        private:
                // build the ui
                void construct();
                
                // add button handler
                void on_add_audio();
                
                // delete button handler
                void on_remove_audio();
                
                // labels
                Gtk::Label *m_AudioLabel;
                
                // containers
                Gtk::ScrolledWindow *m_SWindow;
                
                // buttons
                Gtk::Button *m_AddButton;
                Gtk::Button *m_DeleteButton;
                
                // list of audio files
                Glib::RefPtr<Gtk::ListStore> m_Model;
                Gtk::TreeView *m_AudioList;
                
                // column record
                class ColumnRec: public Gtk::TreeModel::ColumnRecord {
                        public:
                                ColumnRec() {
                                        add(m_NameCol);
                                        add(m_IdCol);
                                }
                                
                                // columns
                                Gtk::TreeModelColumn<Glib::ustring> m_NameCol;
                                Gtk::TreeModelColumn<Glib::ustring> m_IdCol;
                };
                
                // column record instance
                ColumnRec m_ColRec;
};

/***************************************************************************/

class NewEvidenceDialog: public Gtk::Dialog {
        public:
                NewEvidenceDialog(const StringVector &ids);
                
                Case::Evidence get_evidence_data();
                
                Glib::ustring get_image_path() const { return m_PathEntry->get_text(); }
                
        private:
                // build the ui
                void construct();
                
                // id text changes handler
                void on_id_changed();
                
                // browse button clicks
                void on_browse_button_clicked();
                
                // labels
                Gtk::Label *m_PathLabel;
                Gtk::Label *m_IdLabel;
                
                // entries
                Gtk::Entry *m_PathEntry;
                Gtk::Entry *m_IdEntry;
                
                // buttons
                Gtk::Button *m_BrowseButton;
                Gtk::Button *m_OKButton;
                
                // record of used evidence ids
                StringVector m_UsedIds;
};

/***************************************************************************/

class EvidenceDialog: public Gtk::Dialog {
        public:
                EvidenceDialog(const EvidenceMap &evidence,
                               const ImageMap &images,
                               const StringVector &evidenceIds);
                
                EvidenceMap get_evidence() const { return m_Evidence; }
                
        private:
                // build the ui
                void construct(const ImageMap &images);
                
                // has check image button toggled
                void on_check_img_toggled();
                
                // add a background
                void on_add();
                
                // remove a background
                void on_delete();
                
                // amend button click handler
                void on_amend_button_clicked();
                
                // row changes handler
                void on_selection_changed();
                
                // tree view and model for managing assets
                Gtk::TreeView *m_TreeView;
                Glib::RefPtr<Gtk::ListStore> m_Model;
                
                // labels
                Gtk::Label *m_EvidenceLabel;
                Gtk::Label *m_PreviewLabel;
                Gtk::Label *m_InternalLabel;
                Gtk::Label *m_NameLabel;
                Gtk::Label *m_CaptionLabel;
                Gtk::Label *m_DescLabel;
                
                // scrolled window container
                Gtk::ScrolledWindow *m_SWindow;
                
                // image for previews
                Gtk::Image *m_Image;
                
                // entries
                Gtk::Entry *m_InternalEntry;
                Gtk::Entry *m_NameEntry;
                Gtk::Entry *m_CaptionEntry;
                Gtk::Entry *m_DescEntry;
                
                // check buttons
                Gtk::CheckButton *m_HasImgCB;
                
                // combo boxes
                ImgComboBox *m_ImgCB;
                
                // buttons
                Gtk::Button *m_AddButton;
                Gtk::Button *m_DeleteButton;
                Gtk::Button *m_AmendButton;
                
                // column record
                class ColumnRec: public Gtk::TreeModel::ColumnRecord {
                        public:
                                // constructor
                                ColumnRec() {
                                        add(m_Column);
                                }
                                
                                // columns
                                Gtk::TreeModelColumn<Glib::ustring> m_Column;
                };
                
                // column record instance
                ColumnRec m_ColumnRec;
                
                // record of evidence data
                EvidenceMap m_Evidence;
                StringVector m_EvidenceIds;
};

/***************************************************************************/

class BackgroundsDialog: public Gtk::Dialog {
        public:
                BackgroundsDialog(const BackgroundMap &bgs,
                                  const StringVector &bgIds);
                
                BackgroundMap get_backgrounds() const { return m_Backgrounds; }
                
        private:
                // build the ui
                void construct();
                
                // add a background
                void on_add();
                
                // remove a background
                void on_delete();
                
                // row changes handler
                void on_selection_changed();
                
                // scrolled window container
                Gtk::ScrolledWindow *m_SWindow;
                
                // list view for managing backgrounds
                Gtk::TreeView *m_ListView;
                Glib::RefPtr<Gtk::ListStore> m_ListModel;
                
                // image
                Gtk::Image *m_Image;
                
                // labels
                Gtk::Label *m_BGLabel;
                Gtk::Label *m_PreviewLabel;
                
                // buttons
                Gtk::Button *m_AddButton;
                Gtk::Button *m_DeleteButton;
                
                // column record
                class ColumnRec: public Gtk::TreeModel::ColumnRecord {
                        public:
                                // constructor
                                ColumnRec() {
                                        add(m_Column);
                                }
                                
                                // columns
                                Gtk::TreeModelColumn<Glib::ustring> m_Column;
                };
                
                // column record instance
                ColumnRec m_ColumnRec;
                
                // record of background data
                BackgroundMap m_Backgrounds;
                StringVector m_BGIds;
};

/***************************************************************************/

class NewBackgroundDialog: public Gtk::Dialog {
        public:
                NewBackgroundDialog(const StringVector &bgIds);
                
                Case::Background get_background_data();
                
                Glib::ustring get_path() const { return m_PathEntry->get_text(); }
                
        private:
                // build the ui
                void construct();
                
                // browse button click handler
                void on_browse_button_clicked();
                
                // id entry text change handler
                void on_id_changed();
                
                // labels
                Gtk::Label *m_PathLabel;
                Gtk::Label *m_IdLabel;
                Gtk::Label *m_TypeLabel;
                
                // entries
                Gtk::Entry *m_PathEntry;
                Gtk::Entry *m_IdEntry;
                
                // radio buttons
                Gtk::RadioButton::Group m_RBGroup;
                Gtk::RadioButton *m_SingleScreenRB;
                Gtk::RadioButton *m_DoubleScreenRB;
                
                // buttons
                Gtk::Button *m_OKButton;
                Gtk::Button *m_BrowseButton;
                
                // record of background ids
                StringVector m_UsedBGs;
};

/***************************************************************************/

class NewDialog: public Gtk::Dialog {
        public:
                NewDialog();
                
                void set_overview(const Case::Overview &overview);
                
                Case::Overview get_overview();
        
        private:
                // build the ui
                void construct();
                
                // labels
                Gtk::Label *m_CaseNameLabel;
                Gtk::Label *m_CaseAuthorLabel;
                Gtk::Label *m_LawSysLabel;
                
                // entries
                Gtk::Entry *m_CaseNameEntry;
                Gtk::Entry *m_CaseAuthorEntry;
                
                // combo boxes
                Gtk::ComboBoxText *m_LawSysCB;
};

/***************************************************************************/

class CharBrowser: public Gtk::Dialog {
        public:
                CharBrowser(const CharacterMap &cmap);
                
                bool was_changed() const { return m_CharChanged; }
                
                CharacterMap get_characters() const { return m_CharacterMap; }
                
        private:
                // build the ui
                void construct();
                
                // edit button handler
                void on_edit_button_clicked();
                
                // combo box selectio changes
                void on_combo_box_changed();
                
                // see if a character was changed
                bool m_CharChanged;
                
                // labels
                Gtk::Label *m_CharacterLabel;
                Gtk::Label *m_InternalLabel;
                Gtk::Label *m_NameLabel;
                Gtk::Label *m_DescLabel;
                
                // entries
                Gtk::Entry *m_InternalEntry;
                Gtk::Entry *m_NameEntry;
                Gtk::Entry *m_DescEntry;
                
                // buttons
                Gtk::Button *m_EditButton;
                
                // combo boxes
                Gtk::ComboBoxText *m_CharCB;
                
                // internal record of characters
                CharacterMap m_CharacterMap;
};

/***************************************************************************/

class NewCharDialog: public Gtk::Dialog {
        public:
                NewCharDialog(const StringVector &names);
                
                void set_character_data(const Character &ch);
                
                Character get_character_data();
                
        private:
                // build the ui
                void construct();
                
                // signal handler for internal name text changes
                void on_internal_name_changed();
                
                // signal handler for check button clicks
                void on_check_button_clicked(const Glib::ustring &buttonId);
                
                // signal handler for browse button clicks
                void on_browse_button_clicked(const Glib::ustring &buttonId);
                
                // flag if internal names should be checked
                bool m_CheckInternals;
                
                // build the general page
                Gtk::Container* build_general_page();
                
                // build the graphics page
                Gtk::Container* build_graphics_page();
                
                // radio buttons
                Gtk::RadioButtonGroup m_Group;
                Gtk::RadioButton *m_MaleRB;
                Gtk::RadioButton *m_FemaleRB;
                Gtk::RadioButton *m_UnknownRB;
                
                // check buttons
                Gtk::CheckButton *m_HasTagCB;
                Gtk::CheckButton *m_HasHeadshotCB;
                
                // notebook for tabs
                Gtk::Notebook *m_NB;
                
                // buttons
                Gtk::Button *m_OKButton;
                Gtk::Button *m_TagBrowseButton;
                Gtk::Button *m_HeadshotBrowseButton;
                
                // labels
                Gtk::Label *m_CodeNameLabel;
                Gtk::Label *m_NameLabel;
                Gtk::Label *m_GenderLabel;
                Gtk::Label *m_CapLabel;
                Gtk::Label *m_DescLabel;
                Gtk::Label *m_SpriteLabel;
                Gtk::Label *m_TextBoxLabel;
                Gtk::Label *m_HeadshotLabel;
                
                // entries
                Gtk::Entry *m_CodeNameEntry;
                Gtk::Entry *m_NameEntry;
                Gtk::Entry *m_CapEntry;
                Gtk::Entry *m_DescEntry;
                Gtk::Entry *m_SpriteEntry;
                
                // images
                Gtk::Image *m_TextBoxImage;
                Gtk::Image *m_HeadshotImage;
                
                // record of already present character internal names (used for validation)
                StringVector m_UsedNames;
};

/***************************************************************************/

class InitialBlockDialog: public Gtk::Dialog {
        public:
                InitialBlockDialog(const Glib::ustring &id, BufferMap blocks);
                
                Glib::ustring get_selected_block_id() const { return m_BlocksCB->get_active_text(); }
                
        private:
                // build the ui
                void construct();
                
                // block cb changes
                void on_block_changed();
                
                // scrolled window for text view
                Gtk::ScrolledWindow *m_SWindow;
                
                // text view
                Gtk::TextView *m_TextPreview;
                
                // combo box
                Gtk::ComboBoxText *m_BlocksCB;
                
                // labels
                Gtk::Label *m_BlockLabel;
                Gtk::Label *m_PreviewLabel;
                
                // record of text blocks
                BufferMap m_Blocks;
};

#endif

---