whandler.cc

Click is a modular router toolkit. To use it you ll need to know how to compile and install the sof

	    if (last != s)
		text.append(last, s - last);
	    if (positions.size() && positions.back() == text.length())
		positions.pop_back();
	    else
		positions.push_back(text.length());
	    text.append(hexdigits[((unsigned char) *s) >> 4]);
	    text.append(hexdigits[((unsigned char) *s) & 15]);
	    positions.push_back(text.length());
	    last = s + 1;
	    multiline = true;
	} else if (*s == '\n' || *s == '\f')
	    multiline = true;
    if (text.length())
	text.append(last, data.end() - last);
    return multiline;
}

void whandler::hinfo::display(whandler *wh, bool change_form)
{
    if (!wdata || (hv->flags() & hflag_button))
	return;

    // Multiline data requires special handling
    StringAccum binary_data;
    Vector<int> positions;
    bool multiline = binary_to_utf8(hv->hvalue(), binary_data, positions);

    // Valid checkbox data?
    if (hv->flags() & hflag_checkbox) {
	bool value;
	if (hv->have_hvalue()
	    && cp_bool(cp_uncomment(hv->hvalue()), &value)) {
	    gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(wdata), FALSE);
	    gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(wdata), value);
	    return;
	} else if (!hv->have_hvalue() || !change_form) {
	    gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(wdata), TRUE);
	    return;
	} else
	    create(wh, (hv->flags() & ~hflag_checkbox) | (multiline ? hflag_multiline : 0), false);
    }

    // Valid multiline data?
    if (!(hv->flags() & hflag_multiline) && (multiline || positions.size())) {
	if (!change_form) {
	    gtk_entry_set_text(GTK_ENTRY(wdata), "???");
	    gtk_entry_set_position(GTK_ENTRY(wdata), -1);
	    return;
	} else
	    create(wh, hv->flags() | hflag_multiline, false);
    }

    // Set data
    if (positions.size()) {
	assert(hv->flags() & hflag_multiline);
	GtkTextBuffer *b = gtk_text_view_get_buffer(GTK_TEXT_VIEW(wdata));
	gtk_text_buffer_set_text(b, binary_data.data(), binary_data.length());
	GtkTextIter i1, i2;
	for (int *i = positions.begin(); i != positions.end(); i += 2) {
	    gtk_text_buffer_get_iter_at_offset(b, &i1, i[0]);
	    gtk_text_buffer_get_iter_at_offset(b, &i2, i[1]);
	    gtk_text_buffer_apply_tag(b, wh->main()->binary_tag(), &i1, &i2);
	}
	gtk_text_buffer_get_end_iter(b, &i1);
	gtk_text_buffer_place_cursor(b, &i1);
    } else if (hv->flags() & hflag_multiline) {
	GtkTextBuffer *b = gtk_text_view_get_buffer(GTK_TEXT_VIEW(wdata));
	gtk_text_buffer_set_text(b, hv->hvalue().data(), hv->hvalue().length());
	GtkTextIter i1;
	gtk_text_buffer_get_end_iter(b, &i1);
	gtk_text_buffer_place_cursor(b, &i1);
    } else {
	gtk_entry_set_text(GTK_ENTRY(wdata), hv->hvalue().c_str());
	gtk_entry_set_position(GTK_ENTRY(wdata), -1);
    }

    // Display parameters
    if (wlabel && hv->read_param() && (hv->hparam() || hv->have_hvalue())) {
	if (!hv->hparam())
	    gtk_label_set_text(GTK_LABEL(wlabel), hv->handler_name().c_str());
	else {
	    StringAccum sa;
	    sa << hv->handler_name() << ' '
	       << hv->hparam().substring(0, MIN(hv->hparam().length(), 100));
	    gtk_label_set_text(GTK_LABEL(wlabel), sa.c_str());
	}
    }

    // Unhighlight
    set_edit_active(wh->main(), false);
}



/*****
 *
 * Life is elsewhere
 *
 */

void whandler::display(const String &ename, bool incremental)
{
    if ((_display_ename == ename && incremental)
	|| !GTK_WIDGET_DRAWABLE(_eviewbox))
	return;
    _display_ename = ename;
    gtk_container_foreach(GTK_CONTAINER(_handlerbox), destroy_callback, NULL);

    // no longer interested in old handler values
    for (std::deque<hinfo>::iterator hiter = _hinfo.begin();
	 hiter != _hinfo.end(); ++hiter)
	hiter->hv->set_flags(main(), hiter->hv->flags() & ~(hflag_preferences | hflag_notify_whandlers));
    _hinfo.clear();

    hide_actions();
    _hpref_actions = 0;

    handler_values::iterator hiter = main()->hvalues().begin(ename);

    // no information about this element's handlers yet
    if (hiter == main()->hvalues().end()) {
	gtk_text_view_set_editable(GTK_TEXT_VIEW(_eview_config), TRUE);
	g_object_set(G_OBJECT(_eview_config), "can-focus", TRUE, (const char *) NULL);

	if (!ename || _rw->empty())
	    /* there are no elements; do nothing */;
	else if (!_rw->element_exists(ename, true)) {
	    // either not an element, or a compound (compounds have no
	    // handlers).  Report an error if not an element at all.
	    if (!_rw->element_exists(ename)) {
		GtkWidget *l = gtk_label_new(NULL);
		gtk_label_set_markup(GTK_LABEL(l), _("Unknown element"));
		gtk_widget_show(l);
		gtk_box_pack_start(_handlerbox, l, FALSE, FALSE, 0);
	    }
	} else if (_rw->driver()) {
	    GtkWidget *l = gtk_label_new(NULL);
	    gtk_label_set_markup(GTK_LABEL(l), _("<i>Loading...</i>"));
	    gtk_widget_show(l);
	    gtk_box_pack_start(_handlerbox, l, FALSE, FALSE, 0);
	    handler_value *hv = _rw->hvalues().find_force(ename + ".handlers");
	    hv->set_flags(main(), hv->flags() | hflag_notify_whandlers);
	    hv->refresh(main());
	}
	return;
    }

    // parse handlers into _hinfo
    for (; hiter != main()->hvalues().end(); ++hiter)
	_hinfo.push_back(hiter.operator->());

    // parse _hinfo into widgets
    for (std::deque<hinfo>::iterator hi = _hinfo.begin();
	 hi != _hinfo.end(); ++hi)
	if (hi->hv->flags() & hflag_special) {
	    if (hi->hv->handler_name() == "config") {
		hi->wdata = _eview_config;
		gboolean edit = (active() && hi->editable() ? TRUE : FALSE);
		gtk_text_view_set_editable(GTK_TEXT_VIEW(hi->wdata), edit);
		g_object_set(hi->wdata, "can-focus", edit, (const char *) NULL);
		g_object_set_data_full(G_OBJECT(hi->wdata), "clicky_hname", g_strdup(hi->hv->hname().c_str()), g_free);
		hi->hv->set_flags(_rw, hi->hv->flags() | hflag_notify_whandlers);
		hi->hv->refresh(_rw);
	    }
	} else {
	    hi->create(this, hi->hv->flags() | hflag_notify_whandlers, true);
	    if (hi->hv->refreshable() && !hi->hv->have_hvalue()
		&& hi->hv->have_required_hparam()
		&& (hi->hv->flags() & hflag_collapse) == 0)
		hi->hv->refresh(_rw);
	}

    // the final button box
    GtkWidget *bbox = gtk_hbutton_box_new();
    gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
    _hpref_actions = GTK_BUTTON_BOX(bbox);
    on_preferences(onpref_initial);
    gtk_box_pack_end(_handlerbox, bbox, FALSE, FALSE, 0);

    GtkWidget *w = gtk_hseparator_new();
    gtk_box_pack_end(_handlerbox, w, FALSE, FALSE, 4);
    gtk_widget_show(w);
}

void whandler::on_preferences(int action)
{
    gtk_container_foreach(GTK_CONTAINER(_hpref_actions), destroy_callback, NULL);
    if (action == onpref_initial || action == onpref_prefok
	|| action == onpref_prefcancel) {
	GtkWidget *w = gtk_button_new_from_stock(GTK_STOCK_PROPERTIES);
	gtk_button_set_relief(GTK_BUTTON(w), GTK_RELIEF_NONE);
	gtk_container_add(GTK_CONTAINER(_hpref_actions), w);
	g_signal_connect(w, "clicked", G_CALLBACK(on_hpref_preferences_clicked), this);
    } else {
	GtkWidget *w = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
	gtk_container_add(GTK_CONTAINER(_hpref_actions), w);
	g_signal_connect(w, "clicked", G_CALLBACK(on_hpref_cancel_clicked), this);
	w = gtk_button_new_from_stock(GTK_STOCK_OK);
	gtk_container_add(GTK_CONTAINER(_hpref_actions), w);
	g_signal_connect(w, "clicked", G_CALLBACK(on_hpref_ok_clicked), this);
    }
    gtk_widget_show_all(GTK_WIDGET(_hpref_actions));

    if (action == onpref_prefcancel)
	for (std::deque<hinfo>::iterator iter = _hinfo.begin();
	     iter != _hinfo.end(); ++iter)
	    if (!iter->hv->special()) {
		iter->hv->set_autorefresh_period(iter->_old_autorefresh_period);
		iter->hv->set_flags(main(), iter->_old_flags);
	    }

    int clear = 0, set = 0;
    if (action == onpref_showpref)
	set = hflag_preferences;
    if (action == onpref_prefok || action == onpref_prefcancel)
	clear = hflag_preferences;
    if (clear || set)
	for (std::deque<hinfo>::iterator iter = _hinfo.begin();
	     iter != _hinfo.end(); ++iter)
	    if (!iter->hv->special())
		iter->create(this, (iter->hv->flags() & ~clear) | set, false);
}

void whandler::make_actions(int which)
{
    assert(which == 0 || which == 1);
    if (_actions[which])
	return;
    // modified from GtkTreeView's search window

    // create window
    _actions[which] = gtk_window_new(GTK_WINDOW_POPUP);
    if (GTK_WINDOW(_rw->_window)->group)
	gtk_window_group_add_window(GTK_WINDOW(_rw->_window)->group, GTK_WINDOW(_actions[which]));
    gtk_window_set_transient_for(GTK_WINDOW(_actions[which]), GTK_WINDOW(_rw->_window));
    gtk_window_set_destroy_with_parent(GTK_WINDOW(_actions[which]), TRUE);
    // gtk_window_set_modal(GTK_WINDOW(tree_view->priv->search_window), TRUE);

    // add contents
    GtkWidget *frame = gtk_frame_new(NULL);
    gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_ETCHED_IN);
    gtk_widget_show(frame);
    gtk_container_add(GTK_CONTAINER(_actions[which]), frame);

    GtkWidget *bbox = gtk_hbutton_box_new();
    gtk_box_set_spacing(GTK_BOX(bbox), 5);
    gtk_widget_show(bbox);
    gtk_container_set_border_width(GTK_CONTAINER(bbox), 3);
    gtk_container_add(GTK_CONTAINER(frame), bbox);
    GtkWidget *cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
    gtk_widget_show(cancel);
    gtk_container_add(GTK_CONTAINER(bbox), cancel);
    g_signal_connect(cancel, "clicked", G_CALLBACK(on_handler_action_cancel_clicked), this);
    if (which == 0)
	_actions_apply[which] = gtk_button_new_from_stock(GTK_STOCK_APPLY);
    else {
	_actions_apply[which] = gtk_button_new_with_mnemonic(_("_Query"));
	gtk_button_set_image(GTK_BUTTON(_actions_apply[which]), gtk_image_new_from_stock(GTK_STOCK_OK, GTK_ICON_SIZE_BUTTON));
    }
    gtk_widget_show(_actions_apply[which]);
    gtk_container_add(GTK_CONTAINER(bbox), _actions_apply[which]);
    g_signal_connect(_actions_apply[which], "clicked", G_CALLBACK(on_handler_action_apply_clicked), this);

    gtk_widget_realize(_actions[which]);
}

void whandler::show_actions(GtkWidget *near, const String &hname, bool changed)
{
    if ((hname == _actions_hname && (!changed || _actions_changed))
	|| _updating)
	return;

    // find handler
    hinfo *hi = find_hinfo(hname);
    if (!hi || !hi->editable() || !active())
	return;

    // mark change
    if (changed) {
	hi->set_edit_active(main(), true);
	if (hname == _actions_hname) {
	    _actions_changed = changed;
	    return;
	}
    }

    // hide old actions, create new ones
    if (_actions_hname)
	hide_actions(_actions_hname);
    _actions_hname = hname;
    _actions_changed = changed;

    // erase inconsistent states from "no value yet available"
    if (hi->hv->flags() & hflag_checkbox) {
	GtkToggleButton *b = GTK_TOGGLE_BUTTON(hi->wdata);
	if (gtk_toggle_button_get_inconsistent(b)) {
	    gtk_toggle_button_set_active(b, FALSE);
	    gtk_toggle_button_set_inconsistent(b, FALSE);
	}
    } else if ((hi->hv->flags() & hflag_have_hvalue) == 0) {
	if (hi->hv->flags() & hflag_multiline) {
	    GtkTextBuffer *b = gtk_text_view_get_buffer(GTK_TEXT_VIEW(hi->wdata));
	    if (gtk_text_buffer_get_char_count(b) == 3) {
		GtkTextIter i1, i2;
		gtk_text_buffer_get_start_iter(b, &i1);
		gtk_text_buffer_get_end_iter(b, &i2);
		gchar *data = gtk_text_buffer_get_text(b, &i1, &i2, FALSE);
		if (strcmp(data, "???") == 0)
		    gtk_text_buffer_set_text(b, "", 0);
		g_free(data);
	    }
	} else {
	    if (strcmp(gtk_entry_get_text(GTK_ENTRY(hi->wdata)), "???") == 0)
		gtk_entry_set_text(GTK_ENTRY(hi->wdata), "");
	}
    }

    // get monitor and widget coordinates
    gtk_widget_realize(near);
    GdkScreen *screen = gdk_drawable_get_screen(near->window);
    gint monitor_num = gdk_screen_get_monitor_at_window(screen, near->window);
    GdkRectangle monitor;
    gdk_screen_get_monitor_geometry(screen, monitor_num, &monitor);