set.c

Go to the documentation of this file.

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#ifdef HAVE_STRING_H
#include <string.h>
#endif

#include "global.h"

#include "action.h"
#include "buffer.h"
#include "compat.h"
#include "crosshair.h"
#include "data.h"
#include "draw.h"
#include "error.h"
#include "find.h"
#include "misc.h"
#include "move.h"
#include "set.h"
#include "undo.h"
#include "pcb-printf.h"

#ifdef HAVE_LIBDMALLOC
#include <dmalloc.h>
#endif

static int mode_position = 0;
static int mode_stack[MAX_MODESTACK_DEPTH];

void
SetGrid (Coord Grid, bool align)
{
  char *grid_string;
  if (Grid >= 1 && Grid <= MAX_GRID)
    {
      if (align)
        {
          PCB->GridOffsetX = Crosshair.X % Grid;
          PCB->GridOffsetY = Crosshair.Y % Grid;
        }
      PCB->Grid = Grid;
      grid_string = pcb_g_strdup_printf ("%mr", Grid);
      if (grid_string)
        AttributePut (PCB, "PCB::grid::size", grid_string);
      g_free (grid_string);
      if (Settings.DrawGrid)
        Redraw ();
    }
}

void
SetLineSize (Coord Size)
{
  if (Size >= MIN_LINESIZE && Size <= MAX_LINESIZE)
    {
      Settings.LineThickness = Size;
      if (TEST_FLAG (AUTODRCFLAG, PCB))
        FitCrosshairIntoGrid (Crosshair.X, Crosshair.Y);
    }
}

void
SetViaSize (Coord Size, bool Force)
{
  if (Force || (Size <= MAX_PINORVIASIZE &&
                Size >= MIN_PINORVIASIZE &&
                Size >= Settings.ViaDrillingHole + MIN_PINORVIACOPPER))
    {
      Settings.ViaThickness = Size;
    }
}

void
SetViaDrillingHole (Coord Size, bool Force)
{
  if (Force || (Size <= MAX_PINORVIASIZE &&
                Size >= MIN_PINORVIAHOLE &&
                Size <= Settings.ViaThickness - MIN_PINORVIACOPPER))
    {
      Settings.ViaDrillingHole = Size;
    }
}

void
pcb_use_route_style (RouteStyleType * rst)
{
  Settings.LineThickness = rst->Thick;
  Settings.ViaThickness = rst->Diameter;
  Settings.ViaDrillingHole = rst->Hole;
  Settings.Keepaway = rst->Keepaway;
}

void
SetKeepawayWidth (Coord Width)
{
  if (Width <= MAX_LINESIZE)
    {
      Settings.Keepaway = Width;
    }
}

void
SetTextScale (int Scale)
{
  if (Scale <= MAX_TEXTSCALE && Scale >= MIN_TEXTSCALE)
    {
      Settings.TextScale = Scale;
    }
}

void
SetChangedFlag (bool New)
{
  if (PCB->Changed != New)
    {
      PCB->Changed = New;

    }
}

void
SetBufferNumber (int Number)
{
  if (Number >= 0 && Number < MAX_BUFFER)
    {
      Settings.BufferNumber = Number;

      /* do an update on the crosshair range */
      crosshair_update_range();
    }
}

void
SaveMode (void)
{
  mode_stack[mode_position] = Settings.Mode;
  if (mode_position < MAX_MODESTACK_DEPTH - 1)
    mode_position++;
}

void
RestoreMode (void)
{
  if (mode_position == 0)
    {
      Message ("hace: underflow of restore mode\n");
      return;
    }
  SetMode (mode_stack[--mode_position]);
}


void
SetMode (int Mode)
{
  static bool recursing = false;
  if (recursing)
    return;
  recursing = true;
  notify_crosshair_change (false);
  addedLines = 0;
  Crosshair.AttachedObject.Type = NO_TYPE;
  Crosshair.AttachedObject.State = STATE_FIRST;
  Crosshair.AttachedPolygon.PointN = 0;
  if (PCB->RatDraw)
    {
      if (Mode == ARC_MODE || Mode == RECTANGLE_MODE ||
          Mode == VIA_MODE || Mode == POLYGON_MODE ||
          Mode == POLYGONHOLE_MODE ||
          Mode == TEXT_MODE || Mode == INSERTPOINT_MODE ||
          Mode == THERMAL_MODE)
        {
          Message (_("That mode is NOT allowed when drawing ratlines!\n"));
          Mode = NO_MODE;
        }
    }
  if (Settings.Mode == LINE_MODE && Mode == ARC_MODE &&
      Crosshair.AttachedLine.State != STATE_FIRST)
    {
      Crosshair.AttachedLine.State = STATE_FIRST;
      Crosshair.AttachedBox.State = STATE_SECOND;
      Crosshair.AttachedBox.Point1.X = Crosshair.AttachedBox.Point2.X =
        Crosshair.AttachedLine.Point1.X;
      Crosshair.AttachedBox.Point1.Y = Crosshair.AttachedBox.Point2.Y =
        Crosshair.AttachedLine.Point1.Y;
      AdjustAttachedObjects ();
    }
  else if (Settings.Mode == ARC_MODE && Mode == LINE_MODE &&
           Crosshair.AttachedBox.State != STATE_FIRST)
    {
      Crosshair.AttachedBox.State = STATE_FIRST;
      Crosshair.AttachedLine.State = STATE_SECOND;
      Crosshair.AttachedLine.Point1.X = Crosshair.AttachedLine.Point2.X =
        Crosshair.AttachedBox.Point1.X;
      Crosshair.AttachedLine.Point1.Y = Crosshair.AttachedLine.Point2.Y =
        Crosshair.AttachedBox.Point1.Y;
      Settings.Mode = Mode;
      AdjustAttachedObjects ();
    }
  /* Cancel rubberband move */
  else if (Settings.Mode == MOVE_MODE)
    MoveObjectAndRubberband (Crosshair.AttachedObject.Type,
                             Crosshair.AttachedObject.Ptr1,
                             Crosshair.AttachedObject.Ptr2,
                             Crosshair.AttachedObject.Ptr3,
                             0, 0);
  else
    {
      if (Settings.Mode == ARC_MODE || Settings.Mode == LINE_MODE)
        SetLocalRef (0, 0, false);
      Crosshair.AttachedBox.State = STATE_FIRST;
      Crosshair.AttachedLine.State = STATE_FIRST;
      if (Mode == LINE_MODE && TEST_FLAG (AUTODRCFLAG, PCB))
        {
          if (ClearFlagOnAllObjects (true, CONNECTEDFLAG | FOUNDFLAG))
            {
              IncrementUndoSerialNumber ();
              Draw ();
            }
        }
    }

  Settings.Mode = Mode;
  crosshair_update_range();

  recursing = false;

  notify_crosshair_change (true);
}

void
SetRouteStyle (char *name)
{
  char num[10];

  STYLE_LOOP (PCB);
  {
    if (name && NSTRCMP (name, style->Name) == 0)
      {
        sprintf (num, "%d", n + 1);
        hid_actionl ("RouteStyle", num, NULL);
        break;
      }
  }
  END_LOOP;
}

void
SetLocalRef (Coord X, Coord Y, bool Showing)
{
  static MarkType old;
  static int count = 0;

  if (Showing)
    {
      notify_mark_change (false);
      if (count == 0)
        old = Marked;
      Marked.X = X;
      Marked.Y = Y;
      Marked.status = true;
      count++;
      notify_mark_change (true);
    }
  else if (count > 0)
    {
      notify_mark_change (false);
      count = 0;
      Marked = old;
      notify_mark_change (true);
    }
}