parse-gtk.c

Go to the documentation of this file.

/********************************************************************\
 * parse-gtk.c -- Plugin for Dui Parser that handle Gtk markup.     *
 * Copyright (C) 2002,2004 Linas Vepstas <linas@linas.org>          *
 * http://dwi.sourceforge.net                                       *
 *                                                                  *
 * 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 program; if not, contact:                *
 *                                                                  *
 * Free Software Foundation           Voice:  +1-617-542-5942       *
 * 59 Temple Place - Suite 330        Fax:    +1-617-542-2652       *
 * Boston, MA  02111-1307,  USA       gnu@gnu.org                   *
\********************************************************************/

#include <stdlib.h>
#include "parse-gtk.h"
#include "duifield-gtk.h"
#include "duitop-gtk.h"
#include "duifield.h"
#include "interface.h"
#include "signal.h"
#include "window.h"
#include "perr.h"

#include "parse-utils.h"
#include "readfile.h"

/* ============================================================== */
/* The XML Parsing and parse context routines */

struct DwiGtkParseCtxt_s
{
    DuiParser *parser;

    DuiGtkTop *top;

    DuiWindow *window;

    DuiAction *action;
};

/* ============================================================== */

static void 
window_start (gpointer self, const gchar **attrs)
{
    static const gchar * eltname = "<window>";
    DwiGtkParseCtxt *ctx = self;
    DuiParser *par = ctx->parser;

    gint i;
    const gchar * provider = NULL;
    const gchar * winname = NULL;
    const gchar * filepath = NULL;
    const gchar * root_widget = NULL;
    const gchar * mainattr = NULL;
    gint is_main = 0;

    GENERIC_CHECKS ;

    i = 0;
    while (attrs[i])
    {
        CASE ("provider",    provider)
        CASE ("name",        winname)
        CASE ("filename",    filepath)
        CASE ("root_widget", root_widget)
        CASE ("main",        mainattr)
        CASE_UNKNOWN ;
        i += 2;
    }

    if (!winname)
    {
        REQUIRE (filepath, "a file path!");
        REQUIRE (root_widget, "a root widget!");
    }

    /* If there's already a window by this name, append to it;
     * else create a new window */
    if (winname) 
    {
        ctx->window = dui_gtk_top_find_window_by_name (ctx->top, winname);
    }
    if (NULL == ctx->window)
    {
        gchar * glade_path;
        REQUIRE (filepath, "a file path!");
        REQUIRE (root_widget, "a root widget!");

        if (mainattr && !strcasecmp (mainattr, "yes")) is_main = 1;
        glade_path = g_strconcat (estron_parser_get_fileparent (par),
                "/", filepath, NULL);
        PINFO ("glade path=%s", glade_path);
        ctx->window = dui_window_new (winname, ctx->top);
        dui_window_set_glade (ctx->window, glade_path, root_widget, is_main);
        g_free (glade_path);
    }
}

static void 
window_end (gpointer self)
{
    DwiGtkParseCtxt *ctx = self;
    ctx->window = NULL;
}

static DuiParserElementPlugin *
dwi_window_parser_plugin (DwiGtkParseCtxt *ctx)
{
    DuiParserElementPlugin *plg = g_new0 (DuiParserElementPlugin, 1);

    plg->eltname = "window";
    plg->start_handler = window_start;
    plg->end_handler = window_end;
    plg->user_data = ctx;

    return plg;
}

/* ============================================================== */

static void
sigaction_start (gpointer self, const gchar **attrs)
{
    static const gchar * eltname = "<sigaction>";
    DwiGtkParseCtxt *ctx = self;
    DuiParser *par = ctx->parser;
    gint i;
    const gchar * widgetname = NULL;
    const gchar * signalname = NULL;
    const gchar * sigaction = NULL;

    GENERIC_CHECKS;
    CHECK_NEST (ctx->window, "<window>");

    i = 0;
    while (attrs[i])
    {
        CASE ("widget", widgetname)
        CASE ("signal", signalname)
        CASE ("action", sigaction)
        CASE_UNKNOWN;
        i += 2;
    }

    REQUIRE (widgetname, "a widget!");
    REQUIRE (signalname, "a valid signal name on the widget!");
    REQUIRE (sigaction,  "an action to perform!");

    DuiSignal *sig = dui_signal_new (widgetname, signalname, sigaction);
    dui_window_add_signal (ctx->window, sig, NULL);
}

static DuiParserElementPlugin *
dwi_sigaction_parser_plugin (DwiGtkParseCtxt *ctx)
{
    DuiParserElementPlugin *plg = g_new0 (DuiParserElementPlugin, 1);

    plg->eltname = "sigaction";
    plg->start_handler = sigaction_start;
    plg->end_handler = NULL;
    plg->user_data = ctx;
    
    return plg;
}

/* ============================================================== */

static void
submit_start (gpointer self, const gchar **attrs)
{
    static const gchar * eltname = "<submit>";
    DwiGtkParseCtxt *ctx = self;
    DuiParser *par = ctx->parser;
    gint i;
    const gchar * widgetname = NULL;
    const gchar * signalname = NULL;

    GENERIC_CHECKS ;
    CHECK_NEST (ctx->action, "<form>");

    i = 0;
    while (attrs[i])
    {
        CASE ("widget", widgetname)
        CASE ("signal", signalname)
        CASE_UNKNOWN ;
        i += 2;
    }

    REQUIRE (widgetname, "a widget!");
    REQUIRE (signalname, "a signal!");

    DuiSignal *sig = dui_signal_new (widgetname, signalname, "submit_form");

    dui_window_add_signal (ctx->window, sig, ctx->action);
}

static DuiParserElementPlugin *
dwi_submit_parser_plugin (DwiGtkParseCtxt *ctx)
{
    DuiParserElementPlugin *plg = g_new0 (DuiParserElementPlugin, 1);

    plg->eltname = "submit";
    plg->start_handler = submit_start;
    plg->end_handler = NULL;
    plg->user_data = ctx;
    
    return plg;
}

/* ============================================================== */
/* Handle "where" term for widgets that are multi-row widgets */

static const gchar *
gtk_row_handler (gpointer self, DuiFieldMap *fm, const gchar **attrs)
{
    DwiGtkParseCtxt G_GNUC_UNUSED *ctx = self;
    const gchar * widgetname = NULL;
    const gchar * match_col = NULL;
    gint mcol = -1;

    gint i=0;
    while (attrs[i])
    {
        CASE ("widget",   widgetname)
        CASE ("match_column", match_col)
      {}
        i += 2;
    }

    if (match_col) mcol = atoi (match_col);

    // XXX we expect a widget name and a matching column too
    if (widgetname)
    {
        dui_field_set_wid_where (&fm->target, widgetname, mcol, "equal");
    }
    return widgetname;
}

static DuiParserTablePlugin *
gtk_parser_table_plugin (DwiGtkParseCtxt *ctx)
{
    DuiParserTablePlugin *plg = g_new0 (DuiParserTablePlugin, 1);

    plg->plugin_name = "gtk_parser";
    plg->handler = gtk_row_handler;
    plg->user_data = ctx;
    
    return plg;
}

/* ============================================================== */

static gboolean
dwi_widget_field_handler (gpointer self, DuiField *fld, 
                 const gchar * row_context, const gchar **attrs)
{
    DwiGtkParseCtxt G_GNUC_UNUSED *ctx = self;
    const gchar * widgetname = NULL;
    const gchar * column = NULL;
    gint colnum = -1;

    gint i=0;
    while (attrs[i])
    {
        CASE ("widget", widgetname)
        CASE ("column",   column)
      {}
        i += 2;
    }
    if (column) colnum = atoi (column);

    // XXX we really are expecting a column as well, right ??
    // XXX we should print warning if no widgetname found ... 
    if (widgetname)
    {
    dui_field_set_widget (fld, widgetname, colnum);
        return TRUE;
    }
    return FALSE;
}

static DuiParserFieldPlugin *
dwi_widget_parser_plugin (DwiGtkParseCtxt *ctx)
{
    DuiParserFieldPlugin *plg = g_new0 (DuiParserFieldPlugin, 1);

    plg->fieldname = "widget";
    plg->handler = dwi_widget_field_handler;
    plg->user_data = ctx;
    
    return plg;
}

/* ============================================================== */

static gboolean
dwi_widdata_field_handler (gpointer self, DuiField *fld, 
                 const gchar * row_context, const gchar **attrs)
{
    DwiGtkParseCtxt G_GNUC_UNUSED *ctx = self;
    const gchar * widgetname = NULL;
    const gchar * datakey = NULL;
    const gchar * column = NULL;
    gint colnum = -1;

    gint i=0;
    while (attrs[i])
    {
        CASE ("widget",  widgetname)
        CASE ("column",  column)
        CASE ("data",    datakey)
      {}
        i += 2;
    }
    if (column) colnum = atoi (column);

    // XXX we really are expecting a column as well, right ??
    // XXX we should print warning if no widgetname found ... 
    // REQUIRE (widgetname, "the name of a widget!");
    // REQUIRE (datakey,    "the data field on the widget!");
    if (widgetname)
    {
    dui_field_set_wid_data (fld, widgetname, colnum, datakey);
        return TRUE;
    }
    return FALSE;
}

static DuiParserFieldPlugin *
dwi_widdata_parser_plugin (DwiGtkParseCtxt *ctx)
{
    DuiParserFieldPlugin *plg = g_new0 (DuiParserFieldPlugin, 1);

    plg->fieldname = "widget_data";
    plg->handler = dwi_widdata_field_handler;
    plg->user_data = ctx;

    return plg;
}

/* ============================================================== */

static gboolean
dwi_widarg_field_handler (gpointer self, DuiField *fld, 
                 const gchar * row_context, const gchar **attrs)
{
    DwiGtkParseCtxt G_GNUC_UNUSED *ctx = self;
    const gchar * widgetname = NULL;
    const gchar * argname = NULL;
    const gchar * column = NULL;
    gint colnum = -1;

    gint i=0;
    while (attrs[i])
    {
        CASE ("widget",  widgetname)
        CASE ("column",  column)
        CASE ("arg",     argname)
      {}
        i += 2;
    }
    if (column) colnum = atoi (column);

    // XXX we really are expecting a column as well, right ??
    // XXX we should print warning if no widgetname found ... 
    // REQUIRE (widgetname, "the name of a widget!");
    // REQUIRE (argname,    "the arg on the widget!");
    if (widgetname)
    {
    dui_field_set_wid_arg (fld, widgetname, colnum, argname);
        return TRUE;
    }
    return FALSE;
}

static DuiParserFieldPlugin *
dwi_widarg_parser_plugin (DwiGtkParseCtxt *ctx)
{
    DuiParserFieldPlugin *plg = g_new0 (DuiParserFieldPlugin, 1);

    plg->fieldname = "widget_arg";
    plg->handler = dwi_widarg_field_handler;
    plg->user_data = ctx;
    
    return plg;
}

/* ============================================================== */

static void
add_action (gpointer self,  DuiAction *act)
{
    DwiGtkParseCtxt *ctx = self;
    dui_window_add_action (ctx->window, act);
    ctx->action = act;
}

static void
add_report (gpointer self,  DuiReport *rpt)
{
    DwiGtkParseCtxt *ctx = self;
    dui_window_add_report (ctx->window, rpt);
}

static DuiParserStructPlugin *
dwi_struct_plugin (DwiGtkParseCtxt *ctx)
{
    DuiParserStructPlugin *plg = g_new0 (DuiParserStructPlugin, 1);

    plg->action_created = add_action;
    plg->report_created = add_report;
    plg->user_data = ctx;
    return plg;
}

/* ============================================================== */

DwiGtkParseCtxt *
dwi_gtk_parser_new (DuiParser *par)
{
    DuiParserElementPlugin *plg;
    DwiGtkParseCtxt *ctx = g_new0 (DwiGtkParseCtxt, 1);

    ctx->top = dui_gtk_top_new();
    ctx->parser = par;
    ctx->window = NULL;
    ctx->action = NULL;

    /* Make sure the gtk interface is realized */
    DuiInterfacePlugin *dip = dui_gtk_top_plugin_new(ctx->top);
    DuiInterface *iface = dui_parser_get_interface (par);
    dui_interface_register_plugin (iface, dip);

    plg = dwi_sigaction_parser_plugin(ctx);
    dui_parser_register_element_plugin (par, plg);

    plg = dwi_submit_parser_plugin(ctx);
    dui_parser_register_element_plugin (par, plg);

    plg = dwi_window_parser_plugin(ctx);
    dui_parser_register_element_plugin (par, plg);

    DuiParserTablePlugin *tbl;
    tbl = gtk_parser_table_plugin (ctx);
    dui_parser_register_table_plugin (par, tbl);

   DuiParserFieldPlugin *fp;
    fp = dwi_widget_parser_plugin (ctx);
    dui_parser_register_field_plugin (par, fp);

    fp = dwi_widdata_parser_plugin (ctx);
    dui_parser_register_field_plugin (par, fp);

    fp = dwi_widarg_parser_plugin (ctx);
    dui_parser_register_field_plugin (par, fp);

    DuiParserStructPlugin *psp;
    psp = dwi_struct_plugin (ctx);
    dui_parser_register_struct_plugin (par, psp);

    return ctx;
}

/* ======================== END OF FILE ========================= */
/* ============================================================== */

---