void map_client(client_t *c) { XWindowAttributes attr; strut_t s = { 0, 0, 0, 0 }; XWMHints *hints; int btn, want_raise = 1; XGrabServer(dpy); XGetWindowAttributes(dpy, c->win, &attr); collect_struts(c, &s); if (attr.map_state == IsViewable) { c->ignore_unmap++; reparent(c, &s); if (get_wm_state(c->win) == IconicState) { c->ignore_unmap++; XUnmapWindow(dpy, c->win); } else { set_wm_state(c, NormalState); do_map(c, want_raise); } } else { if ((hints = XGetWMHints(dpy, c->win))) { if (hints->flags & StateHint) set_wm_state(c, hints->initial_state); XFree(hints); } else { set_wm_state(c, NormalState); } if (!init_geom(c, &s) && opt_imap) { btn = sweep(c, map_curs, recalc_map, SWEEP_DOWN, &s); if (btn == Button2) btn = sweep(c, resize_curs, recalc_resize, SWEEP_UP, &s); if (btn == Button3) want_raise = 0; } #ifdef DEBUG dump_geom(c, "set to"); dump_info(c); #endif reparent(c, &s); if (get_wm_state(c->win) == NormalState) do_map(c, want_raise); } XSync(dpy, False); c->name = get_wm_name(c->win); // horrible kludge XUngrabServer(dpy); }
void do_done(CHAR_DATA * ch, char * thedir) { CHAR_DATA *rch; if(!ch->infight) { printf_to_char(ch,"You're not in a fight."); return; } if(!TURN(ch)) { printf_to_char(ch,"It's not your turn."); return; } check_winner(ch->in_room); for (rch = ch->in_room->people; rch != NULL; rch = rch->next_in_room) { printf_to_char(rch,"%s ends %s turn.\n",fcn(ch), ch->sex ? "his" : "her"); do_map(rch,"forced"); rch->AT++; } ch->AT = 0; advance_turn(ch); }
/** * vm_map - map another task's memory to current task. * * Note: This routine does not support mapping to the specific * address. */ int vm_map(task_t target, void *addr, size_t size, void **alloc) { int err; sched_lock(); if (!task_valid(target)) { err = ESRCH; goto out; } if (target == cur_task()) { err = EINVAL; goto out; } if (!task_capable(CAP_MEMORY)) { err = EPERM; goto out; } if (!user_area(addr)) { err = EFAULT; goto out; } err = do_map(target->map, addr, size, alloc); out: sched_unlock(); return err; }
/// Stop using 'keymap'. static void keymap_unload(void) { char_u buf[KMAP_MAXLEN + 10]; char_u *save_cpo = p_cpo; kmap_T *kp; if (!(curbuf->b_kmap_state & KEYMAP_LOADED)) { return; } // Set 'cpoptions' to "C" to avoid line continuation. p_cpo = (char_u *)"C"; // clear the ":lmap"s kp = (kmap_T *)curbuf->b_kmap_ga.ga_data; for (int i = 0; i < curbuf->b_kmap_ga.ga_len; ++i) { vim_snprintf((char *)buf, sizeof(buf), "<buffer> %s", kp[i].from); (void)do_map(1, buf, LANGMAP, FALSE); xfree(kp[i].from); xfree(kp[i].to); } p_cpo = save_cpo; ga_clear(&curbuf->b_kmap_ga); curbuf->b_kmap_state &= ~KEYMAP_LOADED; status_redraw_curbuf(); }
mmap_t* CMMap::map_both(const char* filename, size_t size_max) { int fd = open(filename, O_RDONLY|O_WRONLY); if (-1 == fd) throw CSyscallException(errno, __FILE__, __LINE__); return do_map(PROT_READ|PROT_WRITE, fd, 0, 0, size_max, false); }
void advance_turn(CHAR_DATA * ch) { CHAR_DATA *rch; int q=0; for (rch = ch->in_room->people; rch != NULL; rch = rch->next_in_room) { if(rch->infight) q++; } if(q<1); return; check_winner(ch->in_room); q = 0; for (rch = ch->in_room->people; rch != NULL; rch = rch->next_in_room) { if(rch == NULL || !rch->infight) continue; do_map(rch,"forced"); } ch->in_room->next = NULL; while(ch->in_room->next == NULL) { for (rch = ch->in_room->people; rch != NULL; rch = rch->next_in_room) { if(rch == NULL || !rch->infight) continue; if(rch->ATToCast < rch->AT) { say_spell (rch, rch->SnToCast); tile_spell(rch, rch->SnToCast); rch->ATToCast = 0; rch->SnToCast = 0; rch->casting = FALSE; rch->CastTargY = 0; rch->CastTargX = 0; } rch->AT += rch->speed; if(rch->AT >= 100) { rch->AT = 100; ch->in_room->turn = rch; break; } } } ch->in_room->turn->MoveLeft = ch->in_room->turn->base_move; ch->in_room->turn->AttackLeft = 1; printf_to_char(rch,"%s's turn.\n",fcn(ch->in_room->turn)); }
SYS_NAMESPACE_BEGIN mmap_t* CMMap::map_read(const char* filename, size_t size_max) { int fd = open(filename, O_RDONLY); if (-1 == fd) throw CSyscallException(errno, __FILE__, __LINE__); return do_map(PROT_READ, fd, 0, 0, size_max, false); }
void map_and_write (int fd, int map, char c) { char b[M_MAXMAP]; int n; n = do_map(b, map, c); if ( n ) if ( writen_ni(fd, b, n) < n ) fatal("write to stdout failed: %s", strerror(errno)); }
static errval_t refill_slabs(struct pmap_arm *pmap, size_t request) { errval_t err; /* Keep looping till we have #request slabs */ while (slab_freecount(&pmap->slab) < request) { // Amount of bytes required for #request size_t bytes = SLAB_STATIC_SIZE(request - slab_freecount(&pmap->slab), sizeof(struct vnode)); /* Get a frame of that size */ struct capref cap; err = frame_alloc(&cap, bytes, &bytes); if (err_is_fail(err)) { return err_push(err, LIB_ERR_FRAME_ALLOC); } /* If we do not have enough slabs to map the frame in, recurse */ size_t required_slabs_for_frame = max_slabs_required(bytes); if (slab_freecount(&pmap->slab) < required_slabs_for_frame) { // If we recurse, we require more slabs than to map a single page assert(required_slabs_for_frame > 4); err = refill_slabs(pmap, required_slabs_for_frame); if (err_is_fail(err)) { return err_push(err, LIB_ERR_SLAB_REFILL); } } /* Perform mapping */ genvaddr_t genvaddr = pmap->vregion_offset; pmap->vregion_offset += (genvaddr_t)bytes; // if this assert fires, increase META_DATA_RESERVED_SPACE assert(pmap->vregion_offset < (vregion_get_base_addr(&pmap->vregion) + vregion_get_size(&pmap->vregion))); err = do_map(pmap, genvaddr, cap, 0, bytes, VREGION_FLAGS_READ_WRITE, NULL, NULL); if (err_is_fail(err)) { return err_push(err, LIB_ERR_PMAP_DO_MAP); } /* Grow the slab */ lvaddr_t buf = vspace_genvaddr_to_lvaddr(genvaddr); slab_grow(&pmap->slab, (void*)buf, bytes); } return SYS_ERR_OK; }
void WidgetWindow::xt_realize(XtValueMask* mask, XSetWindowAttributes* attr) { WindowRep& wr = *((Window*)this)->rep(); wr.xattrs_ = *attr; wr.xattrmask_ = *mask; bind(); set_props(); do_map(); // ### why keep this? XtAddEventHandler( (Widget)widget_, StructureNotifyMask, FALSE, &WidgetWindow::xt_structure_event, this ); }
/** * \brief Create page mappings * * \param pmap The pmap object * \param vaddr The virtual address to create the mapping for * \param frame The frame cap to map in * \param offset Offset into the frame cap * \param size Size of the mapping * \param flags Flags for the mapping * \param retoff If non-NULL, filled in with adjusted offset of mapped region * \param retsize If non-NULL, filled in with adjusted size of mapped region */ static errval_t map(struct pmap *pmap, genvaddr_t vaddr, struct capref frame, size_t offset, size_t size, vregion_flags_t flags, size_t *retoff, size_t *retsize) { struct pmap_arm *pmap_arm = (struct pmap_arm *)pmap; size += BASE_PAGE_OFFSET(offset); size = ROUND_UP(size, BASE_PAGE_SIZE); offset -= BASE_PAGE_OFFSET(offset); const size_t slabs_reserve = 3; // == max_slabs_required(1) uint64_t slabs_free = slab_freecount(&pmap_arm->slab); size_t slabs_required = max_slabs_required(size) + slabs_reserve; if (slabs_required > slabs_free) { if (get_current_pmap() == pmap) { errval_t err = refill_slabs(pmap_arm, slabs_required); if (err_is_fail(err)) { return err_push(err, LIB_ERR_SLAB_REFILL); } } else { size_t bytes = SLAB_STATIC_SIZE(slabs_required - slabs_free, sizeof(struct vnode)); void *buf = malloc(bytes); if (!buf) { return LIB_ERR_MALLOC_FAIL; } slab_grow(&pmap_arm->slab, buf, bytes); } } return do_map(pmap_arm, vaddr, frame, offset, size, flags, retoff, retsize); }
/// ":loadkeymap" command: load the following lines as the keymap. /// /// @param eap void ex_loadkeymap(exarg_T *eap) { char_u *line; char_u *p; char_u *s; #define KMAP_LLEN 200 // max length of "to" and "from" together char_u buf[KMAP_LLEN + 11]; char_u *save_cpo = p_cpo; if (!getline_equal(eap->getline, eap->cookie, getsourceline)) { EMSG(_("E105: Using :loadkeymap not in a sourced file")); return; } // Stop any active keymap and clear the table. keymap_unload(); curbuf->b_kmap_state = 0; ga_init(&curbuf->b_kmap_ga, (int)sizeof(kmap_T), 20); // Set 'cpoptions' to "C" to avoid line continuation. p_cpo = (char_u *)"C"; // Get each line of the sourced file, break at the end. for (;;) { line = eap->getline(0, eap->cookie, 0); if (line == NULL) { break; } p = skipwhite(line); if ((*p != '"') && (*p != NUL)) { kmap_T *kp = GA_APPEND_VIA_PTR(kmap_T, &curbuf->b_kmap_ga); s = skiptowhite(p); kp->from = vim_strnsave(p, (size_t)(s - p)); p = skipwhite(s); s = skiptowhite(p); kp->to = vim_strnsave(p, (size_t)(s - p)); if ((STRLEN(kp->from) + STRLEN(kp->to) >= KMAP_LLEN) || (*kp->from == NUL) || (*kp->to == NUL)) { if (*kp->to == NUL) { EMSG(_("E791: Empty keymap entry")); } xfree(kp->from); xfree(kp->to); --curbuf->b_kmap_ga.ga_len; } } xfree(line); } // setup ":lnoremap" to map the keys for (int i = 0; i < curbuf->b_kmap_ga.ga_len; ++i) { vim_snprintf((char *)buf, sizeof(buf), "<buffer> %s %s", ((kmap_T *)curbuf->b_kmap_ga.ga_data)[i].from, ((kmap_T *)curbuf->b_kmap_ga.ga_data)[i].to); (void)do_map(2, buf, LANGMAP, FALSE); } p_cpo = save_cpo; curbuf->b_kmap_state |= KEYMAP_LOADED; status_redraw_curbuf(); }
static DerivedMesh *applyModifier(ModifierData *md, Object *ob, DerivedMesh *derivedData, ModifierApplyFlag UNUSED(flag)) { WeightVGProximityModifierData *wmd = (WeightVGProximityModifierData *) md; DerivedMesh *dm = derivedData; MDeformVert *dvert = NULL; MDeformWeight **dw, **tdw; int numVerts; float (*v_cos)[3] = NULL; /* The vertices coordinates. */ Object *obr = NULL; /* Our target object. */ int defgrp_idx; float *tw = NULL; float *org_w = NULL; float *new_w = NULL; int *tidx, *indices = NULL; int numIdx = 0; int i; /* Flags. */ #if 0 int do_prev = (wmd->modifier.mode & eModifierMode_DoWeightPreview); #endif #if DO_PROFILE TIMEIT_START(perf) #endif /* Get number of verts. */ numVerts = dm->getNumVerts(dm); /* Check if we can just return the original mesh. * Must have verts and therefore verts assigned to vgroups to do anything useful! */ if ((numVerts == 0) || (ob->defbase.first == NULL)) return dm; /* Get our target object. */ obr = wmd->proximity_ob_target; if (obr == NULL) return dm; /* Get vgroup idx from its name. */ defgrp_idx = defgroup_name_index(ob, wmd->defgrp_name); if (defgrp_idx < 0) return dm; dvert = CustomData_duplicate_referenced_layer(&dm->vertData, CD_MDEFORMVERT, numVerts); /* If no vertices were ever added to an object's vgroup, dvert might be NULL. * As this modifier never add vertices to vgroup, just return. */ if (!dvert) return dm; /* Find out which vertices to work on (all vertices in vgroup), and get their relevant weight. */ tidx = MEM_mallocN(sizeof(int) * numVerts, "WeightVGProximity Modifier, tidx"); tw = MEM_mallocN(sizeof(float) * numVerts, "WeightVGProximity Modifier, tw"); tdw = MEM_mallocN(sizeof(MDeformWeight *) * numVerts, "WeightVGProximity Modifier, tdw"); for (i = 0; i < numVerts; i++) { MDeformWeight *_dw = defvert_find_index(&dvert[i], defgrp_idx); if (_dw) { tidx[numIdx] = i; tw[numIdx] = _dw->weight; tdw[numIdx++] = _dw; } } /* If no vertices found, return org data! */ if (numIdx == 0) { MEM_freeN(tidx); MEM_freeN(tw); MEM_freeN(tdw); return dm; } if (numIdx != numVerts) { indices = MEM_mallocN(sizeof(int) * numIdx, "WeightVGProximity Modifier, indices"); memcpy(indices, tidx, sizeof(int) * numIdx); org_w = MEM_mallocN(sizeof(float) * numIdx, "WeightVGProximity Modifier, org_w"); memcpy(org_w, tw, sizeof(float) * numIdx); dw = MEM_mallocN(sizeof(MDeformWeight *) * numIdx, "WeightVGProximity Modifier, dw"); memcpy(dw, tdw, sizeof(MDeformWeight *) * numIdx); MEM_freeN(tw); MEM_freeN(tdw); } else { org_w = tw; dw = tdw; } new_w = MEM_mallocN(sizeof(float) * numIdx, "WeightVGProximity Modifier, new_w"); MEM_freeN(tidx); /* Get our vertex coordinates. */ v_cos = MEM_mallocN(sizeof(float[3]) * numIdx, "WeightVGProximity Modifier, v_cos"); if (numIdx != numVerts) { /* XXX In some situations, this code can be up to about 50 times more performant * than simply using getVertCo for each affected vertex... */ float (*tv_cos)[3] = MEM_mallocN(sizeof(float[3]) * numVerts, "WeightVGProximity Modifier, tv_cos"); dm->getVertCos(dm, tv_cos); for (i = 0; i < numIdx; i++) copy_v3_v3(v_cos[i], tv_cos[indices[i]]); MEM_freeN(tv_cos); } else dm->getVertCos(dm, v_cos); /* Compute wanted distances. */ if (wmd->proximity_mode == MOD_WVG_PROXIMITY_OBJECT) { const float dist = get_ob2ob_distance(ob, obr); for (i = 0; i < numIdx; i++) new_w[i] = dist; } else if (wmd->proximity_mode == MOD_WVG_PROXIMITY_GEOMETRY) { const short use_trgt_verts = (wmd->proximity_flags & MOD_WVG_PROXIMITY_GEOM_VERTS); const short use_trgt_edges = (wmd->proximity_flags & MOD_WVG_PROXIMITY_GEOM_EDGES); const short use_trgt_faces = (wmd->proximity_flags & MOD_WVG_PROXIMITY_GEOM_FACES); if (use_trgt_verts || use_trgt_edges || use_trgt_faces) { DerivedMesh *target_dm = obr->derivedFinal; short free_target_dm = FALSE; if (!target_dm) { if (ELEM3(obr->type, OB_CURVE, OB_SURF, OB_FONT)) target_dm = CDDM_from_curve(obr); else if (obr->type == OB_MESH) { Mesh *me = (Mesh *)obr->data; if (me->edit_btmesh) target_dm = CDDM_from_BMEditMesh(me->edit_btmesh, me, FALSE, FALSE); else target_dm = CDDM_from_mesh(me, obr); } free_target_dm = TRUE; } /* We must check that we do have a valid target_dm! */ if (target_dm) { SpaceTransform loc2trgt; float *dists_v = use_trgt_verts ? MEM_mallocN(sizeof(float) * numIdx, "dists_v") : NULL; float *dists_e = use_trgt_edges ? MEM_mallocN(sizeof(float) * numIdx, "dists_e") : NULL; float *dists_f = use_trgt_faces ? MEM_mallocN(sizeof(float) * numIdx, "dists_f") : NULL; space_transform_setup(&loc2trgt, ob, obr); get_vert2geom_distance(numIdx, v_cos, dists_v, dists_e, dists_f, target_dm, &loc2trgt); for (i = 0; i < numIdx; i++) { new_w[i] = dists_v ? dists_v[i] : FLT_MAX; if (dists_e) new_w[i] = minf(dists_e[i], new_w[i]); if (dists_f) new_w[i] = minf(dists_f[i], new_w[i]); } if (free_target_dm) target_dm->release(target_dm); if (dists_v) MEM_freeN(dists_v); if (dists_e) MEM_freeN(dists_e); if (dists_f) MEM_freeN(dists_f); } /* Else, fall back to default obj2vert behavior. */ else { get_vert2ob_distance(numIdx, v_cos, new_w, ob, obr); } } else { get_vert2ob_distance(numIdx, v_cos, new_w, ob, obr); } } /* Map distances to weights. */ do_map(new_w, numIdx, wmd->min_dist, wmd->max_dist, wmd->falloff_type); /* Do masking. */ weightvg_do_mask(numIdx, indices, org_w, new_w, ob, dm, wmd->mask_constant, wmd->mask_defgrp_name, wmd->modifier.scene, wmd->mask_texture, wmd->mask_tex_use_channel, wmd->mask_tex_mapping, wmd->mask_tex_map_obj, wmd->mask_tex_uvlayer_name); /* Update vgroup. Note we never add nor remove vertices from vgroup here. */ weightvg_update_vg(dvert, defgrp_idx, dw, numIdx, indices, org_w, FALSE, 0.0f, FALSE, 0.0f); /* If weight preview enabled... */ #if 0 /* XXX Currently done in mod stack :/ */ if (do_prev) DM_update_weight_mcol(ob, dm, 0, org_w, numIdx, indices); #endif /* Freeing stuff. */ MEM_freeN(org_w); MEM_freeN(new_w); MEM_freeN(dw); if (indices) MEM_freeN(indices); MEM_freeN(v_cos); #if DO_PROFILE TIMEIT_END(perf) #endif /* Return the vgroup-modified mesh. */ return dm; }
enum bverror do_blit(struct bvbltparams *bvbltparams, struct gcbatch *batch, struct surfaceinfo *srcinfo) { enum bverror bverror = BVERR_NONE; struct gccontext *gccontext = get_context(); struct gcmosrc0 *gcmosrc0; struct gcmosrc *gcmosrc; struct gcblit *gcblit; unsigned int index; struct bvbuffmap *dstmap = NULL; struct bvbuffmap *srcmap = NULL; struct surfaceinfo *dstinfo; int dstshiftX, dstshiftY; int dstpixalign, dstbyteshift; int dstoffsetX, dstoffsetY; int srcshiftX, srcshiftY, srctopedge; struct gcrect srcclipped; int srcsurfwidth, srcsurfheight; unsigned int physwidth, physheight; int orthogonal; int multisrc; GCENTER(GCZONE_BLIT); /* 3-plane source not supported. */ if ((srcinfo->format.type == BVFMT_YUV) && (srcinfo->format.cs.yuv.planecount == 3)) { BVSETBLTERROR((srcinfo->index == 0) ? BVERR_SRC1GEOM_FORMAT : BVERR_SRC2GEOM_FORMAT, "unsupported source%d format.", srcinfo->index + 1); goto exit; } /* Get a shortcut to the destination surface. */ dstinfo = &batch->dstinfo; /* Parse destination parameters. */ bverror = parse_destination(bvbltparams, batch); if (bverror != BVERR_NONE) goto exit; /* Setup rotation. */ process_dest_rotation(bvbltparams, batch); /*********************************************************************** * Determine source surface alignment offset. */ /* Determine whether the source and the destination are orthogonal * to each other. */ orthogonal = (srcinfo->angle % 2) != (dstinfo->angle % 2); /* Compute clipped source rectangle. */ srcclipped.left = srcinfo->rect.left + batch->clipdelta.left; srcclipped.top = srcinfo->rect.top + batch->clipdelta.top; srcclipped.right = srcinfo->rect.right + batch->clipdelta.right; srcclipped.bottom = srcinfo->rect.bottom + batch->clipdelta.bottom; GCPRINT_RECT(GCZONE_SURF, "clipped source", &srcclipped); /* Validate the source rectangle. */ if (!valid_rect(srcinfo->geom, &srcclipped)) { BVSETBLTERROR((srcinfo->index == 0) ? BVERR_SRC1RECT : BVERR_SRC2RECT, "invalid source rectangle."); goto exit; } /* Compute the source surface shift. */ switch (srcinfo->angle) { case ROT_ANGLE_0: srctopedge = srcclipped.top; srcshiftX = srcclipped.left - batch->dstadjusted.left; srcshiftY = srctopedge - batch->dstadjusted.top; break; case ROT_ANGLE_90: srctopedge = srcinfo->geom->width - srcclipped.left; srcshiftX = srcclipped.top - batch->dstadjusted.top; srcshiftY = srctopedge - (batch->dstwidth - batch->dstadjusted.left); srctopedge += 1; break; case ROT_ANGLE_180: srctopedge = srcinfo->geom->height - srcclipped.top; srcshiftX = (srcinfo->geom->width - srcclipped.left) - (batch->dstwidth - batch->dstadjusted.left); srcshiftY = srctopedge - (batch->dstheight - batch->dstadjusted.top); srctopedge += 1; break; case ROT_ANGLE_270: srctopedge = srcclipped.left; srcshiftX = (srcinfo->geom->height - srcclipped.top) - (batch->dstheight - batch->dstadjusted.top); srcshiftY = srctopedge - batch->dstadjusted.left; break; default: srctopedge = 0; srcshiftX = 0; srcshiftY = 0; } /* We cannot be in the middle of a sample, currently only YUV formats * can have subsamples. Adjust vertical position as necessary. * Horizontal position will be adjusted based on the byte offset and * base address alignment requirement. This assumes that if we are * aligned on the base address, then we are also aligned at the * beginning of a sample. */ if (srcinfo->format.type == BVFMT_YUV) { int mody = (srctopedge + srcshiftY) % srcinfo->format.cs.yuv.ysample; if (mody < 0) mody = srcinfo->format.cs.yuv.ysample + mody; srcshiftY -= mody; srcinfo->ypixalign = -mody; } else { srcinfo->ypixalign = 0; } /* Compute the source surface offset in bytes. */ srcinfo->bytealign = srcshiftY * (int) srcinfo->geom->virtstride + srcshiftX * (int) srcinfo->format.bitspp / 8; /* Compute the source offset in pixels needed to compensate * for the surface base address misalignment if any. */ srcinfo->xpixalign = get_pixel_offset(srcinfo, srcinfo->bytealign); GCDBG(GCZONE_SURF, "source surface %d:\n", srcinfo->index + 1); GCDBG(GCZONE_SURF, " surface offset (pixels) = %d,%d\n", srcshiftX, srcshiftY); GCDBG(GCZONE_SURF, " surface offset (bytes) = 0x%08X\n", srcinfo->bytealign); GCDBG(GCZONE_SURF, " srcpixalign = %d,%d\n", srcinfo->xpixalign, srcinfo->ypixalign); /* Apply the source alignment. */ srcinfo->bytealign += srcinfo->xpixalign * (int) srcinfo->format.bitspp / 8; srcshiftX += srcinfo->xpixalign; /* NOTE: at this point the source is ready to be presented, * srcinfo->xpixalign and srcinfo->ypixalign represent additional * adjustments for the DESTINATION. */ GCDBG(GCZONE_SURF, " adjusted surface offset (pixels) = %d,%d\n", srcshiftX, srcshiftY); GCDBG(GCZONE_SURF, " adjusted surface offset (bytes) = 0x%08X\n", srcinfo->bytealign); /* Compute U/V plane offsets. */ if ((srcinfo->format.type == BVFMT_YUV) && (srcinfo->format.cs.yuv.planecount > 1)) set_computeyuv(srcinfo, srcshiftX, srcshiftY); /* Set precomputed destination adjustments based on the destination * base address misalignment only. */ dstshiftX = dstinfo->xpixalign; dstshiftY = dstinfo->ypixalign; /* Apply source adjustemnts. */ if (srcinfo->angle == dstinfo->angle) { dstshiftX += srcinfo->xpixalign; dstshiftY += srcinfo->ypixalign; } else if (((srcinfo->angle + 3) % 4) == dstinfo->angle) { dstshiftY += srcinfo->xpixalign; } else if (((srcinfo->angle + 1) % 4) == dstinfo->angle) { dstshiftX += srcinfo->ypixalign; } /* Compute the destination surface offset in bytes. */ dstbyteshift = dstshiftY * (int) dstinfo->geom->virtstride + dstshiftX * (int) dstinfo->format.bitspp / 8; /* Compute the destination offset in pixels needed to compensate * for the surface base address misalignment if any. If dstpixalign * comes out anything other than zero, multisource blit cannot be * performed. */ dstpixalign = get_pixel_offset(dstinfo, dstbyteshift); GCDBG(GCZONE_SURF, "destination surface:\n"); GCDBG(GCZONE_SURF, " surface offset (pixels) = %d,%d\n", dstshiftX, dstshiftY); GCDBG(GCZONE_SURF, " surface offset (bytes) = 0x%08X\n", dstbyteshift); GCDBG(GCZONE_SURF, " realignment = %d\n", dstpixalign); if ((dstpixalign != 0) || ((srcinfo->xpixalign != 0) && (srcinfo->angle == dstinfo->angle))) { /* Adjust the destination to match the source geometry. */ switch (srcinfo->angle) { case ROT_ANGLE_0: /* Adjust coordinates. */ srcclipped.left -= srcshiftX; srcclipped.top -= srcshiftY; /* Determine source size. */ srcsurfwidth = srcinfo->geom->width - srcinfo->xpixalign; srcsurfheight = srcinfo->geom->height; break; case ROT_ANGLE_90: /* Adjust top coordinate. */ srcclipped.top -= srcshiftX; /* Determine source size. */ srcsurfwidth = srcinfo->geom->height - srcinfo->xpixalign; srcsurfheight = srcinfo->geom->width; break; case ROT_ANGLE_180: /* Determine source size. */ srcsurfwidth = srcinfo->geom->width - srcinfo->xpixalign; srcsurfheight = srcinfo->geom->height; break; case ROT_ANGLE_270: /* Adjust coordinates. */ srcclipped.left -= srcshiftY; /* Determine source size. */ srcsurfwidth = srcinfo->geom->height - srcinfo->xpixalign; srcsurfheight = srcinfo->geom->width; break; default: srcsurfwidth = 0; srcsurfheight = 0; } GCDBG(GCZONE_SURF, "srcrect origin = %d,%d\n", srcclipped.left, srcclipped.top); GCDBG(GCZONE_SURF, "source physical size = %dx%d\n", srcsurfwidth, srcsurfheight); /* Overwrite destination byte offset. */ dstbyteshift = dstinfo->bytealign; /* No adjustment necessary for single-source. */ dstoffsetX = 0; dstoffsetY = 0; /* Set the physical destination size. */ physwidth = dstinfo->physwidth; physheight = dstinfo->physheight; /* Disable multi source for the cases where the destination * and the source address alignments do not match. */ multisrc = 0; GCDBG(GCZONE_SURF, "multi-source disabled.\n"); } else { /* Source origin is not used in multi-source setup. */ srcclipped.left = 0; srcclipped.top = 0; /* Adjust the destination to match the source geometry. */ switch (srcinfo->angle) { case ROT_ANGLE_0: /* Adjust the destination horizontally. */ dstoffsetX = srcinfo->xpixalign; dstoffsetY = srcinfo->ypixalign; /* Apply the source alignment. */ if ((dstinfo->angle % 2) == 0) { physwidth = dstinfo->physwidth - srcinfo->xpixalign; physheight = dstinfo->physheight - srcinfo->ypixalign; } else { physwidth = dstinfo->physwidth - srcinfo->ypixalign; physheight = dstinfo->physheight - srcinfo->xpixalign; } break; case ROT_ANGLE_90: /* Adjust the destination vertically. */ dstoffsetX = srcinfo->ypixalign; dstoffsetY = srcinfo->xpixalign; /* Apply the source alignment. */ if ((dstinfo->angle % 2) == 0) { physwidth = dstinfo->physwidth - srcinfo->ypixalign; physheight = dstinfo->physheight - srcinfo->xpixalign; } else { physwidth = dstinfo->physwidth - srcinfo->xpixalign; physheight = dstinfo->physheight - srcinfo->ypixalign; } break; case ROT_ANGLE_180: /* No adjustment necessary. */ dstoffsetX = 0; dstoffsetY = 0; /* Apply the source alignment. */ if ((dstinfo->angle % 2) == 0) { physwidth = dstinfo->physwidth - srcinfo->xpixalign; physheight = dstinfo->physheight - srcinfo->ypixalign; } else { physwidth = dstinfo->physwidth - srcinfo->ypixalign; physheight = dstinfo->physheight - srcinfo->xpixalign; } break; case ROT_ANGLE_270: /* No adjustment necessary. */ dstoffsetX = 0; dstoffsetY = 0; /* Apply the source alignment. */ if ((dstinfo->angle % 2) == 0) { physwidth = dstinfo->physwidth - srcinfo->ypixalign; physheight = dstinfo->physheight - srcinfo->xpixalign; } else { physwidth = dstinfo->physwidth - srcinfo->xpixalign; physheight = dstinfo->physheight - srcinfo->ypixalign; } break; default: physwidth = 0; physheight = 0; dstoffsetX = 0; dstoffsetY = 0; } /* Source geometry is now the same as the destination. */ if (orthogonal) { srcsurfwidth = physheight; srcsurfheight = physwidth; } else { srcsurfwidth = physwidth; srcsurfheight = physheight; } /* Enable multi-source. */ multisrc = 1; GCDBG(GCZONE_SURF, "multi-source enabled.\n"); } /* Misaligned source may cause the destination parameters * to change, verify whether this has happened. */ if ((batch->dstbyteshift != dstbyteshift) || (batch->dstphyswidth != physwidth) || (batch->dstphysheight != physheight) || (batch->dstoffsetX != dstoffsetX) || (batch->dstoffsetY != dstoffsetY)) { /* Set new values. */ batch->dstbyteshift = dstbyteshift; batch->dstphyswidth = physwidth; batch->dstphysheight = physheight; batch->dstoffsetX = dstoffsetX; batch->dstoffsetY = dstoffsetY; /* Now we need to end the current batch and program * the hardware with the new destination. */ batch->batchflags |= BVBATCH_DST; } /* Check if we need to finalize existing batch. */ if ((batch->batchend != do_blit_end) || (batch->op.blit.srccount == 4) || (batch->op.blit.multisrc == 0) || (multisrc == 0) || ((batch->batchflags & (BVBATCH_DST | BVBATCH_CLIPRECT | BVBATCH_DESTRECT)) != 0)) { /* Finalize existing batch if any. */ bverror = batch->batchend(bvbltparams, batch); if (bverror != BVERR_NONE) goto exit; /* Blit batch. */ batch->batchend = do_blit_end; /* Initialize the new batch. */ gcblit = &batch->op.blit; gcblit->blockenable = 0; gcblit->srccount = 0; gcblit->multisrc = multisrc; /* Set the destination format. */ gcblit->format = dstinfo->format.format; gcblit->swizzle = dstinfo->format.swizzle; /* Set the destination coordinates. */ gcblit->dstrect.left = batch->dstadjusted.left - dstoffsetX; gcblit->dstrect.top = batch->dstadjusted.top - dstoffsetY; gcblit->dstrect.right = batch->dstadjusted.right - dstoffsetX; gcblit->dstrect.bottom = batch->dstadjusted.bottom - dstoffsetY; /* Map the destination. */ bverror = do_map(dstinfo->buf.desc, batch, &dstmap); if (bverror != BVERR_NONE) { bvbltparams->errdesc = gccontext->bverrorstr; goto exit; } /* Set the new destination. */ bverror = set_dst(bvbltparams, batch, dstmap); if (bverror != BVERR_NONE) goto exit; /* Reset the modified flag. */ batch->batchflags &= ~(BVBATCH_DST | BVBATCH_CLIPRECT | BVBATCH_DESTRECT); } /* Map the source. */ bverror = do_map(srcinfo->buf.desc, batch, &srcmap); if (bverror != BVERR_NONE) { bvbltparams->errdesc = gccontext->bverrorstr; goto exit; } /*********************************************************************** ** Configure source. */ /* We need to walk in blocks if the source and the destination * surfaces are orthogonal to each other. */ batch->op.blit.blockenable |= orthogonal; /* Shortcut to the register index. */ index = batch->op.blit.srccount; /* Set surface parameters. */ if (index == 0) { /* Allocate command buffer. */ bverror = claim_buffer(bvbltparams, batch, sizeof(struct gcmosrc0), (void **) &gcmosrc0); if (bverror != BVERR_NONE) goto exit; add_fixup(bvbltparams, batch, &gcmosrc0->address, srcinfo->bytealign); gcmosrc0->config_ldst = gcmosrc0_config_ldst; gcmosrc0->address = GET_MAP_HANDLE(srcmap); gcmosrc0->stride = srcinfo->geom->virtstride; gcmosrc0->rotation.raw = 0; gcmosrc0->rotation.reg.surf_width = srcsurfwidth; gcmosrc0->config.raw = 0; gcmosrc0->config.reg.swizzle = srcinfo->format.swizzle; gcmosrc0->config.reg.format = srcinfo->format.format; gcmosrc0->origin.reg.x = srcclipped.left; gcmosrc0->origin.reg.y = srcclipped.top; gcmosrc0->size.reg = gcregsrcsize_max; gcmosrc0->rotation_ldst = gcmosrc0_rotation_ldst; gcmosrc0->rotationheight.reg.height = srcsurfheight; gcmosrc0->rotationangle.raw = 0; gcmosrc0->rotationangle.reg.src = rotencoding[srcinfo->angle]; gcmosrc0->rotationangle.reg.dst = rotencoding[dstinfo->angle]; gcmosrc0->rotationangle.reg.src_mirror = srcinfo->mirror; gcmosrc0->rotationangle.reg.dst_mirror = GCREG_MIRROR_NONE; gcmosrc0->rop_ldst = gcmosrc0_rop_ldst; gcmosrc0->rop.raw = 0; gcmosrc0->rop.reg.type = GCREG_ROP_TYPE_ROP3; gcmosrc0->rop.reg.fg = (unsigned char) srcinfo->rop; gcmosrc0->mult_ldst = gcmosrc0_mult_ldst; gcmosrc0->mult.raw = 0; gcmosrc0->mult.reg.srcglobalpremul = GCREG_COLOR_MULTIPLY_MODES_SRC_GLOBAL_PREMULTIPLY_DISABLE; if (srcinfo->format.premultiplied) gcmosrc0->mult.reg.srcpremul = GCREG_COLOR_MULTIPLY_MODES_SRC_PREMULTIPLY_DISABLE; else gcmosrc0->mult.reg.srcpremul = GCREG_COLOR_MULTIPLY_MODES_SRC_PREMULTIPLY_ENABLE; if (dstinfo->format.premultiplied) { gcmosrc0->mult.reg.dstpremul = GCREG_COLOR_MULTIPLY_MODES_SRC_PREMULTIPLY_DISABLE; gcmosrc0->mult.reg.dstdemul = GCREG_COLOR_MULTIPLY_MODES_DST_DEMULTIPLY_DISABLE; } else { gcmosrc0->mult.reg.dstpremul = GCREG_COLOR_MULTIPLY_MODES_SRC_PREMULTIPLY_ENABLE; gcmosrc0->mult.reg.dstdemul = GCREG_COLOR_MULTIPLY_MODES_DST_DEMULTIPLY_ENABLE; } /* Program blending. */ bverror = set_blending(bvbltparams, batch, srcinfo); if (bverror != BVERR_NONE) goto exit; /* Program YUV source. */ if (srcinfo->format.type == BVFMT_YUV) { bverror = set_yuvsrc(bvbltparams, batch, srcinfo, srcmap); if (bverror != BVERR_NONE) goto exit; } } else { /* Allocate command buffer. */ bverror = claim_buffer(bvbltparams, batch, sizeof(struct gcmosrc), (void **) &gcmosrc); if (bverror != BVERR_NONE) goto exit; add_fixup(bvbltparams, batch, &gcmosrc->address, srcinfo->bytealign); gcmosrc->address_ldst = gcmosrc_address_ldst[index]; gcmosrc->address = GET_MAP_HANDLE(srcmap); gcmosrc->stride_ldst = gcmosrc_stride_ldst[index]; gcmosrc->stride = srcinfo->geom->virtstride; gcmosrc->rotation_ldst = gcmosrc_rotation_ldst[index]; gcmosrc->rotation.raw = 0; gcmosrc->rotation.reg.surf_width = srcsurfwidth; gcmosrc->config_ldst = gcmosrc_config_ldst[index]; gcmosrc->config.raw = 0; gcmosrc->config.reg.swizzle = srcinfo->format.swizzle; gcmosrc->config.reg.format = srcinfo->format.format; gcmosrc->origin_ldst = gcmosrc_origin_ldst[index]; gcmosrc->origin.reg.x = srcclipped.left; gcmosrc->origin.reg.y = srcclipped.top; gcmosrc->size_ldst = gcmosrc_size_ldst[index]; gcmosrc->size.reg = gcregsrcsize_max; gcmosrc->rotationheight_ldst = gcmosrc_rotationheight_ldst[index]; gcmosrc->rotationheight.reg.height = srcsurfheight; gcmosrc->rotationangle_ldst = gcmosrc_rotationangle_ldst[index]; gcmosrc->rotationangle.raw = 0; gcmosrc->rotationangle.reg.src = rotencoding[srcinfo->angle]; gcmosrc->rotationangle.reg.dst = rotencoding[dstinfo->angle]; gcmosrc->rotationangle.reg.src_mirror = srcinfo->mirror; gcmosrc->rotationangle.reg.dst_mirror = GCREG_MIRROR_NONE; gcmosrc->rop_ldst = gcmosrc_rop_ldst[index]; gcmosrc->rop.raw = 0; gcmosrc->rop.reg.type = GCREG_ROP_TYPE_ROP3; gcmosrc->rop.reg.fg = (unsigned char) srcinfo->rop; gcmosrc->mult_ldst = gcmosrc_mult_ldst[index]; gcmosrc->mult.raw = 0; gcmosrc->mult.reg.srcglobalpremul = GCREG_COLOR_MULTIPLY_MODES_SRC_GLOBAL_PREMULTIPLY_DISABLE; if (srcinfo->format.premultiplied) gcmosrc->mult.reg.srcpremul = GCREG_COLOR_MULTIPLY_MODES_SRC_PREMULTIPLY_DISABLE; else gcmosrc->mult.reg.srcpremul = GCREG_COLOR_MULTIPLY_MODES_SRC_PREMULTIPLY_ENABLE; if (dstinfo->format.premultiplied) { gcmosrc->mult.reg.dstpremul = GCREG_COLOR_MULTIPLY_MODES_SRC_PREMULTIPLY_DISABLE; gcmosrc->mult.reg.dstdemul = GCREG_COLOR_MULTIPLY_MODES_DST_DEMULTIPLY_DISABLE; } else { gcmosrc->mult.reg.dstpremul = GCREG_COLOR_MULTIPLY_MODES_SRC_PREMULTIPLY_ENABLE; gcmosrc->mult.reg.dstdemul = GCREG_COLOR_MULTIPLY_MODES_DST_DEMULTIPLY_ENABLE; } /* Program blending. */ bverror = set_blending_index(bvbltparams, batch, srcinfo, index); if (bverror != BVERR_NONE) goto exit; /* Program YUV source. */ if (srcinfo->format.type == BVFMT_YUV) { bverror = set_yuvsrc_index(bvbltparams, batch, srcinfo, srcmap, index); if (bverror != BVERR_NONE) goto exit; } } batch->op.blit.srccount += 1; exit: GCEXITARG(GCZONE_BLIT, "bv%s = %d\n", (bverror == BVERR_NONE) ? "result" : "error", bverror); return bverror; }
mmap_t* CMMap::map_read(int fd, size_t size, size_t offset, size_t size_max) { return do_map(PROT_READ, fd, size, offset, size_max, true); }
int main(int argc, char* argv[]){ char* action; Window window; int arg[5]={0}; // Connexion à un serveur X display = XOpenDisplay(NULL); if(!display){ printf("Can not open display.\n"); exit(EXIT_FAILURE); } // Récupère la valeur par default des différentes variables. screen = DefaultScreen(display); gc = DefaultGC (display, screen); root = RootWindow (display, screen); // Détermine l'action à effectuer : // On vérifie que le 2er argument (autre que nom fichier) est un id de fenetre : if(argc>2 && ((!strncmp(argv[2],"0x",2) && strtoll(argv[2],NULL,16)) || strtoll(argv[2],NULL,10)) ){ action = argv[1]; window = get_window(argv); // Si 5 arguments, c'est soit un move, soit un resize: if (argc==3){ // 1 seul argument (ex: 0x32422 ) if(!strcmp(action,"mapRaise")) do_map_and_raise(window); else if(!strcmp(action,"map")) do_map(window); else if(!strcmp(action,"raise")) do_raise(window); else if(!strcmp(action,"destroy")) do_destroy(window); else if(!strcmp(action,"focus")) do_focus(window); else if(!strcmp(action,"minimize")) do_minimize(window); else if(!strcmp(action,"set_desktop")) set_desktop((int)strtoll(argv[2],NULL,10)); else fail(); } else if(argc==4){ // 2 arguments (ex : 0x4242535 1 ) if(!strcmp(action,"set_desktop_for_window")){ set_desktop(strtoll(argv[3],NULL,10)); set_desktop_for_window(window,strtoll(argv[3],NULL,10)); } else if(!strcmp(action,"set_viewport")) set_viewport((int)strtoll(argv[2],NULL,10),(int)strtoll(argv[3],NULL,10)); else fail(); } else if(argc==5){ arg[0]=(int)strtoll(argv[3],NULL,10); arg[1]=(int)strtoll(argv[4],NULL,10); if(!strcmp(action,"move")) do_move(window, arg[0], arg[1]); else if(!strcmp(action,"resize")) do_resize(window,arg[0],arg[1]); else fail(); } else if(argc==7){ arg[0]=(int)strtoll(argv[3],NULL,10); arg[1]=(int)strtoll(argv[4],NULL,10); arg[2]=(int)strtoll(argv[5],NULL,10); arg[3]=(int)strtoll(argv[6],NULL,10); if(!strcmp(action,"moveResize")) do_move_and_resize(window, arg[0], arg[1], arg[2], arg[3]); else fail(); } else fail(); } else fail(); XCloseDisplay(display); return EXIT_SUCCESS; }
mmap_t* CMMap::map_write(int fd, size_t size, size_t offset, size_t size_max) { return do_map(PROT_WRITE, fd, size, offset, size_max, true); }
mmap_t* CMMap::map_both(int fd, size_t size, size_t offset, size_t size_max) { return do_map(PROT_READ|PROT_WRITE, fd, size, offset, size_max, true); }
void loop(void) { enum { ST_COMMAND, ST_TRANSPARENT } state; fd_set rdset, wrset; int r, n; unsigned char c; tty_q.len = 0; state = ST_TRANSPARENT; while ( ! sig_exit ) { FD_ZERO(&rdset); FD_ZERO(&wrset); FD_SET(STI, &rdset); FD_SET(tty_fd, &rdset); if ( tty_q.len ) FD_SET(tty_fd, &wrset); r = select(tty_fd + 1, &rdset, &wrset, NULL, NULL); if ( r < 0 ) { if ( errno == EINTR ) continue; else fatal("select failed: %d : %s", errno, strerror(errno)); } if ( FD_ISSET(STI, &rdset) ) { /* read from terminal */ do { n = read(STI, &c, 1); } while (n < 0 && errno == EINTR); if (n == 0) { fatal("stdin closed"); } else if (n < 0) { /* is this really necessary? better safe than sory! */ if ( errno != EAGAIN && errno != EWOULDBLOCK ) fatal("read from stdin failed: %s", strerror(errno)); else goto skip_proc_STI; } switch (state) { case ST_COMMAND: if ( c == opts.escape ) { /* pass the escape character down */ if (tty_q.len + M_MAXMAP <= TTY_Q_SZ) { n = do_map((char *)tty_q.buff + tty_q.len, opts.omap, c); tty_q.len += n; if ( opts.lecho ) map_and_write(STO, opts.emap, c); } else { fd_printf(STO, "\x07"); } } else { /* process command key */ if ( do_command(c) ) /* picocom exit */ return; } state = ST_TRANSPARENT; break; case ST_TRANSPARENT: if ( c == opts.escape ) { state = ST_COMMAND; } else { if (tty_q.len + M_MAXMAP <= TTY_Q_SZ) { n = do_map((char *)tty_q.buff + tty_q.len, opts.omap, c); tty_q.len += n; if ( opts.lecho ) map_and_write(STO, opts.emap, c); } else fd_printf(STO, "\x07"); } break; default: assert(0); break; } } skip_proc_STI: if ( FD_ISSET(tty_fd, &rdset) ) { char buff_rd[TTY_RD_SZ]; char buff_map[TTY_RD_SZ * M_MAXMAP]; /* read from port */ do { n = read(tty_fd, &buff_rd, sizeof(buff_rd)); } while (n < 0 && errno == EINTR); if (n == 0) { fatal("term closed"); } else if ( n < 0 ) { if ( errno != EAGAIN && errno != EWOULDBLOCK ) fatal("read from term failed: %s", strerror(errno)); } else { int i; char *bmp = &buff_map[0]; for (i = 0; i < n; i++) { bmp += do_map(bmp, opts.imap, buff_rd[i]); } n = bmp - buff_map; if ( writen_ni(STO, buff_map, n) < n ) fatal("write to stdout failed: %s", strerror(errno)); } } if ( FD_ISSET(tty_fd, &wrset) ) { /* write to port */ int sz; sz = (tty_q.len < tty_write_sz) ? tty_q.len : tty_write_sz; do { n = write(tty_fd, tty_q.buff, sz); } while ( n < 0 && errno == EINTR ); if ( n <= 0 ) fatal("write to term failed: %s", strerror(errno)); memmove(tty_q.buff, tty_q.buff + n, tty_q.len - n); tty_q.len -= n; } } }