C++ (Cpp) pad_or_pin_center Examples

Example #1

File: utilities.c Project: bert/pcb-plugins

static bool
have_two_corresponding_aux (ElementType *old_element,
                            ElementType *new_element,
                            bool unique,
                            bool non_coincident,
                            PadOrPinType* old1_pp_ptr,
                            PadOrPinType* old2_pp_ptr,
                            PadOrPinType* new1_pp_ptr,
                            PadOrPinType* new2_pp_ptr)
{
  PadOrPinType old1_pp = make_pad_or_pin(NULL, NULL);
  PadOrPinType new1_pp = make_pad_or_pin(NULL, NULL);
  bool first_found = false;

  PAD_OR_PIN_LOOP_HYG(old_element, _old);
  {
    if (! unique
        || is_number_unique(old_element,
                            pad_or_pin_number(&pp_old))) {
      CheapPointType old_pt = pad_or_pin_center(&pp_old);
      PAD_OR_PIN_LOOP_HYG(new_element, _new);
      {
        if (pad_or_pin_number_cmp(&pp_old, &pp_new) == 0
            && (! unique
                || is_number_unique(new_element,
                                    pad_or_pin_number(&pp_new)))) {
          CheapPointType new_pt = pad_or_pin_center(&pp_new);
          if (! non_coincident || point_distance2(old_pt, new_pt)) {
            if (! first_found) {
              old1_pp = pp_old;
              new1_pp = pp_new;
              first_found = true;
            } else {
              if (old1_pp_ptr) {
                *old1_pp_ptr = old1_pp;
              }
              if (new1_pp_ptr) {
                *new1_pp_ptr = new1_pp;
              }
              if (old2_pp_ptr) {
                *old2_pp_ptr = pp_old;
              }
              if (new2_pp_ptr) {
                *new2_pp_ptr = pp_new;
              }
              return true;
            }
          }
        }
      }
      END_LOOP;
    }
  }
  END_LOOP;
  return false;
}

Example #2

File: footprintupdate.c Project: Mehanik/pcb-plugins

static void
replace_one_footprint_aux(ElementTypePtr old_element,
                          PadOrPinType* old1_pp, PadOrPinType* old2_pp,
                          ElementTypePtr copy_element,
                          PadOrPinType* copy1_pp, PadOrPinType* copy2_pp)
{
  Boolean two_points = (old2_pp && copy2_pp);
  Boolean reflect = IS_REFLECTED(copy_element, old_element);

  debug_log("Reflect?: %s\n", (reflect ? "yes" : "no"));
  if (reflect) {
    /* Change side of board */
    ChangeElementSide(copy_element, 0);
  }

  CheapPointType copy1_pt = pad_or_pin_center(copy1_pp);
  CheapPointType old1_pt = pad_or_pin_center(old1_pp);

  BYTE rot_steps = 0;
  if (two_points) {
    /* Calculate nearest rotation steps */
    CheapPointType copy2_pt = pad_or_pin_center(copy2_pp);
    CheapPointType old2_pt = pad_or_pin_center(old2_pp);
    rot_steps =
      calculate_rotation_steps(copy1_pt, copy2_pt, old1_pt, old2_pt);
  }
  if (rot_steps) {
    /* Rotate copy */
    RotateElementLowLevel(PCB->Data, copy_element, 0, 0, rot_steps);
    /* Recalculate since copy_element has changed. */
    copy1_pt = pad_or_pin_center(copy1_pp);
  }

  /* Calculate translation */
  LocationType dx = old1_pt.X - copy1_pt.X;
  LocationType dy = old1_pt.Y - copy1_pt.Y;
  /* Move element */
  MoveElementLowLevel(PCB->Data, copy_element, dx, dy);

  /* Transfer pad/pin text and names. */
  transfer_text(old_element, copy_element);
  transfer_names(old_element, copy_element);
  transfer_flags(old_element, copy_element);
  SetElementBoundingBox(PCB->Data, copy_element, &PCB->Font);

  AddObjectToCreateUndoList(ELEMENT_TYPE,
                            copy_element, copy_element, copy_element);
  /* Remove old element. */
  MoveObjectToRemoveUndoList(ELEMENT_TYPE,
                             old_element, old_element, old_element);
}

Example #3

File: pad-pin-data.c Project: Mehanik/pcb-plugins

ElementPadPinData*
alloc_pad_pin_data_array(ElementTypePtr element, int* len_ptr)
{
  int len = element->PadN + element->PinN;
  ElementPadPinData* ppd = MyCalloc(len, sizeof(ElementPadPinData),
                                    "alloc_pad_pin_data_array");

  /* Set the pad/pin pointers and centers */
  int i = 0;
  PAD_OR_PIN_LOOP(element);
  {
    ppd[i].pp = pp;
    ppd[i].center
      = ppd[i].transformed_center
      = pad_or_pin_center(&pp);
    i++;
  }
  END_LOOP;

  /* Sort by pad/pin number */
  qsort(ppd, len, sizeof(ElementPadPinData), pad_pin_data_cmp_by_number);

  /* Set the shared field */
  int i_start = 0;
  const PadOrPinType* pp_start = &ppd[0].pp;
  /* Index i goes all the way to len; watch out. */
  for (i = 1; i < len + 1; i++) {
    if (i == len || pad_or_pin_number_cmp(pp_start, &ppd[i].pp) != 0) {
      int shares = i - i_start;
      int j;
      for (j = i_start; j < i; j++) {
        ppd[j].shares = shares;
      }
      /* Prepare for next block */
      if (i != len) {
        i_start = i;
        pp_start = &ppd[i].pp;
      }
    }
  }
  *len_ptr = len;
  return ppd;
}