qi-hardware/fped
1
0
Fork 0
mirror of git://projects.qi-hardware.com/fped.git synced 2024-11-25 00:47:10 +02:00
Code
103933acf5
fped/gui.c
Erich Heinzle 7081258910 diff for gEDA PCB export in fped 
I have

1) sorted out the tabbing

2) simplified > 1 element export by exporting elements in a layout (.pcb)

3) documented incompatibilities in the README

4) done it as a diff against origin master

let me know if you need anything else done

Cheers.

Erich

From dae69d9a63071a15c213c72e70b86fe963a67dd4 Mon Sep 17 00:00:00 2001
From: erich_heinzle <a1039181@gmail.com>
Date: Sun, 22 Jan 2017 23:48:57 +1030
Subject: [PATCH] support for export to gEDA format of single and multiple
 footprints in a .pcb layout
2017-01-22 13:15:26 -03:00

539 lines
13 KiB
C
Raw Blame History

/*
* gui.c - Editor GUI core
*
* Written 2009-2012, 2015-2016 by Werner Almesberger
* Copyright 2009-2012, 2015-2016 by Werner Almesberger
* Copyright 2016, Erich Heinzle (gEDA additions)
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*/
#include <stdlib.h>
#include <locale.h>
#include <gtk/gtk.h>
#include "inst.h"
#include "file.h"
#include "gui_util.h"
#include "gui_style.h"
#include "gui_status.h"
#include "gui_canvas.h"
#include "gui_tool.h"
#include "gui_frame.h"
#include "gui.h"
#include "fped.h"
#include "icons/stuff.xpm"
#include "icons/stuff_off.xpm"
#include "icons/meas.xpm"
#include "icons/meas_off.xpm"
#include "icons/all.xpm"
#include "icons/all_off.xpm"
#include "icons/bright.xpm"
#include "icons/bright_off.xpm"
GtkWidget *root;
int show_all = 1;
int show_stuff = 1;
int show_meas = 1;
int show_bright = 0;
static GtkWidget *paned;
static GtkWidget *frames_box;
static GtkWidget *ev_stuff, *ev_meas, *ev_all, *ev_bright;
static GtkWidget *stuff_image[2], *meas_image[2], *all_image[2];
static GtkWidget *bright_image[2];
static GtkItemFactory *menu_factory;
static void do_build_frames(void);
/* ----- save callbacks ---------------------------------------------------- */
static void save_as_fpd(void)
{
GtkWidget *dialog;
dialog = gtk_file_chooser_dialog_new("Save File",
NULL, GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL);
gtk_file_chooser_set_do_overwrite_confirmation(
GTK_FILE_CHOOSER(dialog), TRUE);
if (save_file_name)
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog),
save_file_name);
if (gtk_dialog_run(GTK_DIALOG (dialog)) == GTK_RESPONSE_ACCEPT) {
save_file_name =
gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
save_fpd();
/* @@@ we may leak save_file_name */
no_save = 0;
}
gtk_widget_destroy(dialog);
}
/* ----- view callbacks ---------------------------------------------------- */
static void show_var(void)
{
sidebar = sidebar_var;
change_world();
}
static void show_code(void)
{
sidebar = sidebar_code;
change_world();
}
static void show_pkg(void)
{
sidebar = sidebar_pkg;
change_world();
}
/* ----- allow callbacks --------------------------------------------------- */
static void allow_touch(void)
{
allow_overlap = ao_touch;
change_world();
}
static void allow_any_overlap(void)
{
allow_overlap = ao_any;
change_world();
}
static void allow_neither(void)
{
allow_overlap = ao_none;
change_world();
}
static void allow_holes(void)
{
GtkCheckMenuItem *item =
GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(menu_factory,
"/Allow/Holes"));
holes_linked = !gtk_check_menu_item_get_active(item);
change_world();
}
/* ----- menu bar ---------------------------------------------------------- */
static GtkItemFactoryEntry menu_entries[] = {
{ "/File", NULL, NULL, 0, "<Branch>" },
{ "/File/Save", NULL, save_fpd, 0, "<Item>" },
{ "/File/Save as", NULL, save_as_fpd, 0, "<Item>" },
{ "/File/sep1", NULL, NULL, 0, "<Separator>" },
{ "/File/Write KiCad", NULL, write_kicad, 0, "<Item>" },
{ "/File/Write gEDA", NULL, write_geda, 0, "<Item>" },
{ "/File/Write Postscript",
NULL, write_ps, 0, "<Item>" },
{ "/File/sep2", NULL, NULL, 0, "<Separator>" },
{ "/File/Reload", NULL, reload, 0, "<Item>" },
{ "/File/sep3", NULL, NULL, 0, "<Separator>" },
{ "/File/Quit", NULL, gtk_main_quit, 0, "<Item>" },
{ "/View", NULL, NULL, 0, "<Branch>" },
{ "/View/Zoom in", NULL, zoom_in_center, 0, "<Item>" },
{ "/View/Zoom out", NULL, zoom_out_center,0, "<Item>" },
{ "/View/Zoom all", NULL, zoom_to_extents,0, "<Item>" },
{ "/View/Zoom frame", NULL, zoom_to_frame, 0, "<Item>" },
{ "/View/sep1", NULL, NULL, 0, "<Separator>" },
{ "/View/Show variables",
NULL, show_var, 0, "<RadioItem>" },
{ "/View/Show code", NULL, show_code, 0,
"/View/Show variables" },
{ "/View/Show packages",NULL, show_pkg, 0,
"/View/Show variables" },
{ "/Allow/Touch", NULL, allow_touch, 0, "<RadioItem>" },
{ "/Allow/Overlap", NULL, allow_any_overlap,
0, "/Allow/Touch" },
{ "/Allow/Neither", NULL, allow_neither, 0, "/Allow/Touch" },
{ "/Allow/sep1", NULL, NULL, 0, "<Separator>" },
{ "/Allow/Holes", NULL, allow_holes, 0, "<CheckItem>" }
};
static void make_menu_bar(GtkWidget *hbox)
{
GtkWidget *bar;
menu_factory = gtk_item_factory_new(GTK_TYPE_MENU_BAR, "<FpedMenu>",
NULL);
gtk_item_factory_create_items(menu_factory,
sizeof(menu_entries)/sizeof(*menu_entries), menu_entries, NULL);
bar = gtk_item_factory_get_widget(menu_factory, "<FpedMenu>");
gtk_box_pack_start(GTK_BOX(hbox), bar, TRUE, TRUE, 0);
gtk_widget_set_sensitive(
gtk_item_factory_get_item(menu_factory, "/File/Save"), !no_save);
gtk_widget_set_sensitive(
gtk_item_factory_get_item(menu_factory, "/File/Reload"),
no_save && !!save_file_name);
}
void update_menu_bar(void)
{
const char *s;
switch (sidebar) {
case sidebar_var:
s = "/View/Show variables";
break;
case sidebar_code:
s = "/View/Show code";
break;
case sidebar_pkg:
s = "/View/Show packages";
break;
default:
abort();
}
gtk_check_menu_item_set_active(
GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(menu_factory, s)),
TRUE);
switch (allow_overlap) {
case ao_none:
s = "/Allow/Neither";
break;
case ao_touch:
s = "/Allow/Touch";
break;
case ao_any:
s = "/Allow/Overlap";
break;
default:
abort();
}
gtk_check_menu_item_set_active(
GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(menu_factory, s)),
TRUE);
gtk_check_menu_item_set_active(
GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(menu_factory,
"/Allow/Holes")), !holes_linked);
}
static gboolean toggle_all(GtkWidget *widget, GdkEventButton *event,
gpointer data)
{
switch (event->button) {
case 1:
show_all = !show_all;
set_image(ev_all, all_image[show_all]);
inst_deselect();
redraw();
break;
}
return TRUE;
}
static gboolean toggle_stuff(GtkWidget *widget, GdkEventButton *event,
gpointer data)
{
switch (event->button) {
case 1:
show_stuff = !show_stuff;
set_image(ev_stuff, stuff_image[show_stuff]);
inst_deselect();
redraw();
break;
}
return TRUE;
}
static gboolean toggle_meas(GtkWidget *widget, GdkEventButton *event,
gpointer data)
{
switch (event->button) {
case 1:
show_meas = !show_meas;
set_image(ev_meas, meas_image[show_meas]);
inst_deselect();
redraw();
break;
}
return TRUE;
}
static gboolean toggle_bright(GtkWidget *widget, GdkEventButton *event,
gpointer data)
{
switch (event->button) {
case 1:
show_bright = !show_bright;
set_image(ev_bright, bright_image[show_bright]);
inst_deselect();
redraw();
break;
}
return TRUE;
}
static void make_tool_bar(GtkWidget *hbox, GdkDrawable *drawable)
{
GtkWidget *bar;
bar = gtk_toolbar_new();
gtk_box_pack_end(GTK_BOX(hbox), bar, TRUE, TRUE, 0);
//gtk_box_pack_end(GTK_BOX(hbox), bar, FALSE, FALSE, 0);
gtk_toolbar_set_style(GTK_TOOLBAR(bar), GTK_TOOLBAR_ICONS);
ev_all = tool_button(bar, drawable, NULL, NULL, toggle_all, NULL);
ev_stuff = tool_button(bar, drawable, NULL, NULL, toggle_stuff, NULL);
ev_meas = tool_button(bar, drawable, NULL, NULL, toggle_meas, NULL);
ev_bright = tool_button(bar, drawable, NULL, NULL, toggle_bright, NULL);
stuff_image[0] = gtk_widget_ref(make_image(drawable, xpm_stuff_off,
"Show vectors and frame references (disabled)"));
stuff_image[1] = gtk_widget_ref(make_image(drawable, xpm_stuff,
"Show vectors and frame references (enabled)"));
meas_image[0] = gtk_widget_ref(make_image(drawable, xpm_meas_off,
"Show measurements (disabled)"));
meas_image[1] = gtk_widget_ref(make_image(drawable, xpm_meas,
"Show measurements (enabled)"));
all_image[0] = gtk_widget_ref(make_image(drawable, xpm_all_off,
"Show all frames (currently showing only the active frame)"));
all_image[1] = gtk_widget_ref(make_image(drawable, xpm_all,
"Show all frames (enabled)"));
bright_image[0] = gtk_widget_ref(make_image(drawable, xpm_bright_off,
"Highlight elements (disabled)"));
bright_image[1] = gtk_widget_ref(make_image(drawable, xpm_bright,
"Highlight elements (enabled)"));
set_image(ev_stuff, stuff_image[show_stuff]);
set_image(ev_meas, meas_image[show_meas]);
set_image(ev_all, all_image[show_all]);
set_image(ev_bright, bright_image[show_bright]);
}
static void cleanup_tool_bar(void)
{
g_object_unref(stuff_image[0]);
g_object_unref(stuff_image[1]);
g_object_unref(meas_image[0]);
g_object_unref(meas_image[1]);
g_object_unref(all_image[0]);
g_object_unref(all_image[1]);
g_object_unref(bright_image[0]);
g_object_unref(bright_image[1]);
}
static void make_top_bar(GtkWidget *vbox)
{
GtkWidget *hbox;
hbox = gtk_hbox_new(FALSE, 0);
make_menu_bar(hbox);
make_tool_bar(hbox, root->window);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
}
/* ----- central screen area ----------------------------------------------- */
static void resize_frames_area(GtkWidget *widget, GtkAllocation *allocation,
gpointer user_data)
{
static int width = 0;
if (allocation->width == width)
return;
width = allocation->width;
do_build_frames();
}
static void make_center_area(GtkWidget *vbox)
{
GtkWidget *hbox, *frames_area;//, *paned;
GtkWidget *tools;
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
paned = gtk_hpaned_new();
gtk_box_pack_start(GTK_BOX(hbox), paned, TRUE, TRUE, 0);
/* Frames */
frames_area = gtk_scrolled_window_new(NULL, NULL);
gtk_paned_add1(GTK_PANED(paned), frames_area);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(frames_area),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request(frames_area,
DEFAULT_FRAME_AREA_WIDTH, DEFAULT_FRAME_AREA_HEIGHT);
frames_box = gtk_vbox_new(FALSE, 0);
build_frames(frames_box, DEFAULT_FRAME_AREA_WIDTH);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(frames_area),
frames_box);
g_signal_connect(G_OBJECT(frames_area), "size-allocate",
G_CALLBACK(resize_frames_area), NULL);
/* Canvas */
gtk_paned_add2(GTK_PANED(paned), make_canvas());
/* Icon bar */
tools = gui_setup_tools(root->window);
gtk_box_pack_end(GTK_BOX(hbox), tools, FALSE, FALSE, 0);
}
/* ----- GUI construction -------------------------------------------------- */
static void do_build_frames(void)
{
int width;
width = gtk_paned_get_position(GTK_PANED(paned));
build_frames(frames_box, width > 0 ? width : DEFAULT_FRAME_AREA_WIDTH);
}
void change_world(void)
{
struct bbox before, after;
int reachable_is_active;
inst_deselect();
status_begin_reporting();
before = inst_get_bbox(NULL);
reachable_is_active = reachable_pkg && reachable_pkg == active_pkg;
instantiate();
if (reachable_is_active && reachable_pkg &&
reachable_pkg != active_pkg) {
active_pkg = reachable_pkg;
instantiate();
}
after = inst_get_bbox(NULL);
do_build_frames();
if (after.min.x < before.min.x || after.min.y < before.min.y ||
after.max.x > before.max.x || after.max.y > before.max.y)
zoom_to_extents();
else
redraw();
}
void change_world_reselect(void)
{
struct obj *selected_obj;
/*
* We can edit an object even if it's not selected if it was picked
* via the item view. inst_select_obj tries to find an instance, but
* if there's never been a successful instantiation since creation of
* the object or if the object is unreachable for some other reason,
* then selected_inst will be NULL.
*/
if (!selected_inst) {
change_world();
return;
}
selected_obj = selected_inst->obj;
change_world();
inst_select_obj(selected_obj);
}
static void make_screen(GtkWidget *window)
{
GtkWidget *vbox;
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), vbox);
make_top_bar(vbox);
make_center_area(vbox);
make_status_area(vbox);
}
int gui_init(int *argc, char ***argv)
{
gtk_init(argc, argv);
setlocale(LC_ALL, "C"); /* damage control */
return 0;
}
int gui_main(void)
{
root = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(root), GTK_WIN_POS_CENTER);
gtk_window_set_default_size(GTK_WINDOW(root), 620, 460);
if (*VERSION)
gtk_window_set_title(GTK_WINDOW(root),
"fped (rev " VERSION ")");
else
gtk_window_set_title(GTK_WINDOW(root), "fped");
/* get root->window */
gtk_widget_show_all(root);
g_signal_connect(G_OBJECT(root), "destroy",
G_CALLBACK(gtk_main_quit), NULL);
make_screen(root);
gtk_widget_show_all(root);
gui_setup_style(root->window);
init_canvas();
edit_nothing();
select_frame(frames);
make_popups();
update_menu_bar();
gtk_main();
gui_cleanup_style();
gui_cleanup_tools();
cleanup_tool_bar();
cleanup_status_area();
return 0;
}
View Git Blame Copy Permalink