GType
ags_set_audio_channels_get_type()
{
  static GType ags_type_set_audio_channels = 0;

  if(!ags_type_set_audio_channels){
    static const GTypeInfo ags_set_audio_channels_info = {
      sizeof (AgsSetAudioChannelsClass),
      NULL, /* base_init */
      NULL, /* base_finalize */
      (GClassInitFunc) ags_set_audio_channels_class_init,
      NULL, /* class_finalize */
      NULL, /* class_data */
      sizeof (AgsSetAudioChannels),
      0,    /* n_preallocs */
      (GInstanceInitFunc) ags_set_audio_channels_init,
    };

    static const GInterfaceInfo ags_connectable_interface_info = {
      (GInterfaceInitFunc) ags_set_audio_channels_connectable_interface_init,
      NULL, /* interface_finalize */
      NULL, /* interface_data */
    };

    ags_type_set_audio_channels = g_type_register_static(AGS_TYPE_TASK,
							 "AgsSetAudioChannels\0",
							 &ags_set_audio_channels_info,
							 0);
    
    g_type_add_interface_static(ags_type_set_audio_channels,
				AGS_TYPE_CONNECTABLE,
				&ags_connectable_interface_info);
  }
  
  return (ags_type_set_audio_channels);
}
Exemple #2
0
GType
gimp_data_get_type (void)
{
  static GType data_type = 0;

  if (! data_type)
    {
      const GTypeInfo data_info =
      {
        sizeof (GimpDataClass),
        (GBaseInitFunc) NULL,
        (GBaseFinalizeFunc) NULL,
        (GClassInitFunc) gimp_data_class_init,
        NULL,           /* class_finalize */
        NULL,           /* class_data     */
        sizeof (GimpData),
        0,              /* n_preallocs    */
        (GInstanceInitFunc) gimp_data_init,
      };

      const GInterfaceInfo tagged_info =
      {
        (GInterfaceInitFunc) gimp_data_tagged_iface_init,
        NULL,           /* interface_finalize */
        NULL            /* interface_data     */
      };

      data_type = g_type_register_static (GIMP_TYPE_VIEWABLE,
                                          "GimpData",
                                          &data_info, 0);

      g_type_add_interface_static (data_type, GIMP_TYPE_TAGGED, &tagged_info);
    }

  return data_type;
}
Exemple #3
0
GType
gail_adjustment_get_type (void)
{
  static GType type = 0;

  if (!type)
  {
    static const GTypeInfo tinfo =
    {
      sizeof (GailAdjustmentClass),
      (GBaseInitFunc) NULL, /* base init */
      (GBaseFinalizeFunc) NULL, /* base finalize */
      (GClassInitFunc) gail_adjustment_class_init, /* class init */
      (GClassFinalizeFunc) NULL, /* class finalize */
      NULL, /* class data */
      sizeof (GailAdjustment), /* instance size */
      0, /* nb preallocs */
      (GInstanceInitFunc) NULL, /* instance init */
      NULL /* value table */
    };

    static const GInterfaceInfo atk_value_info =
    {
        (GInterfaceInitFunc) atk_value_interface_init,
        (GInterfaceFinalizeFunc) NULL,
        NULL
    };

    type = g_type_register_static (ATK_TYPE_OBJECT,
                                   "GailAdjustment", &tinfo, 0);

    g_type_add_interface_static (type, ATK_TYPE_VALUE,
                                 &atk_value_info);
  }
  return type;
}
Exemple #4
0
GType
ags_devout_thread_get_type()
{
  static GType ags_type_devout_thread = 0;

  if(!ags_type_devout_thread){
    static const GTypeInfo ags_devout_thread_info = {
      sizeof (AgsDevoutThreadClass),
      NULL, /* base_init */
      NULL, /* base_finalize */
      (GClassInitFunc) ags_devout_thread_class_init,
      NULL, /* class_finalize */
      NULL, /* class_data */
      sizeof (AgsDevoutThread),
      0,    /* n_preallocs */
      (GInstanceInitFunc) ags_devout_thread_init,
    };

    static const GInterfaceInfo ags_connectable_interface_info = {
      (GInterfaceInitFunc) ags_devout_thread_connectable_interface_init,
      NULL, /* interface_finalize */
      NULL, /* interface_data */
    };

    ags_type_devout_thread = g_type_register_static(AGS_TYPE_THREAD,
						    "AgsDevoutThread\0",
						    &ags_devout_thread_info,
						    0);
    
    g_type_add_interface_static(ags_type_devout_thread,
				AGS_TYPE_CONNECTABLE,
				&ags_connectable_interface_info);
  }
  
  return (ags_type_devout_thread);
}
Exemple #5
0
GType
gda_data_model_array_get_type (void)
{
	static GType type = 0;

	if (G_UNLIKELY (type == 0)) {
		static GMutex registering;
		static const GTypeInfo info = {
			sizeof (GdaDataModelArrayClass),
			(GBaseInitFunc) NULL,
			(GBaseFinalizeFunc) NULL,
			(GClassInitFunc) gda_data_model_array_class_init,
			NULL,
			NULL,
			sizeof (GdaDataModelArray),
			0,
			(GInstanceInitFunc) gda_data_model_array_init,
			0
		};

		static const GInterfaceInfo data_model_info = {
                        (GInterfaceInitFunc) gda_data_model_array_data_model_init,
                        NULL,
                        NULL
                };


		g_mutex_lock (&registering);
		if (type == 0) {
			type = g_type_register_static (G_TYPE_OBJECT, "GdaDataModelArray", &info, 0);
			g_type_add_interface_static (type, GDA_TYPE_DATA_MODEL, &data_model_info);
		}
		g_mutex_unlock (&registering);
	}
	return type;
}
GType
ags_thread_pool_get_type()
{
  static GType ags_type_thread_pool = 0;

  if(!ags_type_thread_pool){
    static const GTypeInfo ags_thread_pool_info = {
      sizeof (AgsThreadPoolClass),
      NULL, /* base_init */
      NULL, /* base_finalize */
      (GClassInitFunc) ags_thread_pool_class_init,
      NULL, /* class_finalize */
      NULL, /* class_data */
      sizeof (AgsThreadPool),
      0,    /* n_preallocs */
      (GInstanceInitFunc) ags_thread_pool_init,
    };

    static const GInterfaceInfo ags_connectable_interface_info = {
      (GInterfaceInitFunc) ags_thread_pool_connectable_interface_init,
      NULL, /* interface_finalize */
      NULL, /* interface_data */
    };

    ags_type_thread_pool = g_type_register_static(G_TYPE_OBJECT,
						  "AgsThreadPool\0",
						  &ags_thread_pool_info,
						  0);

    g_type_add_interface_static(ags_type_thread_pool,
				AGS_TYPE_CONNECTABLE,
				&ags_connectable_interface_info);
  }

  return (ags_type_thread_pool);
}
Exemple #7
0
GType
gail_canvas_item_get_type (void)
{
  static GType type = 0;

  if (!type)
    {
      static const GTypeInfo tinfo =
      {
        sizeof (GailCanvasItemClass),
        (GBaseInitFunc) NULL, /* base init */
        (GBaseFinalizeFunc) NULL, /* base finalize */
        (GClassInitFunc) gail_canvas_item_class_init, /* class init */
        (GClassFinalizeFunc) NULL, /* class finalize */
        NULL, /* class data */
        sizeof (GailCanvasItem), /* instance size */
        0, /* nb preallocs */
        (GInstanceInitFunc) NULL, /* instance init */
        NULL /* value table */
      };

      static const GInterfaceInfo atk_component_info =
      {
        (GInterfaceInitFunc) gail_canvas_item_component_interface_init,
        (GInterfaceFinalizeFunc) NULL,
        NULL
      };

      type = g_type_register_static (ATK_TYPE_GOBJECT_ACCESSIBLE,
                                     "GailCanvasItem", &tinfo, 0);
      g_type_add_interface_static (type, ATK_TYPE_COMPONENT,
                                   &atk_component_info);
    }

  return type;
}
Exemple #8
0
GType
gtk_cell_view_get_type (void)
{
  static GType cell_view_type = 0;

  if (!cell_view_type)
    {
      static const GTypeInfo cell_view_info =
        {
          sizeof (GtkCellViewClass),
          NULL, /* base_init */
          NULL, /* base_finalize */
          (GClassInitFunc) gtk_cell_view_class_init,
          NULL, /* class_finalize */
          NULL, /* class_data */
          sizeof (GtkCellView),
          0,
          (GInstanceInitFunc) gtk_cell_view_init
        };

      static const GInterfaceInfo cell_layout_info =
       {
         (GInterfaceInitFunc) gtk_cell_view_cell_layout_init,
         NULL,
         NULL
       };

      cell_view_type = g_type_register_static (GTK_TYPE_WIDGET, "PidginCellView",
                                               &cell_view_info, 0);

      g_type_add_interface_static (cell_view_type, GTK_TYPE_CELL_LAYOUT,
                                   &cell_layout_info);
    }

  return cell_view_type;
}
Exemple #9
0
GType custom_undo_manager_get_type (void)
{
  /* Some boilerplate type registration stuff */
  static GType custom_undo_manager_type = 0;

  if (custom_undo_manager_type == 0)
  {
    const GTypeInfo custom_undo_manager_info =
    {
      sizeof (CustomUndoManagerClass),
      NULL,                                         /* base_init */
      NULL,                                         /* base_finalize */
      (GClassInitFunc) custom_undo_manager_class_init,
      NULL,                                         /* class finalize */
      NULL,                                         /* class_data */
      sizeof (CustomUndoManager),
      0,                                           /* n_preallocs */
      NULL
    };

    static const GInterfaceInfo source_undo_manager_info =
    {
      (GInterfaceInitFunc) custom_undo_manager_interface_init,
      NULL,
      NULL
    };

    custom_undo_manager_type = g_type_register_static (G_TYPE_OBJECT, "custom_undo_manager",
                                               &custom_undo_manager_info, (GTypeFlags)0);

    /* Here we register our GtkTreeModel interface with the type system */
    g_type_add_interface_static (custom_undo_manager_type, GTK_TYPE_SOURCE_UNDO_MANAGER, &source_undo_manager_info);
  }

  return custom_undo_manager_type;
}
GType
ags_client_toolbar_get_type()
{
  static GType ags_type_client_toolbar = 0;

  if(!ags_type_client_toolbar){
    static const GTypeInfo ags_client_toolbar_info = {
      sizeof (AgsClientToolbarClass),
      NULL, /* base_init */
      NULL, /* base_finalize */
      (GClassInitFunc) ags_client_toolbar_class_init,
      NULL, /* class_finalize */
      NULL, /* class_data */
      sizeof (AgsClientToolbar),
      0,    /* n_preallocs */
      (GInstanceInitFunc) ags_client_toolbar_init,
    };

    static const GInterfaceInfo ags_connectable_interface_info = {
      (GInterfaceInitFunc) ags_client_toolbar_connectable_interface_init,
      NULL, /* interface_finalize */
      NULL, /* interface_data */
    };
    
    ags_type_client_toolbar = g_type_register_static(GTK_TYPE_TOOLBAR,
						     "AgsClientToolbar\0",
						     &ags_client_toolbar_info,
						     0);
    
    g_type_add_interface_static(ags_type_client_toolbar,
				AGS_TYPE_CONNECTABLE,
				&ags_connectable_interface_info);
  }

  return (ags_type_client_toolbar);
}
GType
ags_application_context_get_type()
{
  static GType ags_type_application_context = 0;

  if(!ags_type_application_context){
    static const GTypeInfo ags_application_context_info = {
      sizeof (AgsApplicationContextClass),
      NULL, /* base_init */
      NULL, /* base_finalize */
      (GClassInitFunc) ags_application_context_class_init,
      NULL, /* class_finalize */
      NULL, /* class_data */
      sizeof (AgsApplicationContext),
      0,    /* n_preallocs */
      (GInstanceInitFunc) ags_application_context_init,
    };

    static const GInterfaceInfo ags_connectable_interface_info = {
      (GInterfaceInitFunc) ags_application_context_connectable_interface_init,
      NULL, /* interface_finalize */
      NULL, /* interface_data */
    };

    ags_type_application_context = g_type_register_static(G_TYPE_OBJECT,
							  "AgsApplicationContext\0",
							  &ags_application_context_info,
							  0);

    g_type_add_interface_static(ags_type_application_context,
				AGS_TYPE_CONNECTABLE,
				&ags_connectable_interface_info);
  }

  return (ags_type_application_context);
}
Exemple #12
0
GType
psppire_var_store_get_type (void)
{
  static GType var_store_type = 0;

  if (!var_store_type)
    {
      static const GTypeInfo var_store_info =
      {
	sizeof (PsppireVarStoreClass),
	NULL,		/* base_init */
	NULL,		/* base_finalize */
        (GClassInitFunc) psppire_var_store_class_init,
	NULL,		/* class_finalize */
	NULL,		/* class_data */
        sizeof (PsppireVarStore),
	0,
        (GInstanceInitFunc) psppire_var_store_init,
      };

      static const GInterfaceInfo sheet_model_info =
      {
	(GInterfaceInitFunc) psppire_var_store_sheet_model_init,
	NULL,
	NULL
      };

      var_store_type = g_type_register_static (G_TYPE_OBJECT, "PsppireVarStore", &var_store_info, 0);

      g_type_add_interface_static (var_store_type,
				   PSPPIRE_TYPE_SHEET_MODEL,
				   &sheet_model_info);
    }

  return var_store_type;
}
Exemple #13
0
GType
ags_count_beats_audio_get_type()
{
  static GType ags_type_count_beats_audio = 0;

  if(!ags_type_count_beats_audio){
    static const GTypeInfo ags_count_beats_audio_info = {
      sizeof (AgsCountBeatsAudioClass),
      NULL, /* base_init */
      NULL, /* base_finalize */
      (GClassInitFunc) ags_count_beats_audio_class_init,
      NULL, /* class_finalize */
      NULL, /* class_data */
      sizeof (AgsCountBeatsAudio),
      0,    /* n_preallocs */
      (GInstanceInitFunc) ags_count_beats_audio_init,
    };
    
    static const GInterfaceInfo ags_plugin_interface_info = {
      (GInterfaceInitFunc) ags_count_beats_audio_plugin_interface_init,
      NULL, /* interface_finalize */
      NULL, /* interface_data */
    };
    
    ags_type_count_beats_audio = g_type_register_static(AGS_TYPE_RECALL_AUDIO,
							"AgsCountBeatsAudio\0",
							&ags_count_beats_audio_info,
							0);

    g_type_add_interface_static(ags_type_count_beats_audio,
				AGS_TYPE_PLUGIN,
				&ags_plugin_interface_info);
  }

  return(ags_type_count_beats_audio);
}
Exemple #14
0
GType
ags_script_fprintf_get_type()
{
  static GType ags_type_script_fprintf = 0;

  if(!ags_type_script_fprintf){
    static const GTypeInfo ags_script_fprintf_info = {
      sizeof (AgsScriptFPrintfClass),
      NULL, /* base_init */
      NULL, /* base_finalize */
      (GClassInitFunc) ags_script_fprintf_class_init,
      NULL, /* class_finalize */
      NULL, /* class_data */
      sizeof (AgsScriptFPrintf),
      0,    /* n_preallocs */
      (GInstanceInitFunc) ags_script_fprintf_init,
    };

    static const GInterfaceInfo ags_connectable_interface_info = {
      (GInterfaceInitFunc) ags_script_fprintf_connectable_interface_init,
      NULL, /* interface_finalize */
      NULL, /* interface_data */
    };

    ags_type_script_fprintf = g_type_register_static(AGS_TYPE_SCRIPT_CONTROLLER,
						     "AgsScriptFPrintf\0",
						     &ags_script_fprintf_info,
						     0);
    
    g_type_add_interface_static(ags_type_script_fprintf,
				AGS_TYPE_CONNECTABLE,
				&ags_connectable_interface_info);
  }

  return (ags_type_script_fprintf);
}
GType
ags_open_file_get_type()
{
  static GType ags_type_open_file = 0;

  if(!ags_type_open_file){
    static const GTypeInfo ags_open_file_info = {
      sizeof (AgsOpenFileClass),
      NULL, /* base_init */
      NULL, /* base_finalize */
      (GClassInitFunc) ags_open_file_class_init,
      NULL, /* class_finalize */
      NULL, /* class_data */
      sizeof (AgsOpenFile),
      0,    /* n_preallocs */
      (GInstanceInitFunc) ags_open_file_init,
    };

    static const GInterfaceInfo ags_connectable_interface_info = {
      (GInterfaceInitFunc) ags_open_file_connectable_interface_init,
      NULL, /* interface_finalize */
      NULL, /* interface_data */
    };

    ags_type_open_file = g_type_register_static(AGS_TYPE_TASK,
						"AgsOpenFile\0",
						&ags_open_file_info,
						0);

    g_type_add_interface_static(ags_type_open_file,
				AGS_TYPE_CONNECTABLE,
				&ags_connectable_interface_info);
  }
  
  return (ags_type_open_file);
}
GType
ags_apply_synth_get_type()
{
  static GType ags_type_apply_synth = 0;

  if(!ags_type_apply_synth){
    static const GTypeInfo ags_apply_synth_info = {
      sizeof (AgsApplySynthClass),
      NULL, /* base_init */
      NULL, /* base_finalize */
      (GClassInitFunc) ags_apply_synth_class_init,
      NULL, /* class_finalize */
      NULL, /* class_data */
      sizeof (AgsApplySynth),
      0,    /* n_preallocs */
      (GInstanceInitFunc) ags_apply_synth_init,
    };

    static const GInterfaceInfo ags_connectable_interface_info = {
      (GInterfaceInitFunc) ags_apply_synth_connectable_interface_init,
      NULL, /* interface_finalize */
      NULL, /* interface_data */
    };

    ags_type_apply_synth = g_type_register_static(AGS_TYPE_TASK,
						  "AgsApplySynth\0",
						  &ags_apply_synth_info,
						  0);

    g_type_add_interface_static(ags_type_apply_synth,
				AGS_TYPE_CONNECTABLE,
				&ags_connectable_interface_info);
  }
  
  return (ags_type_apply_synth);
}
GType
ags_recall_container_get_type (void)
{
  static GType ags_type_recall_container = 0;

  if(!ags_type_recall_container){
    static const GTypeInfo ags_recall_container_info = {
      sizeof (AgsRecallContainerClass),
      NULL, /* base_init */
      NULL, /* base_finalize */
      (GClassInitFunc) ags_recall_container_class_init,
      NULL, /* class_finalize */
      NULL, /* class_data */
      sizeof (AgsRecallContainer),
      0,    /* n_preallocs */
      (GInstanceInitFunc) ags_recall_container_init,
    };

    static const GInterfaceInfo ags_connectable_interface_info = {
      (GInterfaceInitFunc) ags_recall_container_connectable_interface_init,
      NULL, /* interface_finalize */
      NULL, /* interface_data */
    };

    ags_type_recall_container = g_type_register_static(G_TYPE_OBJECT,
						       "AgsRecallContainer\0",
						       &ags_recall_container_info,
						       0);

    g_type_add_interface_static(ags_type_recall_container,
				AGS_TYPE_CONNECTABLE,
				&ags_connectable_interface_info);
  }

  return(ags_type_recall_container);
}
Exemple #18
0
GType
ags_input_get_type (void)
{
  static GType ags_type_input = 0;

  if(!ags_type_input){
    static const GTypeInfo ags_input_info = {
      sizeof (AgsInputClass),
      (GBaseInitFunc) NULL, /* base_init */
      (GBaseFinalizeFunc) NULL, /* base_finalize */
      (GClassInitFunc) ags_input_class_init,
      NULL, /* class_finalize */
      NULL, /* class_data */
      sizeof (AgsInput),
      0,    /* n_preallocs */
      (GInstanceInitFunc) ags_input_init,
    };

    static const GInterfaceInfo ags_connectable_interface_info = {
      (GInterfaceInitFunc) ags_input_connectable_interface_init,
      NULL, /* interface_finalize */
      NULL, /* interface_data */
    };

    ags_type_input = g_type_register_static(AGS_TYPE_CHANNEL,
					    "AgsInput\0",
					    &ags_input_info,
					    0);

    g_type_add_interface_static(ags_type_input,
				AGS_TYPE_CONNECTABLE,
				&ags_connectable_interface_info);
  }

  return (ags_type_input);
}
Exemple #19
0
GType
gail_item_get_type (void)
{
  static GType type = 0;

  if (!type)
    {
      static const GTypeInfo tinfo =
      {
        sizeof (GailItemClass),
        (GBaseInitFunc) NULL, /* base init */
        (GBaseFinalizeFunc) NULL, /* base finalize */
        (GClassInitFunc) gail_item_class_init, /* class init */
        (GClassFinalizeFunc) NULL, /* class finalize */
        NULL, /* class data */
        sizeof (GailItem), /* instance size */
        0, /* nb preallocs */
        (GInstanceInitFunc) NULL, /* instance init */
        NULL /* value table */
      };

      static const GInterfaceInfo atk_text_info =
      {
        (GInterfaceInitFunc) atk_text_interface_init,
        (GInterfaceFinalizeFunc) NULL,
        NULL
      };

      type = g_type_register_static (GAIL_TYPE_CONTAINER,
                                     "GailItem", &tinfo, 0);
      g_type_add_interface_static (type, ATK_TYPE_TEXT,
                                   &atk_text_info);
    }

  return type;
}
Exemple #20
0
GType
gail_arrow_get_type (void)
{
  static GType type = 0;

  if (!type)
  {
    static const GTypeInfo tinfo =
    {
      sizeof (GailArrowClass),
      (GBaseInitFunc) NULL, /* base init */
      (GBaseFinalizeFunc) NULL, /* base finalize */
      (GClassInitFunc) gail_arrow_class_init, /* class init */
      (GClassFinalizeFunc) NULL, /* class finalize */
      NULL, /* class data */
      sizeof (GailArrow), /* instance size */
      0, /* nb preallocs */
      (GInstanceInitFunc) gail_arrow_object_init, /* instance init */
      NULL /* value table */
    };

    static const GInterfaceInfo atk_image_info =
    {
        (GInterfaceInitFunc) atk_image_interface_init,
        (GInterfaceFinalizeFunc) NULL,
        NULL
    };

    type = g_type_register_static (GAIL_TYPE_WIDGET,
                                   "GailArrow", &tinfo, 0);

    g_type_add_interface_static (type, ATK_TYPE_IMAGE,
                                 &atk_image_info);
  }
  return type;
}
GType
ags_acceleration_get_type()
{
  static GType ags_type_acceleration = 0;

  if(!ags_type_acceleration){
    static const GTypeInfo ags_acceleration_info = {
      sizeof(AgsAccelerationClass),
      NULL,
      NULL,
      (GClassInitFunc) ags_acceleration_class_init,
      NULL,
      NULL,
      sizeof(AgsAcceleration),
      0,
      (GInstanceInitFunc) ags_acceleration_init,
    };

    static const GInterfaceInfo ags_connectable_interface_info = {
      (GInterfaceInitFunc) ags_acceleration_connectable_interface_init,
      NULL, /* interface_finalize */
      NULL, /* interface_data */
    };

    ags_type_acceleration = g_type_register_static(G_TYPE_OBJECT,
					   "AgsAcceleration\0",
					   &ags_acceleration_info,
					   0);
    
    g_type_add_interface_static(ags_type_acceleration,
				AGS_TYPE_CONNECTABLE,
				&ags_connectable_interface_info);
  }

  return(ags_type_acceleration);
}
GType
ags_remove_audio_signal_get_type()
{
  static GType ags_type_remove_audio_signal = 0;

  if(!ags_type_remove_audio_signal){
    static const GTypeInfo ags_remove_audio_signal_info = {
      sizeof (AgsRemoveAudioSignalClass),
      NULL, /* base_init */
      NULL, /* base_finalize */
      (GClassInitFunc) ags_remove_audio_signal_class_init,
      NULL, /* class_finalize */
      NULL, /* class_data */
      sizeof (AgsRemoveAudioSignal),
      0,    /* n_preallocs */
      (GInstanceInitFunc) ags_remove_audio_signal_init,
    };

    static const GInterfaceInfo ags_connectable_interface_info = {
      (GInterfaceInitFunc) ags_remove_audio_signal_connectable_interface_init,
      NULL, /* interface_finalize */
      NULL, /* interface_data */
    };

    ags_type_remove_audio_signal = g_type_register_static(AGS_TYPE_TASK,
						  "AgsRemoveAudioSignal\0",
						  &ags_remove_audio_signal_info,
						  0);

    g_type_add_interface_static(ags_type_remove_audio_signal,
				AGS_TYPE_CONNECTABLE,
				&ags_connectable_interface_info);
  }
  
  return (ags_type_remove_audio_signal);
}
Exemple #23
0
/**
 *
 *  gtk2hs_store_get_type: here we register our new type and its interfaces
 *                         with the type system. If you want to implement
 *                         additional interfaces like GtkTreeSortable, you
 *                         will need to do it here.
 *
 **/
GType
gtk2hs_store_get_type (void)
{
  static GType gtk2hs_store_type = 0;

  if (!gtk2hs_store_type)
  {
    static const GTypeInfo gtk2hs_store_info =
    {
      sizeof (Gtk2HsStoreClass),
      NULL,              /* base_init */
      NULL,              /* base_finalize */
      (GClassInitFunc) gtk2hs_store_class_init,
      NULL,              /* class finalize */
      NULL,              /* class_data */
      sizeof (Gtk2HsStore),
      0,                 /* n_preallocs */
      (GInstanceInitFunc) gtk2hs_store_init
    };

    static const GInterfaceInfo tree_model_info =
    {
      (GInterfaceInitFunc) gtk2hs_store_tree_model_init,
      NULL,
      NULL
    };

#if GTK_MAJOR_VERSION < 3
/* The TreeSortable interface is currently not implemented. */
    static const GInterfaceInfo tree_sortable_info =
    {
      (GInterfaceInitFunc) gtk2hs_store_tree_sortable_init,
      NULL,
      NULL
    };
#endif
    static const GInterfaceInfo tree_drag_source_info =
    {
      (GInterfaceInitFunc) gtk2hs_store_tree_drag_source_init,
      NULL,
      NULL
    };

    static const GInterfaceInfo tree_drag_dest_info =
    {
      (GInterfaceInitFunc) gtk2hs_store_tree_drag_dest_init,
      NULL,
      NULL
    };

    gtk2hs_store_type = g_type_register_static (G_TYPE_OBJECT, "Gtk2HsStore",
                                               &gtk2hs_store_info,
                                               (GTypeFlags) 0);

    g_type_add_interface_static (gtk2hs_store_type, GTK_TYPE_TREE_MODEL,
    &tree_model_info);

    /* The TreeSortable interface is currently not implemented. Uncomment to
    add it. */
/*    g_type_add_interface_static (gtk2hs_store_type,
                                 GTK_TYPE_TREE_SORTABLE,
                                 &tree_sortable_info);
*/
    g_type_add_interface_static (gtk2hs_store_type,
                                 GTK_TYPE_TREE_DRAG_SOURCE,
                                 &tree_drag_source_info);

    g_type_add_interface_static (gtk2hs_store_type,
                                 GTK_TYPE_TREE_DRAG_DEST,
                                 &tree_drag_dest_info);
  }

  return gtk2hs_store_type;
}
GType
ea_day_view_main_item_get_type (void)
{
	static GType type = 0;
	AtkObjectFactory *factory;
	GTypeQuery query;
	GType derived_atk_type;

	if (!type) {
		static GTypeInfo tinfo = {
			sizeof (EaDayViewMainItemClass),
			(GBaseInitFunc) NULL, /* base init */
			(GBaseFinalizeFunc) NULL, /* base finalize */
			(GClassInitFunc) ea_day_view_main_item_class_init,
			(GClassFinalizeFunc) NULL, /* class finalize */
			NULL, /* class data */
			sizeof (EaDayViewMainItem), /* instance size */
			0, /* nb preallocs */
			(GInstanceInitFunc) NULL, /* instance init */
			NULL /* value table */
		};

		static const GInterfaceInfo atk_component_info = {
			(GInterfaceInitFunc) atk_component_interface_init,
			(GInterfaceFinalizeFunc) NULL,
			NULL
		};

		static const GInterfaceInfo atk_table_info = {
			(GInterfaceInitFunc) atk_table_interface_init,
			(GInterfaceFinalizeFunc) NULL,
			NULL
		};
		static const GInterfaceInfo atk_selection_info = {
			(GInterfaceInitFunc) atk_selection_interface_init,
			(GInterfaceFinalizeFunc) NULL,
			NULL
		};

		/*
		 * Figure out the size of the class and instance
		 * we are run-time deriving from (GailCanvasItem, in this case)
		 *
		 */

		factory = atk_registry_get_factory (
			atk_get_default_registry (),
			e_day_view_main_item_get_type ());
		derived_atk_type = atk_object_factory_get_accessible_type (factory);
		g_type_query (derived_atk_type, &query);

		tinfo.class_size = query.class_size;
		tinfo.instance_size = query.instance_size;

		type = g_type_register_static (
			derived_atk_type,
			"EaDayViewMainItem", &tinfo, 0);
		g_type_add_interface_static (
			type, ATK_TYPE_COMPONENT,
			&atk_component_info);
		g_type_add_interface_static (
			type, ATK_TYPE_TABLE,
			&atk_table_info);
		g_type_add_interface_static (
			type, ATK_TYPE_SELECTION,
			&atk_selection_info);
	}

	return type;
}
Exemple #25
0
GType
ea_cal_view_event_get_type (void)
{
	static GType type = 0;
	AtkObjectFactory *factory;
	GTypeQuery query;
	GType derived_atk_type;

	if (!type) {
		static GTypeInfo tinfo = {
			sizeof (EaCalViewEventClass),
			(GBaseInitFunc) NULL, /* base init */
			(GBaseFinalizeFunc) NULL, /* base finalize */
			(GClassInitFunc) ea_cal_view_event_class_init, /* class init */
			(GClassFinalizeFunc) NULL, /* class finalize */
			NULL, /* class data */
			sizeof (EaCalViewEvent), /* instance size */
			0, /* nb preallocs */
			(GInstanceInitFunc) ea_cal_view_event_init, /* instance init */
			NULL /* value table */
		};

		static const GInterfaceInfo atk_component_info = {
			(GInterfaceInitFunc) atk_component_interface_init,
			(GInterfaceFinalizeFunc) NULL,
			NULL
		};

		static const GInterfaceInfo atk_action_info = {
			(GInterfaceInitFunc) atk_action_interface_init,
			(GInterfaceFinalizeFunc) NULL,
			NULL
		};

		/*
		 * Figure out the size of the class and instance
		 * we are run-time deriving from (atk object for E_TEXT, in this case)
		 */

		factory = atk_registry_get_factory (
			atk_get_default_registry (),
			E_TYPE_TEXT);
		derived_atk_type = atk_object_factory_get_accessible_type (factory);
		g_type_query (derived_atk_type, &query);

		tinfo.class_size = query.class_size;
		tinfo.instance_size = query.instance_size;

		/* we inherit the component, text and other interfaces from E_TEXT */
		type = g_type_register_static (
			derived_atk_type,
			"EaCalViewEvent", &tinfo, 0);
		g_type_add_interface_static (
			type, ATK_TYPE_COMPONENT,
			&atk_component_info);
		g_type_add_interface_static (
			type, ATK_TYPE_ACTION,
			&atk_action_info);

	}

	return type;
}
gboolean
gst_ffmpegmux_register (GstPlugin * plugin)
{
  GTypeInfo typeinfo = {
    sizeof (GstFFMpegMuxClass),
    (GBaseInitFunc) gst_ffmpegmux_base_init,
    NULL,
    (GClassInitFunc) gst_ffmpegmux_class_init,
    NULL,
    NULL,
    sizeof (GstFFMpegMux),
    0,
    (GInstanceInitFunc) gst_ffmpegmux_init,
  };
  static const GInterfaceInfo tag_setter_info = {
    NULL, NULL, NULL
  };
  GType type;
  AVOutputFormat *in_plugin;

  in_plugin = av_oformat_next (NULL);

  GST_LOG ("Registering muxers");

  while (in_plugin) {
    gchar *type_name;
    gchar *p;

    if ((!strncmp (in_plugin->name, "u16", 3)) ||
        (!strncmp (in_plugin->name, "s16", 3)) ||
        (!strncmp (in_plugin->name, "u24", 3)) ||
        (!strncmp (in_plugin->name, "s24", 3)) ||
        (!strncmp (in_plugin->name, "u8", 2)) ||
        (!strncmp (in_plugin->name, "s8", 2)) ||
        (!strncmp (in_plugin->name, "u32", 3)) ||
        (!strncmp (in_plugin->name, "s32", 3)) ||
        (!strncmp (in_plugin->name, "f32", 3)) ||
        (!strncmp (in_plugin->name, "f64", 3)) ||
        (!strncmp (in_plugin->name, "raw", 3)) ||
        (!strncmp (in_plugin->name, "crc", 3)) ||
        (!strncmp (in_plugin->name, "null", 4)) ||
        (!strncmp (in_plugin->name, "gif", 3)) ||
        (!strncmp (in_plugin->name, "frame", 5)) ||
        (!strncmp (in_plugin->name, "image", 5)) ||
        (!strncmp (in_plugin->name, "mulaw", 5)) ||
        (!strncmp (in_plugin->name, "alaw", 4)) ||
        (!strncmp (in_plugin->name, "h26", 3)) ||
        (!strncmp (in_plugin->name, "ass", 3))
        ) {
      GST_LOG ("Ignoring muxer %s", in_plugin->name);
      goto next;
    }

    /* FIXME : We need a fast way to know whether we have mappings for this
     * muxer type. */

    /* construct the type */
    type_name = g_strdup_printf ("ffmux_%s", in_plugin->name);

    p = type_name;

    while (*p) {
      if (*p == '.')
        *p = '_';
      p++;
    }

    type = g_type_from_name (type_name);

    if (!type) {
      /* create the type now */
      type = g_type_register_static (GST_TYPE_ELEMENT, type_name, &typeinfo, 0);
      g_type_set_qdata (type, GST_FFMUX_PARAMS_QDATA, (gpointer) in_plugin);
      g_type_add_interface_static (type, GST_TYPE_TAG_SETTER, &tag_setter_info);
    }

    if (!gst_element_register (plugin, type_name, GST_RANK_MARGINAL, type)) {
      g_free (type_name);
      return FALSE;
    }

    g_free (type_name);

  next:
    in_plugin = av_oformat_next (in_plugin);
  }

  GST_LOG ("Finished registering muxers");

  return TRUE;
}
GType
peas_extension_register_subclass (GType  parent_type,
                                  GType *extension_types)
{
  guint i;
  GString *type_name;
  GType the_type;

  type_name = g_string_new (g_type_name (parent_type));

  for (i = 0; extension_types[i] != 0; ++i)
    {
      /* Use something that is not allowed in symbol names */
      g_string_append_c (type_name, '+');

      g_string_append (type_name, g_type_name (extension_types[i]));
    }

  the_type = g_type_from_name (type_name->str);

  if (the_type == G_TYPE_INVALID)
    {
      GTypeQuery query;
      GTypeInfo type_info = {
        0,
        (GBaseInitFunc) NULL,
        (GBaseFinalizeFunc) NULL,
        (GClassInitFunc) extension_subclass_init,
        (GClassFinalizeFunc) NULL,
        g_memdup (extension_types, sizeof (GType) * (i + 1)),
        0,
        0,
        (GInstanceInitFunc) extension_subclass_instance_init,
        NULL
      };
      GInterfaceInfo iface_info = {
        (GInterfaceInitFunc) implement_interface_methods,
        (GInterfaceFinalizeFunc) NULL,
        NULL
      };

      g_debug ("Registering new type '%s'", type_name->str);

      g_type_query (parent_type, &query);
      type_info.class_size = query.class_size;
      type_info.instance_size = query.instance_size;

      the_type = g_type_register_static (parent_type, type_name->str,
                                         &type_info, 0);

      iface_info.interface_data = GSIZE_TO_POINTER (the_type);

      for (i = 0; extension_types[i] != 0; ++i)
        g_type_add_interface_static (the_type, extension_types[i], &iface_info);
    }

  /* Must be done outside of type registration
   * in the event that the same type is requested again.
   */
  for (i = 0; extension_types[i] != 0; ++i)
    {
      if (!g_type_is_a (the_type, extension_types[i]))
        {
          g_warning ("Type '%s' is invalid", type_name->str);
          the_type = G_TYPE_INVALID;
          break;
        }
    }

  g_string_free (type_name, TRUE);

  return the_type;
}
Exemple #28
0
GType
ags_recall_get_type (void)
{
  static GType ags_type_recall = 0;

  if(!ags_type_recall){
    static const GTypeInfo ags_recall_info = {
      sizeof (AgsRecallClass),
      NULL, /* base_init */
      NULL, /* base_finalize */
      (GClassInitFunc) ags_recall_class_init,
      NULL, /* class_finalize */
      NULL, /* class_data */
      sizeof (AgsRecall),
      0,    /* n_preallocs */
      (GInstanceInitFunc) ags_recall_init,
    };

    static const GInterfaceInfo ags_connectable_interface_info = {
      (GInterfaceInitFunc) ags_recall_connectable_interface_init,
      NULL, /* interface_finalize */
      NULL, /* interface_data */
    };

    static const GInterfaceInfo ags_packable_interface_info = {
      (GInterfaceInitFunc) ags_recall_packable_interface_init,
      NULL, /* interface_finalize */
      NULL, /* interface_data */
    };

    static const GInterfaceInfo ags_dynamic_connectable_interface_info = {
      (GInterfaceInitFunc) ags_recall_dynamic_connectable_interface_init,
      NULL, /* interface_finalize */
      NULL, /* interface_data */
    };

    static const GInterfaceInfo ags_plugin_interface_info = {
      (GInterfaceInitFunc) ags_recall_plugin_interface_init,
      NULL, /* interface_finalize */
      NULL, /* interface_data */
    };

    ags_type_recall = g_type_register_static(G_TYPE_OBJECT,
					     "AgsRecall\0",
					     &ags_recall_info,
					     0);

    g_type_add_interface_static(ags_type_recall,
				AGS_TYPE_CONNECTABLE,
				&ags_connectable_interface_info);

    g_type_add_interface_static(ags_type_recall,
				AGS_TYPE_PACKABLE,
				&ags_packable_interface_info);

    g_type_add_interface_static(ags_type_recall,
				AGS_TYPE_DYNAMIC_CONNECTABLE,
				&ags_dynamic_connectable_interface_info);

    g_type_add_interface_static(ags_type_recall,
				AGS_TYPE_PLUGIN,
				&ags_plugin_interface_info);
  }

  return(ags_type_recall);
}
GType
bml (transform_get_type (const char *element_type_name, gboolean is_polyphonic))
{
  const GTypeInfo element_type_info = {
    sizeof (GstBMLTransformClass),
    (GBaseInitFunc) gst_bml_transform_base_init,
    (GBaseFinalizeFunc) gst_bml_transform_base_finalize,
    (GClassInitFunc) gst_bml_transform_class_init,
    NULL,
    NULL,
    sizeof (GstBMLTransform),
    0,
    (GInstanceInitFunc) gst_bml_transform_init,
  };
  const GInterfaceInfo child_proxy_interface_info = {
    (GInterfaceInitFunc) gst_bml_child_proxy_interface_init,    /* interface_init */
    NULL,                       /* interface_finalize */
    NULL                        /* interface_data */
  };
  const GInterfaceInfo child_bin_interface_info = {
    NULL,                       /* interface_init */
    NULL,                       /* interface_finalize */
    NULL                        /* interface_data */
  };
  const GInterfaceInfo property_meta_interface_info = {
    (GInterfaceInitFunc) gst_bml_property_meta_interface_init,  /* interface_init */
    NULL,                       /* interface_finalize */
    NULL                        /* interface_data */
  };
  const GInterfaceInfo tempo_interface_info = {
    (GInterfaceInitFunc) gst_bml_tempo_interface_init,  /* interface_init */
    NULL,                       /* interface_finalize */
    NULL                        /* interface_data */
  };
  const GInterfaceInfo preset_interface_info = {
    (GInterfaceInitFunc) gst_bml_preset_interface_init, /* interface_init */
    NULL,                       /* interface_finalize */
    NULL                        /* interface_data */
  };
  GType element_type;

  GST_INFO ("registering transform-plugin: \"%s\"", element_type_name);

  // create the element type now
  element_type =
      g_type_register_static (GST_TYPE_BASE_TRANSFORM, element_type_name,
      &element_type_info, 0);
  GST_INFO ("succefully registered new type : \"%s\"", element_type_name);
  g_type_add_interface_static (element_type, GSTBT_TYPE_PROPERTY_META,
      &property_meta_interface_info);
  g_type_add_interface_static (element_type, GSTBT_TYPE_TEMPO,
      &tempo_interface_info);

  // check if this plugin can do multiple voices
  if (is_polyphonic) {
    g_type_add_interface_static (element_type, GST_TYPE_CHILD_PROXY,
        &child_proxy_interface_info);
    g_type_add_interface_static (element_type, GSTBT_TYPE_CHILD_BIN,
        &child_bin_interface_info);
  }
  // add presets iface
  g_type_add_interface_static (element_type, GST_TYPE_PRESET,
      &preset_interface_info);

  GST_INFO ("successfully registered type interfaces");

  return (element_type);
}
GType gst_devsound_src_get_type(void)
    {
    static GType devsoundsrc_type = 0;

    if (!devsoundsrc_type)
        {
        static const GTypeInfo devsoundsrc_info =
            {
            sizeof(GstDevsoundSrcClass), gst_devsound_src_base_init, NULL,
                    (GClassInitFunc) gst_devsound_src_class_init, NULL, NULL,
                    sizeof(GstDevsoundSrc), 0,
                    (GInstanceInitFunc) gst_devsound_src_init
,        };

    static const GInterfaceInfo speech_encoder_config_info =
        {
        gst_speech_encoder_config_handler_init,
        NULL,
        NULL
        };

    static const GInterfaceInfo g711_encoder_info =
        {
        gst_g711_encoder_handler_init,
        NULL,
        NULL
        };

    static const GInterfaceInfo g729_encoder_info =
         {
         gst_g729_encoder_handler_init,
         NULL,
         NULL
         };

    static const GInterfaceInfo ilbc_encoder_info =
         {
         gst_ilbc_encoder_handler_init,
         NULL,
         NULL
         };

    devsoundsrc_type =
    g_type_register_static (GST_TYPE_PUSH_SRC, "GstDevsoundSrc",
            &devsoundsrc_info, (GTypeFlags)0);

    g_type_add_interface_static (devsoundsrc_type, GST_TYPE_SPEECH_ENCODER_CONFIG,
            &speech_encoder_config_info);

    g_type_add_interface_static (devsoundsrc_type, GST_TYPE_G711_ENCODER,
            &g711_encoder_info);

    g_type_add_interface_static (devsoundsrc_type, GST_TYPE_G729_ENCODER,
              &g729_encoder_info);

    g_type_add_interface_static (devsoundsrc_type, GST_TYPE_ILBC_ENCODER,
              &ilbc_encoder_info);

    }

return devsoundsrc_type;
}