/home/martin/src/mimasim/src/mima_gtk/mimaMem.h

Go to the documentation of this file.

//$Id: mimaMem.h,v 1.11 2006/11/04 17:09:02 der_martin Exp $
/*
 * mimasim -- a simulator of a minimal microprocessor system
 * Copyright (C) 2006 Martin Grandrath <gr@ndrath.de>
 *
 * 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., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */

#ifndef MIMAMEM_H
#define MIMAMEM_H

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <gtkmm/frame.h>
#include <gtkmm/box.h>
#include <gtkmm/scrolledwindow.h>
#include <gtkmm/treemodel.h>
#include <gtkmm/treeview.h>
#include <gtkmm/liststore.h>
#include <gtkmm/dialog.h>
#include <gtkmm/table.h>
#include <gtkmm/alignment.h>
#include <gtkmm/label.h>

#include <gtkmm/uimanager.h>

#include <sigc++/sigc++.h>
#include <glibmm.h>
#include <map>

#include <mima.h>
#include "mimaWidgets.h" // for EntryInt
#include "mimaChildWindow.h"

//declare classes
namespace MimaGtk {
     class MimaMem;
     class MimaMemMenu;
     class MimaMemWnd;
}

namespace MimaGtk {


     class MimaMem : public Gtk::Frame
          {
          private:
               enum RESPONSE {
                    OK,
                    APPLY,
                    CLOSE
               };

               class DialogMemoryRange : public Gtk::Dialog
                    {
                    protected:
                         /*
                          * Member widgets
                          * ==============
                          */
                         Gtk::Table m_table;
                         Gtk::Alignment m_align_start,
                              m_align_end;
                         Gtk::Label m_label_start,
                              m_label_end;
                         EntryInt m_entry_start,
                              m_entry_end;
                         void activate();

                    public:
                         DialogMemoryRange();
                         DialogMemoryRange(Glib::ustring title);
                         ~DialogMemoryRange();

                         void init();
                         int get_start();
                         int get_end();
                         void set_start(int start) { m_entry_start.set_value(start); };
                         void set_end(int end)     { m_entry_end.set_value(end);     };
                    };

               /*
                * private typedefs
                * ================
                */
               typedef Gtk::TreeModel::Children     type_children;
               typedef sigc::signal<int>            type_signal_int;
               typedef sigc::signal<int, int>       type_signal_int_int;
               typedef sigc::signal<bool, int>      type_signal_bool_int;
               typedef sigc::signal<void, int, int> type_signal_void_int_int;
               typedef sigc::signal<type_memory_map, int, int> type_signal_memmap_int_int;
               typedef sigc::signal<type_breakpoint_list> type_signal_breakpoint_list_void;

               /*
                * private attributes
                * ==================
                */
               int m_addr_start,
                    m_show_n_words,
                    m_memsize,
                    m_iar;
               std::map<int, bool> m_breakpoints;
               DialogMemoryRange m_dialog;

               /*
                * private members
                * ===============
                */
               void on_dialog_response(int response);

          protected:
               class ModelColumns : public Gtk::TreeModel::ColumnRecord
                    {
                    public:
                         ModelColumns()
                              {
                                   /*
                                    * add columns
                                    */
                                   add(m_col_addr);
                                   add(m_col_value);
                              }
                         Gtk::TreeModelColumn<int> m_col_addr;
                         Gtk::TreeModelColumn<int> m_col_value;
                    };

               ModelColumns m_Columns;

               /*
                * signals
                * =======
                */
               type_signal_int          m_signal_get_memsize;
               type_signal_int          m_signal_get_iar;
               type_signal_int_int      m_signal_get_memory;
               type_signal_bool_int     m_signal_get_breakpoint;
               type_signal_bool_int     m_signal_toggle_breakpoint;
               type_signal_void_int_int m_signal_set_memory;
               type_signal_memmap_int_int m_signal_get_memmap;
               type_signal_breakpoint_list_void m_signal_get_breakpoint_list;

               /*
                * protected members
                * =================
                */
               virtual void on_edited(const Glib::ustring& path_string, const Glib::ustring& new_text);
               void cell_data(Gtk::CellRenderer *renderer, const Gtk::TreeIter &iter);

               /*
                * child widgets
                * =============
                */
               Gtk::ScrolledWindow m_scrolledWindow;
               Gtk::TreeView m_treeView;
               Glib::RefPtr<Gtk::ListStore> m_refTreeModel;
               Gtk::CellRendererText *m_cellrenderer_addr,  *m_cellrenderer_value; // columns are manually rendered

          public:
               MimaMem();
               ~MimaMem();

               /*
                * signal accessors
                * ================
                */
               type_signal_int          signal_get_iar()           { return m_signal_get_iar;          };
               type_signal_int          signal_get_memsize()       { return m_signal_get_memsize;      };
               type_signal_int_int      signal_get_memory()        { return m_signal_get_memory;       };
               type_signal_memmap_int_int signal_get_memory_map()  { return m_signal_get_memmap;       };
               type_signal_bool_int     signal_get_breakpoint()    { return m_signal_get_breakpoint;   };
               type_signal_breakpoint_list_void signal_get_breakpoint_list() { return m_signal_get_breakpoint_list; };
               type_signal_bool_int     signal_toggle_breakpoint() { return m_signal_toggle_breakpoint;};
               type_signal_void_int_int signal_set_memory()        { return m_signal_set_memory;       };

               /*
                * public members
                * ==============
                */
               void show_dialog_memory_range();
               void set_memory_range(int start, int n_words = 16);
               void on_iar_changed(int iar);
               void on_state_changed(MimaSim::State state);
               void on_memory_value_changed(int address, int value);
               void on_memory_breakpoint_changed(int address, bool breakpoint);
               void on_memsize_changed(int size);
               void on_memory_clear();

               int get_current_address();
               int get_current_address_end() const
                    { return m_addr_start + m_show_n_words - 1; }

               void refreshModel();
          };


     class MimaMemMenu
          {
          private:
               typedef sigc::signal<void> type_signal_void;

          protected:
               type_signal_void
                    m_signal_memory_range,
                    m_signal_breakpoint_add,
                    m_signal_breakpoint_remove,
                    m_signal_breakpoint_remove_all;

               /*
                * menu handlers
                * =============
                */
               void on_menu_view_memory_range();
               void on_menu_breakpoint_add();
               void on_menu_breakpoint_remove();
               void on_menu_breakpoint_remove_all();

          public:
               MimaMemMenu();
               ~MimaMemMenu() {};

               Glib::RefPtr<Gtk::UIManager>   UIManager;
               Glib::RefPtr<Gtk::ActionGroup> ActionGroup;

               /*
                * signal accessors
                * ================
                */
               type_signal_void signal_memory_range()          { return m_signal_memory_range;          };
               type_signal_void signal_breakpoint_add()        { return m_signal_breakpoint_add;        };
               type_signal_void signal_breakpoint_remove()     { return m_signal_breakpoint_remove;     };
               type_signal_void signal_breakpoint_remove_all() { return m_signal_breakpoint_remove_all; };

          };



     class MimaMemWnd : public MimaChildWindow
          {
          private:

               /*
                * signal connections
                * ==================
                */
               sigc::connection
                    /* MimaMemMenu -> MimaMem */
                    m_connection_memory_range,
                    /* MimaMemMenu -> MimaMemWnd */
                    m_connection_breakpoint_add,
                    m_connection_breakpoint_remove,
                    m_connection_breakpoint_remove_all,
                    /* Mima -> MimaMem */
                    m_connection_iar_changed,
                    m_connection_memory_value_changed,
                    m_connection_memory_breakpoint_changed,
                    m_connection_memory_clear,
                    /* MimaMem -> Mima */
                    m_connection_get_iar,
                    m_connection_set_memory,
                    m_connection_get_memory,
                    m_connection_get_memory_map,
                    m_connection_get_breakpoint_list,
                    m_connection_get_breakpoint;

          protected:
               virtual bool ask_to_save();

               static int m_count;

               /*
                * child widgets
                * =============
                */
               MimaMemMenu m_mimaMemMenu;
               MimaMem     m_mimaMemFrame;

               Gtk::VBox   m_vbox;

               /*
                * signal handlers
                * ===============
                */
               void on_breakpoint_add();
               void on_breakpoint_remove();
               void on_breakpoint_remove_all();

          public:
               MimaMemWnd(MimaSim::Mima *_mima);
               ~MimaMemWnd();

               virtual ChildWindowType type()
                    { return MEM; }

               int get_current_address()
                    { return m_mimaMemFrame.get_current_address(); }
               int get_current_address_end()
                    { return m_mimaMemFrame.get_current_address_end(); }
          };

}

#endif // MIMAMEM_H

---