/* Run a glib GMainLoop which intercepts key and mouse button events from
| the top level loop. When a mouse or key is hit in the Output drawing
| area, quit the loop so the top level loop can continue and use the
| the mouse pointer coordinates at the time of the mouse button event.
*/
static gboolean
run_get_location_loop (const gchar * message)
{
GMainLoop *loop;
gulong button_handler, key_handler;
gint oldObjState, oldLineState, oldBoxState;
ghid_status_line_set_text (message);
oldObjState = Crosshair.AttachedObject.State;
oldLineState = Crosshair.AttachedLine.State;
oldBoxState = Crosshair.AttachedBox.State;
HideCrosshair (true);
Crosshair.AttachedObject.State = STATE_FIRST;
Crosshair.AttachedLine.State = STATE_FIRST;
Crosshair.AttachedBox.State = STATE_FIRST;
ghid_hand_cursor ();
RestoreCrosshair (true);
/* Stop the top level GMainLoop from getting user input from keyboard
| and mouse so we can install our own handlers here. Also set the
| control interface insensitive so all the user can do is hit a key
| or mouse button in the Output drawing area.
*/
ghid_interface_input_signals_disconnect ();
ghid_interface_set_sensitive (FALSE);
got_location = TRUE; /* Will be unset by hitting most keys */
button_handler =
g_signal_connect (G_OBJECT (gport->drawing_area),
"button_press_event",
G_CALLBACK (loop_button_press_cb), &loop);
key_handler =
g_signal_connect (G_OBJECT (gport->top_window),
"key_press_event",
G_CALLBACK (loop_key_press_cb), &loop);
loop = g_main_loop_new (NULL, FALSE);
g_main_loop_run (loop);
g_main_loop_unref (loop);
g_signal_handler_disconnect (gport->drawing_area, button_handler);
g_signal_handler_disconnect (gport->top_window, key_handler);
ghid_interface_input_signals_connect (); /* return to normal */
ghid_interface_set_sensitive (TRUE);
HideCrosshair (true);
Crosshair.AttachedObject.State = oldObjState;
Crosshair.AttachedLine.State = oldLineState;
Crosshair.AttachedBox.State = oldBoxState;
RestoreCrosshair (true);
ghid_restore_cursor ();
ghid_set_status_line_label ();
return got_location;
}
gboolean
ghid_port_button_release_cb (GtkWidget * drawing_area,
GdkEventButton * ev, GtkUIManager * ui)
{
ModifierKeysState mk;
gboolean drag;
GdkModifierType state;
ghid_note_event_location (ev);
state = (GdkModifierType) (ev->state);
mk = ghid_modifier_keys_state (&state);
drag = have_crosshair_attachments ();
if (drag)
HideCrosshair (TRUE);
do_mouse_action(ev->button, mk + M_Release);
if (drag)
{
AdjustAttachedObjects ();
ghid_invalidate_all ();
RestoreCrosshair (TRUE);
ghid_screen_update ();
}
ghid_set_status_line_label ();
g_idle_add (ghid_idle_cb, NULL);
return TRUE;
}
gboolean
ghid_port_button_press_cb (GtkWidget * drawing_area,
GdkEventButton * ev, GtkUIManager * ui)
{
ModifierKeysState mk;
gboolean drag;
GdkModifierType state;
/* Reject double and triple click events */
if (ev->type != GDK_BUTTON_PRESS) return TRUE;
ghid_note_event_location (ev);
state = (GdkModifierType) (ev->state);
mk = ghid_modifier_keys_state (&state);
ghid_show_crosshair (FALSE);
HideCrosshair (TRUE);
drag = have_crosshair_attachments ();
do_mouse_action(ev->button, mk);
ghid_invalidate_all ();
RestoreCrosshair (TRUE);
ghid_set_status_line_label ();
ghid_show_crosshair (TRUE);
if (!gport->panning)
g_idle_add (ghid_idle_cb, NULL);
return TRUE;
}
gboolean
ghid_port_drawing_area_configure_event_cb (GtkWidget * widget,
GdkEventConfigure * ev,
GHidPort * out)
{
static gboolean first_time_done;
HideCrosshair (TRUE);
gport->width = ev->width;
gport->height = ev->height;
if (gport->pixmap)
gdk_pixmap_unref (gport->pixmap);
gport->pixmap = gdk_pixmap_new (widget->window,
gport->width, gport->height, -1);
gport->drawable = gport->pixmap;
if (!first_time_done)
{
gport->colormap = gtk_widget_get_colormap (gport->top_window);
gport->bg_gc = gdk_gc_new (gport->drawable);
if (gdk_color_parse (Settings.BackgroundColor, &gport->bg_color))
gdk_color_alloc (gport->colormap, &gport->bg_color);
else
gdk_color_white (gport->colormap, &gport->bg_color);
gdk_gc_set_foreground (gport->bg_gc, &gport->bg_color);
gport->offlimits_gc = gdk_gc_new (gport->drawable);
if (gdk_color_parse (Settings.OffLimitColor, &gport->offlimits_color))
gdk_color_alloc (gport->colormap, &gport->offlimits_color);
else
gdk_color_white (gport->colormap, &gport->offlimits_color);
gdk_gc_set_foreground (gport->offlimits_gc, &gport->offlimits_color);
first_time_done = TRUE;
PCBChanged (0, NULL, 0, 0);
}
if (gport->mask)
{
gdk_pixmap_unref (gport->mask);
gport->mask = gdk_pixmap_new (0, gport->width, gport->height, 1);
}
ghid_port_ranges_scale (FALSE);
ghid_invalidate_all ();
RestoreCrosshair (TRUE);
return 0;
}
gboolean
ghid_port_key_release_cb (GtkWidget * drawing_area, GdkEventKey * kev,
GtkUIManager * ui)
{
gint ksym = kev->keyval;
if (ghid_is_modifier_key_sym (ksym))
ghid_note_event_location (NULL);
HideCrosshair (TRUE);
AdjustAttachedObjects ();
ghid_invalidate_all ();
RestoreCrosshair (TRUE);
ghid_screen_update ();
g_idle_add (ghid_idle_cb, NULL);
return FALSE;
}
static int
ReportFoundPins (int argc, char **argv, int x, int y)
{
static DynamicStringType list;
char temp[64];
int col = 0;
DSClearString (&list);
DSAddString (&list, "The following pins/pads are FOUND:\n");
ELEMENT_LOOP (PCB->Data);
{
PIN_LOOP (element);
{
if (TEST_FLAG (FOUNDFLAG, pin))
{
sprintf (temp, "%s-%s,%c",
NAMEONPCB_NAME (element),
pin->Number,
((col++ % (COLUMNS + 1)) == COLUMNS) ? '\n' : ' ');
DSAddString (&list, temp);
}
}
END_LOOP;
PAD_LOOP (element);
{
if (TEST_FLAG (FOUNDFLAG, pad))
{
sprintf (temp, "%s-%s,%c",
NAMEONPCB_NAME (element), pad->Number,
((col++ % (COLUMNS + 1)) == COLUMNS) ? '\n' : ' ');
DSAddString (&list, temp);
}
}
END_LOOP;
}
END_LOOP;
HideCrosshair (false);
gui->report_dialog ("Report", list.Data);
RestoreCrosshair (false);
return 0;
}
void
ghid_port_ranges_changed (void)
{
GtkAdjustment *h_adj, *v_adj;
if (!ghidgui->combine_adjustments)
HideCrosshair (FALSE);
if (ghidgui->combine_adjustments)
{
ghidgui->combine_adjustments = FALSE;
return;
}
ghidgui->need_restore_crosshair = TRUE;
h_adj = gtk_range_get_adjustment (GTK_RANGE (ghidgui->h_range));
v_adj = gtk_range_get_adjustment (GTK_RANGE (ghidgui->v_range));
gport->view_x0 = h_adj->value;
gport->view_y0 = v_adj->value;
ghid_invalidate_all ();
}
/* ---------------------------------------------------------------------------
* move crosshair absolute switched off if it moved
* return true if it switched off
*/
bool
MoveCrosshairAbsolute (LocationType X, LocationType Y)
{
LocationType x, y, z;
x = Crosshair.X;
y = Crosshair.Y;
FitCrosshairIntoGrid (X, Y);
if (Crosshair.X != x || Crosshair.Y != y)
{
/* back up to old position and erase crosshair */
z = Crosshair.X;
Crosshair.X = x;
x = z;
z = Crosshair.Y;
Crosshair.Y = y;
HideCrosshair (false);
/* now move forward again */
Crosshair.X = x;
Crosshair.Y = z;
return (true);
}
return (false);
}
static int
ReportNetLength (int argc, char **argv, int x, int y)
{
double length = 0;
char *netname = 0;
int found = 0;
if (ResetConnections (true))
Draw ();
/* NB: XYtoNetLength calls LookupConnection, which performs an undo
* serial number update, so we don't need to add one here.
*/
gui->get_coords ("Click on a connection", &x, &y);
length = XYtoNetLength (x, y, &found);
if (!found)
{
gui->log ("No net under cursor.\n");
return 1;
}
ELEMENT_LOOP (PCB->Data);
{
PIN_LOOP (element);
{
if (TEST_FLAG (FOUNDFLAG, pin))
{
int ni, nei;
char *ename = element->Name[NAMEONPCB_INDEX].TextString;
char *pname = pin->Number;
char *n;
if (ename && pname)
{
n = Concat (ename, "-", pname, NULL);
for (ni = 0; ni < PCB->NetlistLib.MenuN; ni++)
for (nei = 0; nei < PCB->NetlistLib.Menu[ni].EntryN; nei++)
{
if (strcmp (PCB->NetlistLib.Menu[ni].Entry[nei].ListEntry, n) == 0)
{
netname = PCB->NetlistLib.Menu[ni].Name + 2;
goto got_net_name; /* four for loops deep */
}
}
}
}
}
END_LOOP;
PAD_LOOP (element);
{
if (TEST_FLAG (FOUNDFLAG, pad))
{
int ni, nei;
char *ename = element->Name[NAMEONPCB_INDEX].TextString;
char *pname = pad->Number;
char *n;
if (ename && pname)
{
n = Concat (ename, "-", pname, NULL);
for (ni = 0; ni < PCB->NetlistLib.MenuN; ni++)
for (nei = 0; nei < PCB->NetlistLib.Menu[ni].EntryN; nei++)
{
if (strcmp (PCB->NetlistLib.Menu[ni].Entry[nei].ListEntry, n) == 0)
{
netname = PCB->NetlistLib.Menu[ni].Name + 2;
goto got_net_name; /* four for loops deep */
}
}
}
}
}
END_LOOP;
}
END_LOOP;
got_net_name:
HideCrosshair (false);
{
int prec = Settings.grid_units_mm? 4: 2;
if (netname)
gui->log ("Net \"%s\" length: %.*f %s\n", netname, prec, UNIT (length));
else
gui->log ("Net length: %.*f %s\n", prec, UNIT (length));
}
RestoreCrosshair (false);
return 0;
}
static int
ReportDialog (int argc, char **argv, int x, int y)
{
void *ptr1, *ptr2, *ptr3;
int type, prec = Settings.grid_units_mm? 4: 2;
char report[2048];
type = SearchScreen (x, y, REPORT_TYPES, &ptr1, &ptr2, &ptr3);
if (type == NO_TYPE)
type =
SearchScreen (x, y, REPORT_TYPES | LOCKED_TYPE, &ptr1, &ptr2, &ptr3);
switch (type)
{
case VIA_TYPE:
{
PinTypePtr via;
#ifndef NDEBUG
if (gui->shift_is_pressed ())
{
__r_dump_tree (PCB->Data->via_tree->root, 0);
return 0;
}
#endif
via = (PinTypePtr) ptr2;
if (TEST_FLAG (HOLEFLAG, via))
sprintf (&report[0], "VIA ID# %ld; Flags:%s\n"
"(X,Y) = (%.*f, %.*f) %s.\n"
"It is a pure hole of diameter %.*f %s.\n"
"Name = \"%s\"."
"%s", via->ID, flags_to_string (via->Flags, VIA_TYPE),
prec, units (via->X), prec, UNIT (via->Y),
prec, UNIT (via->DrillingHole),
EMPTY (via->Name), TEST_FLAG (LOCKFLAG,
via) ? "It is LOCKED.\n" :
"");
else
sprintf (&report[0], "VIA ID# %ld; Flags:%s\n"
"(X,Y) = (%.*f, %.*f) %s.\n"
"Copper width = %0.*f %s. Drill width = %0.*f %s.\n"
"Clearance width in polygons = %0.*f %s.\n"
"Annulus = %0.*f %s.\n"
"Solder mask hole = %0.*f %s (gap = %0.*f %s).\n"
"Name = \"%s\"."
"%s", via->ID, flags_to_string (via->Flags, VIA_TYPE),
prec, units (via->X), prec, UNIT (via->Y),
prec, UNIT (via->Thickness),
prec, UNIT (via->DrillingHole),
prec, UNIT (via->Clearance / 2.),
prec, UNIT ((via->Thickness - via->DrillingHole)/2),
prec, UNIT (via->Mask),
prec, UNIT ((via->Mask - via->Thickness)/2),
EMPTY (via->Name), TEST_FLAG (LOCKFLAG, via) ?
"It is LOCKED.\n" : "");
break;
}
case PIN_TYPE:
{
PinTypePtr Pin;
ElementTypePtr element;
#ifndef NDEBUG
if (gui->shift_is_pressed ())
{
__r_dump_tree (PCB->Data->pin_tree->root, 0);
return 0;
}
#endif
Pin = (PinTypePtr) ptr2;
element = (ElementTypePtr) ptr1;
PIN_LOOP (element);
{
if (pin == Pin)
break;
}
END_LOOP;
if (TEST_FLAG (HOLEFLAG, Pin))
sprintf (&report[0], "PIN ID# %ld; Flags:%s\n"
"(X,Y) = (%.*f, %.*f) %s.\n"
"It is a mounting hole. Drill width = %0.*f %s.\n"
"It is owned by element %s.\n"
"%s", Pin->ID, flags_to_string (Pin->Flags, PIN_TYPE),
prec, units (Pin->X), prec, UNIT (Pin->Y),
prec, UNIT (Pin->DrillingHole),
EMPTY (element->Name[1].TextString),
TEST_FLAG (LOCKFLAG, Pin) ? "It is LOCKED.\n" : "");
else
sprintf (&report[0],
"PIN ID# %ld; Flags:%s\n" "(X,Y) = (%.*f, %.*f) %s.\n"
"Copper width = %0.*f %s. Drill width = %0.*f %s.\n"
"Clearance width to Polygon = %0.*f %s.\n"
"Annulus = %0.*f %s.\n"
"Solder mask hole = %0.*f %s (gap = %0.*f %s).\n"
"Name = \"%s\".\n"
"It is owned by element %s\n as pin number %s.\n"
"%s",
Pin->ID, flags_to_string (Pin->Flags, PIN_TYPE),
prec, units(Pin->X), prec, UNIT(Pin->Y),
prec, UNIT (Pin->Thickness),
prec, UNIT (Pin->DrillingHole),
prec, UNIT (Pin->Clearance / 2.),
prec, UNIT ((Pin->Thickness - Pin->DrillingHole)/2),
prec, UNIT (Pin->Mask),
prec, UNIT ((Pin->Mask - Pin->Thickness)/2),
EMPTY (Pin->Name),
EMPTY (element->Name[1].TextString), EMPTY (Pin->Number),
TEST_FLAG (LOCKFLAG, Pin) ? "It is LOCKED.\n" : "");
break;
}
case LINE_TYPE:
{
LineTypePtr line;
#ifndef NDEBUG
if (gui->shift_is_pressed ())
{
LayerTypePtr layer = (LayerTypePtr) ptr1;
__r_dump_tree (layer->line_tree->root, 0);
return 0;
}
#endif
line = (LineTypePtr) ptr2;
sprintf (&report[0], "LINE ID# %ld; Flags:%s\n"
"FirstPoint(X,Y) = (%.*f, %.*f) %s, ID = %ld.\n"
"SecondPoint(X,Y) = (%.*f, %.*f) %s, ID = %ld.\n"
"Width = %0.*f %s.\nClearance width in polygons = %0.*f %s.\n"
"It is on layer %d\n"
"and has name \"%s\".\n"
"%s",
line->ID, flags_to_string (line->Flags, LINE_TYPE),
prec, units (line->Point1.X), prec, UNIT (line->Point1.Y),
line->Point1.ID, prec, units (line->Point2.X), prec, UNIT (line->Point2.Y),
line->Point2.ID, prec, UNIT (line->Thickness),
prec, UNIT (line->Clearance / 2.), GetLayerNumber (PCB->Data,
(LayerTypePtr) ptr1),
UNKNOWN (line->Number), TEST_FLAG (LOCKFLAG,
line) ? "It is LOCKED.\n" :
"");
break;
}
case RATLINE_TYPE:
{
RatTypePtr line;
#ifndef NDEBUG
if (gui->shift_is_pressed ())
{
__r_dump_tree (PCB->Data->rat_tree->root, 0);
return 0;
}
#endif
line = (RatTypePtr) ptr2;
sprintf (&report[0], "RAT-LINE ID# %ld; Flags:%s\n"
"FirstPoint(X,Y) = (%.*f, %.*f) %s; ID = %ld; "
"connects to layer group %d.\n"
"SecondPoint(X,Y) = (%.*f, %.*f) %s; ID = %ld; "
"connects to layer group %d.\n",
line->ID, flags_to_string (line->Flags, LINE_TYPE),
prec, units (line->Point1.X), prec, UNIT (line->Point1.Y),
line->Point1.ID, line->group1,
prec, units (line->Point2.X), prec, UNIT (line->Point2.Y),
line->Point2.ID, line->group2);
break;
}
case ARC_TYPE:
{
ArcTypePtr Arc;
BoxTypePtr box;
#ifndef NDEBUG
if (gui->shift_is_pressed ())
{
LayerTypePtr layer = (LayerTypePtr) ptr1;
__r_dump_tree (layer->arc_tree->root, 0);
return 0;
}
#endif
Arc = (ArcTypePtr) ptr2;
box = GetArcEnds (Arc);
sprintf (&report[0], "ARC ID# %ld; Flags:%s\n"
"CenterPoint(X,Y) = (%.*f, %.*f) %s.\n"
"Radius = %0.*f %s, Thickness = %0.*f %s.\n"
"Clearance width in polygons = %0.*f %s.\n"
"StartAngle = %ld degrees, DeltaAngle = %ld degrees.\n"
"Bounding Box is (%.*f,%.*f), (%.*f,%.*f) %s.\n"
"That makes the end points at (%.*f,%.*f) %s and (%.*f,%.*f) %s.\n"
"It is on layer %d.\n"
"%s", Arc->ID, flags_to_string (Arc->Flags, ARC_TYPE),
prec, units(Arc->X), prec, UNIT(Arc->Y),
prec, UNIT (Arc->Width), prec, UNIT (Arc->Thickness),
prec, UNIT (Arc->Clearance / 2.), Arc->StartAngle, Arc->Delta,
prec, units (Arc->BoundingBox.X1),
prec, units (Arc->BoundingBox.Y1),
prec, units (Arc->BoundingBox.X2),
prec, UNIT (Arc->BoundingBox.Y2),
prec, units (box->X1), prec, UNIT (box->Y1),
prec, units (box->X2), prec, UNIT (box->Y2),
GetLayerNumber (PCB->Data, (LayerTypePtr) ptr1),
TEST_FLAG (LOCKFLAG, Arc) ? "It is LOCKED.\n" : "");
break;
}
case POLYGON_TYPE:
{
PolygonTypePtr Polygon;
#ifndef NDEBUG
if (gui->shift_is_pressed ())
{
LayerTypePtr layer = (LayerTypePtr) ptr1;
__r_dump_tree (layer->polygon_tree->root, 0);
return 0;
}
#endif
Polygon = (PolygonTypePtr) ptr2;
sprintf (&report[0], "POLYGON ID# %ld; Flags:%s\n"
"Its bounding box is (%.*f,%.*f) (%.*f,%.*f) %s.\n"
"It has %d points and could store %d more\n"
" without using more memory.\n"
"It has %d holes and resides on layer %d.\n"
"%s", Polygon->ID,
flags_to_string (Polygon->Flags, POLYGON_TYPE),
prec, units(Polygon->BoundingBox.X1),
prec, units(Polygon->BoundingBox.Y1),
prec, units(Polygon->BoundingBox.X2),
prec, UNIT(Polygon->BoundingBox.Y2),
Polygon->PointN, Polygon->PointMax - Polygon->PointN,
Polygon->HoleIndexN,
GetLayerNumber (PCB->Data, (LayerTypePtr) ptr1),
TEST_FLAG (LOCKFLAG, Polygon) ? "It is LOCKED.\n" : "");
break;
}
case PAD_TYPE:
{
int len, dx, dy, mgap;
PadTypePtr Pad;
ElementTypePtr element;
#ifndef NDEBUG
if (gui->shift_is_pressed ())
{
__r_dump_tree (PCB->Data->pad_tree->root, 0);
return 0;
}
#endif
Pad = (PadTypePtr) ptr2;
element = (ElementTypePtr) ptr1;
PAD_LOOP (element);
{
{
if (pad == Pad)
break;
}
}
END_LOOP;
dx = Pad->Point1.X - Pad->Point2.X;
dy = Pad->Point1.Y - Pad->Point2.Y;
len = sqrt (dx*dx+dy*dy);
mgap = (Pad->Mask - Pad->Thickness)/2;
sprintf (&report[0], "PAD ID# %ld; Flags:%s\n"
"FirstPoint(X,Y) = (%.*f, %.*f) %s; ID = %ld.\n"
"SecondPoint(X,Y) = (%.*f, %.*f) %s; ID = %ld.\n"
"Width = %0.*f %s. Length = %0.*f %s.\n"
"Clearance width in polygons = %0.*f %s.\n"
"Solder mask = %0.*f x %0.*f %s (gap = %0.*f %s).\n"
"Name = \"%s\".\n"
"It is owned by SMD element %s\n"
" as pin number %s and is on the %s\n"
"side of the board.\n"
"%s", Pad->ID,
flags_to_string (Pad->Flags, PAD_TYPE),
prec, units (Pad->Point1.X),
prec, UNIT (Pad->Point1.Y), Pad->Point1.ID,
prec, units (Pad->Point2.X),
prec, UNIT (Pad->Point2.Y), Pad->Point2.ID,
prec, UNIT (Pad->Thickness),
prec, UNIT (len + Pad->Thickness),
prec, UNIT (Pad->Clearance / 2.),
prec, units (Pad->Mask), prec, UNIT (Pad->Mask + len),
prec, UNIT (mgap),
EMPTY (Pad->Name),
EMPTY (element->Name[1].TextString),
EMPTY (Pad->Number),
TEST_FLAG (ONSOLDERFLAG,
Pad) ? "solder (bottom)" : "component",
TEST_FLAG (LOCKFLAG, Pad) ? "It is LOCKED.\n" : "");
break;
}
case ELEMENT_TYPE:
{
ElementTypePtr element;
#ifndef NDEBUG
if (gui->shift_is_pressed ())
{
__r_dump_tree (PCB->Data->element_tree->root, 0);
return 0;
}
#endif
element = (ElementTypePtr) ptr2;
sprintf (&report[0], "ELEMENT ID# %ld; Flags:%s\n"
"BoundingBox (%.*f,%.*f) (%.*f,%.*f) %s.\n"
"Descriptive Name \"%s\".\n"
"Name on board \"%s\".\n"
"Part number name \"%s\".\n"
"It is %.*f %s tall and is located at (X,Y) = (%.*f,%.*f)%s.\n"
"Mark located at point (X,Y) = (%.*f,%.*f).\n"
"It is on the %s side of the board.\n"
"%s",
element->ID, flags_to_string (element->Flags, ELEMENT_TYPE),
prec, units(element->BoundingBox.X1),
prec, units (element->BoundingBox.Y1),
prec, units(element->BoundingBox.X2),
prec, UNIT (element->BoundingBox.Y2),
EMPTY (element->Name[0].TextString),
EMPTY (element->Name[1].TextString),
EMPTY (element->Name[2].TextString),
prec, UNIT (0.45 * element->Name[1].Scale * 100.),
prec, units(element->Name[1].X),
prec, units(element->Name[1].Y),
TEST_FLAG (HIDENAMEFLAG, element) ?
",\n but it's hidden" : "", prec, units(element->MarkX),
prec, units(element->MarkY),
TEST_FLAG (ONSOLDERFLAG, element) ? "solder (bottom)" :
"component", TEST_FLAG (LOCKFLAG, element) ?
"It is LOCKED.\n" : "");
break;
}
case TEXT_TYPE:
#ifndef NDEBUG
if (gui->shift_is_pressed ())
{
LayerTypePtr layer = (LayerTypePtr) ptr1;
__r_dump_tree (layer->text_tree->root, 0);
return 0;
}
#endif
case ELEMENTNAME_TYPE:
{
char laynum[32];
TextTypePtr text;
#ifndef NDEBUG
if (gui->shift_is_pressed ())
{
__r_dump_tree (PCB->Data->name_tree[NAME_INDEX (PCB)]->root, 0);
return 0;
}
#endif
text = (TextTypePtr) ptr2;
if (type == TEXT_TYPE)
sprintf (laynum, "It is on layer %d.",
GetLayerNumber (PCB->Data, (LayerTypePtr) ptr1));
sprintf (&report[0], "TEXT ID# %ld; Flags:%s\n"
"Located at (X,Y) = (%.*f,%.*f) %s.\n"
"Characters are %0.*f %s tall.\n"
"Value is \"%s\".\n"
"Direction is %d.\n"
"The bounding box is (%.*f,%.*f) (%.*f, %.*f) %s.\n"
"%s\n"
"%s", text->ID, flags_to_string (text->Flags, TEXT_TYPE),
prec, units(text->X), prec, UNIT (text->Y),
prec, UNIT (0.45 * text->Scale * 100.),
text->TextString, text->Direction,
prec, units(text->BoundingBox.X1),
prec, units(text->BoundingBox.Y1),
prec, units(text->BoundingBox.X2),
prec, UNIT (text->BoundingBox.Y2),
(type == TEXT_TYPE) ? laynum : "It is an element name.",
TEST_FLAG (LOCKFLAG, text) ? "It is LOCKED.\n" : "");
break;
}
case LINEPOINT_TYPE:
case POLYGONPOINT_TYPE:
{
PointTypePtr point = (PointTypePtr) ptr2;
sprintf (&report[0], "POINT ID# %ld.\n"
"Located at (X,Y) = (%.*f,%.*f) %s.\n"
"It belongs to a %s on layer %d.\n", point->ID,
prec, units (point->X), prec, UNIT (point->Y),
(type == LINEPOINT_TYPE) ? "line" : "polygon",
GetLayerNumber (PCB->Data, (LayerTypePtr) ptr1));
break;
}
case NO_TYPE:
report[0] = '\0';
break;
default:
sprintf (&report[0], "Unknown\n");
break;
}
if (report[0] == '\0')
{
Message (_("Nothing found to report on\n"));
return 1;
}
HideCrosshair (false);
/* create dialog box */
gui->report_dialog ("Report", &report[0]);
RestoreCrosshair (false);
return 0;
}
gint
ghid_port_window_leave_cb (GtkWidget * widget,
GdkEventCrossing * ev, GHidPort * out)
{
gint x0, y0, x, y, dx, dy, w, h;
/* printf("leave mode: %d detail: %d\n", ev->mode, ev->detail); */
/* Window leave events can also be triggered because of focus grabs. Some
* X applications occasionally grab the focus and so trigger this function.
* At least GNOME's window manager is known to do this on every mouse click.
*
* See http://bugzilla.gnome.org/show_bug.cgi?id=102209
*/
if(ev->mode != GDK_CROSSING_NORMAL)
{
return FALSE;
}
if(out->has_entered && !ghidgui->in_popup)
{
/* if actively drawing, start scrolling */
if (have_crosshair_attachments () && ghidgui->auto_pan_on)
{
/* GdkEvent coords are set to 0,0 at leave events, so must figure
| out edge the cursor left.
*/
w = ghid_port.width * gport->zoom;
h = ghid_port.height * gport->zoom;
x0 = VIEW_X (0);
y0 = VIEW_Y (0);
ghid_get_coords (NULL, &x, &y);
x -= x0;
y -= y0;
if (ghid_flip_x )
x = -x;
if (ghid_flip_y )
y = -y;
dx = w - x;
dy = h - y;
x_pan_speed = y_pan_speed = 2 * ghidgui->auto_pan_speed;
if (x < dx)
{
x_pan_speed = -x_pan_speed;
dx = x;
}
if (y < dy)
{
y_pan_speed = -y_pan_speed;
dy = y;
}
if (dx < dy)
{
if (dy < h / 3)
y_pan_speed = y_pan_speed - (3 * dy * y_pan_speed) / h;
else
y_pan_speed = 0;
}
else
{
if (dx < w / 3)
x_pan_speed = x_pan_speed - (3 * dx * x_pan_speed) / w;
else
x_pan_speed = 0;
}
g_idle_add (ghid_pan_idle_cb, NULL);
}
}
if(cursor_in_viewport)
{
HideCrosshair (TRUE);
cursor_in_viewport = FALSE;
}
ghid_show_crosshair (FALSE);
out->has_entered = FALSE;
ghid_screen_update ();
return FALSE;
}
