/* Copyright 2007 The gtkmm Development Team
 *
 * This library 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.1 of the License, or (at your option) any later version.
 *
 * This library 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 library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include <glibmm/vectorutils.h>
#include <gtkmm/application.h>

#include <gtk/gtk.h>

// Allow GtkBuilder to instantiate a gtkmm derived GType instead of the regular
// GTK+ GType, so we can, for instance, use our vfuncs and default signal handlers.
static GType
get_type_from_name_vfunc_callback(GtkBuilder*, const char* type_name)
{
  if (!type_name)
    return G_TYPE_INVALID;

  // See if there is a gtkmm version of the gclass:
  Glib::ustring classname_prefixed ("gtkmm__"); // gtkmm uses a prefix
  classname_prefixed += type_name;

  GType gtype = g_type_from_name(classname_prefixed.c_str());

  if(gtype == G_TYPE_INVALID) // if it's not a registered typename
  {
    // There's no gtkmm derived type, so just use the normal one.
    gtype = g_type_from_name(type_name);
  }

  return gtype;
}

namespace Gtk
{

// static
Glib::RefPtr<Builder> Builder::create_from_file(const std::string& filename)
{
  Glib::RefPtr<Builder> builder = Builder::create();
  if(builder->add_from_file(filename))
    return builder;
  else
    return Glib::RefPtr<Builder>();
}

// static
Glib::RefPtr<Builder> Builder::create_from_file(const std::string& filename, const char* object_id)
{
  Glib::RefPtr<Builder> builder = Builder::create();
  if(builder->add_from_file(filename, object_id))
    return builder;
  else
    return Glib::RefPtr<Builder>();
}

//static
Glib::RefPtr<Builder> Builder::create_from_file(const std::string& filename, const Glib::ustring& object_id)
{
  Glib::RefPtr<Builder> builder = Builder::create();
  if(builder->add_from_file(filename, object_id))
    return builder;
  else
    return Glib::RefPtr<Builder>();
}

//static
Glib::RefPtr<Builder> Builder::create_from_file(const std::string& filename, const std::vector<Glib::ustring>& object_ids)
{
  Glib::RefPtr<Builder> builder = Builder::create();
  if(builder->add_from_file(filename, object_ids))
    return builder;
  else
    return Glib::RefPtr<Builder>();
}

// static
Glib::RefPtr<Builder> Builder::create_from_resource(const std::string& resource_path)
{
  Glib::RefPtr<Builder> builder = Builder::create();
  if(builder->add_from_resource(resource_path))
    return builder;
  else
    return Glib::RefPtr<Builder>();
}

// static
Glib::RefPtr<Builder> Builder::create_from_resource(const std::string& resource_path, const char* object_id)
{
  Glib::RefPtr<Builder> builder = Builder::create();
  if(builder->add_from_resource(resource_path, object_id))
    return builder;
  else
    return Glib::RefPtr<Builder>();
}

//static
Glib::RefPtr<Builder> Builder::create_from_resource(const std::string& resource_path, const Glib::ustring& object_id)
{
  Glib::RefPtr<Builder> builder = Builder::create();
  if(builder->add_from_resource(resource_path, object_id))
    return builder;
  else
    return Glib::RefPtr<Builder>();
}

//static
Glib::RefPtr<Builder> Builder::create_from_resource(const std::string& resource_path, const std::vector<Glib::ustring>& object_ids)
{
  Glib::RefPtr<Builder> builder = Builder::create();
  if(builder->add_from_resource(resource_path, object_ids))
    return builder;
  else
    return Glib::RefPtr<Builder>();
}

//static
Glib::RefPtr<Builder> Builder::create_from_string(const Glib::ustring& buffer)
{
  Glib::RefPtr<Builder> builder = Builder::create();
  if(builder->add_from_string(buffer))
    return builder;
  else
    return Glib::RefPtr<Builder>();
}

//static
Glib::RefPtr<Builder> Builder::create_from_string(const Glib::ustring& buffer,
                                                  const char* object_id)
{
  Glib::RefPtr<Builder> builder = Builder::create();
  if(builder->add_from_string(buffer, object_id))
    return builder;
  else
    return Glib::RefPtr<Builder>();
}

//static
Glib::RefPtr<Builder> Builder::create_from_string(const Glib::ustring& buffer,
                                                  const Glib::ustring& object_id)
{
  Glib::RefPtr<Builder> builder = Builder::create();
  if(builder->add_from_string(buffer, object_id))
    return builder;
  else
    return Glib::RefPtr<Builder>();
}

//static
Glib::RefPtr<Builder> Builder::create_from_string(const Glib::ustring& buffer,
                                                  const std::vector<Glib::ustring>& object_ids)
{
  Glib::RefPtr<Builder> builder = Builder::create();
  if(builder->add_from_string(buffer, object_ids))
    return builder;
  else
    return Glib::RefPtr<Builder>();
}

bool Builder::add_from_file(const std::string& filename, const char* object_id)
{
  std::vector<Glib::ustring> object_ids (1, object_id);

  return add_from_file(filename, object_ids);
}

bool Builder::add_from_file(const std::string& filename, const Glib::ustring& object_id)
{
  std::vector<Glib::ustring> object_ids (1, object_id);

  return add_from_file(filename, object_ids);
}

bool Builder::add_from_resource(const std::string& resource_path, const char* object_id)
{
  std::vector<Glib::ustring> object_ids (1, object_id);

  return add_from_resource(resource_path, object_ids);
}

bool Builder::add_from_resource(const std::string& resource_path, const Glib::ustring& object_id)
{
  std::vector<Glib::ustring> object_ids (1, object_id);

  return add_from_resource(resource_path, object_ids);
}

bool Builder::add_from_string(const Glib::ustring& buffer)
{
  GError* gerror = 0;
  bool retvalue = gtk_builder_add_from_string(gobj(), buffer.c_str(), -1 /* means null-terminated */, &(gerror));
  if(gerror)
    ::Glib::Error::throw_exception(gerror);

  return retvalue;
}


bool Builder::add_from_string(const Glib::ustring& buffer, const char* object_id)
{
  std::vector<Glib::ustring> object_ids (1, object_id);

  return add_from_string(buffer, object_ids);
}

bool Builder::add_from_string(const Glib::ustring& buffer, const Glib::ustring& object_id)
{
  std::vector<Glib::ustring> object_ids (1, object_id);

  return add_from_string(buffer, object_ids);
}

bool Builder::add_from_string(const Glib::ustring& buffer, const std::vector<Glib::ustring>& object_ids)
{
  GError* gerror = 0;
  bool retvalue = gtk_builder_add_objects_from_string(
    gobj(),
    buffer.c_str(),
    -1 /* means null-terminated */,
    const_cast<char**>(Glib::ArrayHandler<Glib::ustring>::vector_to_array(object_ids).data ()),
    &(gerror));
  if(gerror)
    ::Glib::Error::throw_exception(gerror);

  return retvalue;
}

GtkWidget* Builder::get_cwidget(const Glib::ustring& name)
{
  GObject *cobject = gtk_builder_get_object (gobj(), name.c_str());
  if(!cobject)
  {
    g_critical("gtkmm: object `%s' not found in GtkBuilder file.", name.c_str());
    return 0;
  }

  if (!GTK_IS_WIDGET (cobject))
  {
    g_critical("gtkmm: object `%s' (type=`%s') (in GtkBuilder file) is not a widget type.",
               name.c_str(), G_OBJECT_TYPE_NAME(cobject));
    // Don't unref cobject. gtk_builder_get_object() does not give us a reference.
    return 0;
  }

  return GTK_WIDGET (cobject);
}

Gtk::Widget* Builder::get_widget_checked(const Glib::ustring& name, GType type)
{
  // Get the widget from the GtkBuilder file.
  GtkWidget *cobject = get_cwidget(name);
  if(!cobject)
  {
    g_critical("gtkmm: Gtk::Buidler: widget `%s' was not found in the GtkBuilder file, or the specified part of it.",
      name.c_str());
    return 0;
  }

  // Check if it has the correct type.
  if(!g_type_is_a(G_OBJECT_TYPE(cobject), type))
  {
    g_critical("gtkmm: widget `%s' (in GtkBuilder file) is of type `%s' but `%s' was expected",
               name.c_str(), G_OBJECT_TYPE_NAME(cobject), g_type_name(type));
    return 0;
  }

  // Don't take a reference. That's done only in methods that return
  // a Glib::RefPtr<Something>.
  return Glib::wrap (GTK_WIDGET (cobject), false /* take ref */);
}

} // namespace Gtk
