win32-plugin.c

系统任务管理器

 /* GKrellM Windows Portion
|  Copyright (C) 2002 Bill Nalen
|
|  Author:  Bill Nalen    [e-mail]
|  Latest versions might be found at:  http://bill.nalens.com
|
|  This program is free software which I release under the GNU General Public
|  License. You may redistribute and/or modify this program under the terms
|  of that 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.  Version 2 is in the
|  COPYRIGHT file in the top level directory of this distribution.
| 
|  To get a copy of the GNU General Puplic License, write to the Free Software
|  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

// need to link with the following libraries
// ws2_32.lib glib-2.0.lib gtk-win32-2.0.lib gdk-win32-2.0.lib gobject-2.0.lib gdk_pixbuf-2.0.lib gthread-2.0.lib gmodule-2.0.lib 
// needs to be compiled with the single thread option

#include <src/gkrellm.h>

#include <src/win32-plugin.h>

win32_plugin_callbacks* callbacks;

  /* Data structure allocation
  */
GkrellmChart *gkrellm_chart_new0(void)
{
    return (*(callbacks->gkrellm_chart_new0))();
}
GkrellmChartconfig *gkrellm_chartconfig_new0(void)
{
    return (*(callbacks->gkrellm_chartconfig_new0))();
}
GkrellmPanel *gkrellm_panel_new0(void)
{
    return (*(callbacks->gkrellm_panel_new0))();
}
GkrellmKrell *gkrellm_krell_new0(void)
{
    return (*(callbacks->gkrellm_krell_new0))();
}
GkrellmDecal *gkrellm_decal_new0(void)
{
    return (*(callbacks->gkrellm_decal_new0))();
}
GkrellmLabel *gkrellm_label_new0(void)
{
    return (*(callbacks->gkrellm_label_new0))();
}
GkrellmStyle *gkrellm_style_new0(void)
{
    return (*(callbacks->gkrellm_style_new0))();
}
GkrellmStyle *gkrellm_copy_style(GkrellmStyle *a)
{
    return (*(callbacks->gkrellm_copy_style))(a);
}
void		gkrellm_copy_style_values(GkrellmStyle *a, GkrellmStyle *b)
{
    (*(callbacks->gkrellm_copy_style_values))(a, b);
}
GkrellmTextstyle *gkrellm_textstyle_new0(void)
{
    return (*(callbacks->gkrellm_textstyle_new0))();
}
GkrellmTextstyle *gkrellm_copy_textstyle(GkrellmTextstyle *a)
{
    return (*(callbacks->gkrellm_copy_textstyle))(a);
}

  /* Chart functions
  */
void		gkrellm_chart_create(GtkWidget *a, GkrellmMonitor *b,
						GkrellmChart *c, GkrellmChartconfig **d)
{
    (*(callbacks->gkrellm_chart_create))(a, b, c, d);
}
void		gkrellm_chart_destroy(GkrellmChart *a)
{
    (*(callbacks->gkrellm_chart_destroy))(a);
}
void		gkrellm_chart_hide(GkrellmChart *a, gboolean b)
{
    (*(callbacks->gkrellm_chart_hide))(a, b);
}
void		gkrellm_chart_show(GkrellmChart *a, gboolean b)
{
    (*(callbacks->gkrellm_chart_show))(a, b);
}
gboolean	gkrellm_chart_enable_visibility(GkrellmChart *cp, gboolean b,
						gboolean *c)
{
    return (*(callbacks->gkrellm_chart_enable_visibility))(cp, b, c);
}
gboolean	gkrellm_is_chart_visible(GkrellmChart *a)
{
    return (*(callbacks->gkrellm_is_chart_visible))(a);
}
void		gkrellm_set_draw_chart_function(GkrellmChart *a,
						void (*func)(), gpointer b)
{
    (*(callbacks->gkrellm_set_draw_chart_function))(a, func, b);
}
void		gkrellm_draw_chart_to_screen(GkrellmChart *a)
{
    (*(callbacks->gkrellm_draw_chart_to_screen))(a);
}
gint		gkrellm_draw_chart_label(GkrellmChart *a, GkrellmTextstyle *b,
						gint c, gint d,gchar *e)
{
    return (*(callbacks->gkrellm_draw_chart_label))(a, b, c, d, e);
}
void		gkrellm_draw_chart_text(GkrellmChart *a, gint b, gchar *c)
{
    (*(callbacks->gkrellm_draw_chart_text))(a, b, c);
}
void		gkrellm_reset_chart(GkrellmChart *a)
{
    (*(callbacks->gkrellm_reset_chart))(a);
}
void		gkrellm_reset_and_draw_chart(GkrellmChart *a)
{
    (*(callbacks->gkrellm_reset_and_draw_chart))(a);
}
void		gkrellm_refresh_chart(GkrellmChart *a)
{
    (*(callbacks->gkrellm_refresh_chart))(a);
}
void		gkrellm_rescale_chart(GkrellmChart *a)
{
    (*(callbacks->gkrellm_rescale_chart))(a);
}
void		gkrellm_clear_chart(GkrellmChart *a)
{
    (*(callbacks->gkrellm_clear_chart))(a);
}
void		gkrellm_clear_chart_pixmap(GkrellmChart *a)
{
    (*(callbacks->gkrellm_clear_chart_pixmap))(a);
}
void		gkrellm_clean_bg_src_pixmap(GkrellmChart *a)
{
    (*(callbacks->gkrellm_clean_bg_src_pixmap))(a);
}
void		gkrellm_draw_chart_grid_line(GkrellmChart *a, GdkPixmap *b, gint c)
{
    (*(callbacks->gkrellm_draw_chart_grid_line))(a, b, c);
}
void		gkrellm_chart_bg_piximage_override(GkrellmChart *a,
						GkrellmPiximage *b, GkrellmPiximage *c)
{
    (*(callbacks->gkrellm_chart_bg_piximage_override))(a, b, c);
}
gint		gkrellm_chart_width(void)
{
    return (*(callbacks->gkrellm_chart_width))();
}
void		gkrellm_set_chart_height_default(GkrellmChart *a, gint b)
{
    (*(callbacks->gkrellm_set_chart_height_default))(a, b);
}
void		gkrellm_set_chart_height(GkrellmChart *a, gint b)
{
    (*(callbacks->gkrellm_set_chart_height))(a, b);
}
gint		gkrellm_get_chart_scalemax(GkrellmChart *a)
{
    return (*(callbacks->gkrellm_get_chart_scalemax))(a);
}
void		gkrellm_render_data_pixmap(GkrellmPiximage *a, GdkPixmap **b,
						GdkColor *c, gint d)
{
    (*(callbacks->gkrellm_render_data_pixmap))(a, b, c, d);
}
void		gkrellm_render_data_grid_pixmap(GkrellmPiximage *a,
						GdkPixmap **b, GdkColor *c)
{
    (*(callbacks->gkrellm_render_data_grid_pixmap))(a, b, c);
}

  /* ChartData functions
  */
GkrellmChartdata *gkrellm_add_chartdata(GkrellmChart *a, GdkPixmap **b,
					GdkPixmap *c, gchar *d)
{
    return (*(callbacks->gkrellm_add_chartdata))(a, b, c, d);
}
GkrellmChartdata *gkrellm_add_default_chartdata(GkrellmChart *a, gchar *b)
{
    return (*(callbacks->gkrellm_add_default_chartdata))(a, b);
}
void		gkrellm_alloc_chartdata(GkrellmChart *a)
{
    (*(callbacks->gkrellm_alloc_chartdata))(a);
}
void		gkrellm_store_chartdata(GkrellmChart *a, gulong b, gulong c, gulong d)
{
    (*(callbacks->gkrellm_store_chartdata))(a, b, c, d);
}
void		gkrellm_draw_chartdata(GkrellmChart *a)
{
    (*(callbacks->gkrellm_draw_chartdata))(a);
}
void		gkrellm_monotonic_chartdata(GkrellmChartdata *a, gboolean b)
{
    (*(callbacks->gkrellm_monotonic_chartdata))(a, b);
}
gboolean	gkrellm_get_chartdata_hide(GkrellmChartdata *a)
{
    return (*(callbacks->gkrellm_get_chartdata_hide))(a);
}
gint		gkrellm_get_current_chartdata(GkrellmChartdata *a)
{
    return (*(callbacks->gkrellm_get_current_chartdata))(a);
}
gint		gkrellm_get_chartdata_data(GkrellmChartdata *a, gint b)
{
    return (*(callbacks->gkrellm_get_chartdata_data))(a, b);
}
void		gkrellm_set_chartdata_draw_style(GkrellmChartdata *a, gint b)
{
    (*(callbacks->gkrellm_set_chartdata_draw_style))(a, b);
}
void		gkrellm_set_chartdata_draw_style_default(GkrellmChartdata *a, gint b)
{
    (*(callbacks->gkrellm_set_chartdata_draw_style_default))(a, b);
}
void		gkrellm_set_chartdata_flags(GkrellmChartdata *a, gint b)
{
    (*(callbacks->gkrellm_set_chartdata_flags))(a, b);
}
void		gkrellm_scale_chartdata(GkrellmChartdata *a, gint b, gint c)
{
    (*(callbacks->gkrellm_scale_chartdata))(a, b, c);
}
void		gkrellm_offset_chartdata(GkrellmChartdata *a, gint b)
{
    (*(callbacks->gkrellm_offset_chartdata))(a, b);
}

  /* ChartConfig functions
  */
void		gkrellm_chartconfig_window_create(GkrellmChart *a)
{
    (*(callbacks->gkrellm_chartconfig_window_create))(a);
}
void		gkrellm_chartconfig_window_destroy(GkrellmChart *a)
{
    (*(callbacks->gkrellm_chartconfig_window_destroy))(a);
}
void		gkrellm_chartconfig_grid_resolution_adjustment(
						GkrellmChartconfig *a, gboolean b, gfloat c, gfloat d, gfloat e,
						gfloat f, gfloat g, gint h, gint i)
{
    (*(callbacks->gkrellm_chartconfig_grid_resolution_adjustment))(a, b, c, d, e, f, g, h, i);
}
void		gkrellm_set_chartconfig_grid_resolution(GkrellmChartconfig *a,
						gint b)
{
    (*(callbacks->gkrellm_set_chartconfig_grid_resolution))(a, b);
}
gint		gkrellm_get_chartconfig_grid_resolution(GkrellmChartconfig *a)
{
    return (*(callbacks->gkrellm_get_chartconfig_grid_resolution))(a);
}
void		gkrellm_chartconfig_grid_resolution_connect(
						GkrellmChartconfig *a, void (*fn)(), gpointer b)
{
    (*(callbacks->gkrellm_chartconfig_grid_resolution_connect))(a, fn, b);
}
void		gkrellm_set_chartconfig_flags(GkrellmChartconfig *a, gint b)
{
    (*(callbacks->gkrellm_set_chartconfig_flags))(a, b);
}
void		gkrellm_chartconfig_grid_resolution_label(
						GkrellmChartconfig *a, gchar *b)
{
    (*(callbacks->gkrellm_chartconfig_grid_resolution_label))(a, b);
}
void		gkrellm_set_chartconfig_auto_grid_resolution(
						GkrellmChartconfig *a, gboolean b)
{
    (*(callbacks->gkrellm_set_chartconfig_auto_grid_resolution))(a, b);
}
void		gkrellm_set_chartconfig_auto_resolution_stick(
						GkrellmChartconfig *a, gboolean b)
{
    (*(callbacks->gkrellm_set_chartconfig_auto_resolution_stick))(a, b);
}
void		gkrellm_set_chartconfig_sequence_125(GkrellmChartconfig *a,
						gboolean b)
{
    (*(callbacks->gkrellm_set_chartconfig_sequence_125))(a, b);
}
void		gkrellm_set_chartconfig_fixed_grids(GkrellmChartconfig *a, gint b)
{
    (*(callbacks->gkrellm_set_chartconfig_fixed_grids))(a, b);
}
gint		gkrellm_get_chartconfig_fixed_grids(GkrellmChartconfig *a)
{
    return (*(callbacks->gkrellm_get_chartconfig_fixed_grids))(a);
}
void		gkrellm_chartconfig_fixed_grids_connect(GkrellmChartconfig *a,
						void (*fn)(), gpointer b)
{
    (*(callbacks->gkrellm_chartconfig_fixed_grids_connect))(a, fn, b);
}
gint		gkrellm_get_chartconfig_height(GkrellmChartconfig *a)
{
    return (*(callbacks->gkrellm_get_chartconfig_height))(a);
}
void		gkrellm_chartconfig_height_connect(GkrellmChartconfig *a,
						void (*fn)(), gpointer b)
{
    (*(callbacks->gkrellm_chartconfig_height_connect))(a, fn, b);
}
void		gkrellm_save_chartconfig(FILE *a, GkrellmChartconfig *b,
						gchar *c, gchar *d)
{
    (*(callbacks->gkrellm_save_chartconfig))(a, b, c, d);
}
void		gkrellm_load_chartconfig(GkrellmChartconfig **a, gchar *b, gint c)
{
    (*(callbacks->gkrellm_load_chartconfig))(a, b, c);
}
void		gkrellm_chartconfig_destroy(GkrellmChartconfig **a)
{
    (*(callbacks->gkrellm_chartconfig_destroy))(a);
}

  /* Panel functions
  */
void		gkrellm_panel_configure(GkrellmPanel *a, gchar *b, GkrellmStyle *c)
{
    (*(callbacks->gkrellm_panel_configure))(a, b, c);
}
void		gkrellm_panel_configure_add_height(GkrellmPanel *a, gint b)
{
    (*(callbacks->gkrellm_panel_configure_add_height))(a, b);
}
void		gkrellm_panel_configure_set_height(GkrellmPanel *p, gint h)
{
    (*(callbacks->gkrellm_panel_configure_set_height))(p, h);
}
gint		gkrellm_panel_configure_get_height(GkrellmPanel *p)
{
    return (*(callbacks->gkrellm_panel_configure_get_height))(p);
}
void		gkrellm_panel_create(GtkWidget *a, GkrellmMonitor *b, GkrellmPanel *c)
{
    (*(callbacks->gkrellm_panel_create))(a, b, c);
}
void		gkrellm_panel_destroy(GkrellmPanel *a)
{
    (*(callbacks->gkrellm_panel_destroy))(a);
}
void		gkrellm_panel_hide(GkrellmPanel *a)
{
    (*(callbacks->gkrellm_panel_hide))(a);
}
void		gkrellm_panel_show(GkrellmPanel *a)
{
    (*(callbacks->gkrellm_panel_show))(a);
}
gboolean	gkrellm_panel_enable_visibility(GkrellmPanel *p, gboolean a,
						gboolean *b)
{
    return (*(callbacks->gkrellm_panel_enable_visibility))(p, a, b);
}
gboolean	gkrellm_is_panel_visible(GkrellmPanel *a)
{
    return (*(callbacks->gkrellm_is_panel_visible))(a);
}
void		gkrellm_panel_keep_lists(GkrellmPanel *a, gboolean b)
{
    (*(callbacks->gkrellm_panel_keep_lists))(a, b);
}
void		gkrellm_draw_panel_label(GkrellmPanel *a)
{
    (*(callbacks->gkrellm_draw_panel_label))(a);
}
void		gkrellm_draw_panel_layers(GkrellmPanel *a)
{
    (*(callbacks->gkrellm_draw_panel_layers))(a);
}
void		gkrellm_draw_panel_layers_force(GkrellmPanel *a)
{
    (*(callbacks->gkrellm_draw_panel_layers_force))(a);
}
void		gkrellm_panel_bg_piximage_override(GkrellmPanel *a, GkrellmPiximage *b)
{
    (*(callbacks->gkrellm_panel_bg_piximage_override))(a, b);
}

  /* Krell functions
  */
GkrellmKrell *gkrellm_create_krell(GkrellmPanel *a, GkrellmPiximage *b,
						GkrellmStyle *c)
{
    return (*(callbacks->gkrellm_create_krell))(a, b, c);
}
void		gkrellm_set_krell_full_scale(GkrellmKrell *a, gint b, gint c)
{
    (*(callbacks->gkrellm_set_krell_full_scale))(a, b, c);
}
void		gkrellm_set_style_krell_values(GkrellmStyle *a, gint b, gint c, gint d,
						gint e, gint f, gint g, gint h)
{
    (*(callbacks->gkrellm_set_style_krell_values))(a, b, c, d, e, f, g, h);
}
void		gkrellm_set_style_krell_values_default(GkrellmStyle *s, gint yoff,
						gint depth, gint x_hot, gint expand, gint ema,
						gint left_margin, gint right_margin)
{
    (*(callbacks->gkrellm_set_style_krell_values_default))(s, yoff, depth, x_hot, expand, ema, left_margin, right_margin);
}
void		gkrellm_set_style_slider_values_default(GkrellmStyle *s, gint yoff,
						gint left_margin, gint right_margin)
{
    (*(callbacks->gkrellm_set_style_slider_values_default))(s, yoff, left_margin, right_margin);
}
void		gkrellm_set_krell_margins(GkrellmPanel *a, GkrellmKrell *k,
						gint b, gint c)
{
    (*(callbacks->gkrellm_set_krell_margins))(a, k, b, c);
}
void		gkrellm_set_krell_expand(GkrellmStyle *a, gchar *b)
{
    (*(callbacks->gkrellm_set_krell_expand))(a, b);
}
void		gkrellm_update_krell(GkrellmPanel *a, GkrellmKrell *b, gulong c)
{
    (*(callbacks->gkrellm_update_krell))(a, b, c);
}
void		gkrellm_monotonic_krell_values(GkrellmKrell *k, gboolean b)
{
    (*(callbacks->gkrellm_monotonic_krell_values))(k, b);
}
void		gkrellm_destroy_krell_list(GkrellmPanel *a)
{
    (*(callbacks->gkrellm_destroy_krell_list))(a);
}
void		gkrellm_destroy_krell(GkrellmKrell *a)
{
    (*(callbacks->gkrellm_destroy_krell))(a);
}
void		gkrellm_move_krell_yoff(GkrellmPanel *a, GkrellmKrell *b, gint c)
{
    (*(callbacks->gkrellm_move_krell_yoff))(a, b, c);
}
void		gkrellm_remove_krell(GkrellmPanel *a, GkrellmKrell *b)
{
    (*(callbacks->gkrellm_remove_krell))(a, b);
}
void		gkrellm_insert_krell(GkrellmPanel *a, GkrellmKrell *b, gboolean c)
{
    (*(callbacks->gkrellm_insert_krell))(a, b, c);
}
void		gkrellm_insert_krell_nth(GkrellmPanel *a, GkrellmKrell *b, gint c)
{
    (*(callbacks->gkrellm_insert_krell_nth))(a, b, c);
}

  /* Decal and Decalbutton functions
  */
GkrellmDecal *gkrellm_create_decal_text(GkrellmPanel *p, gchar *a,
						GkrellmTextstyle *b, GkrellmStyle *c, gint d, gint e, gint f)
{
    return (*(callbacks->gkrellm_create_decal_text))(p, a, b, c, d, e, f);
}
GkrellmDecal *gkrellm_create_decal_pixmap(GkrellmPanel *a, GdkPixmap *b,
						GdkBitmap *c, gint d, GkrellmStyle *e, gint f, gint g)
{
    return (*(callbacks->gkrellm_create_decal_pixmap))(a, b, c, d, e, f, g);
}
GkrellmDecal *gkrellm_make_scaled_decal_pixmap(GkrellmPanel *p,
						GkrellmPiximage *im, GkrellmStyle *style,