void WPaintedWidget::resize(const WLength& width, const WLength& height)
{
if (!width.isAuto() && !height.isAuto()) {
setLayoutSizeAware(false);
resizeCanvas(static_cast<int>(width.toPixels()),
static_cast<int>(height.toPixels()));
}
WInteractWidget::resize(width, height);
}
void WPaintedWidget::layoutSizeChanged(int width, int height)
{
// WInteractWidget::resize(width, height);
resizeCanvas(width, height);
}
bool CAPresentationHandler::openDocument (const QString& uri)
{
QString error;
QString mimetype = KMimeType::findByPath (uri)->name();
KoDocumentEntry documentEntry = KoDocumentEntry::queryByMimeType(mimetype);
KoPart *part = documentEntry.createKoPart(&error);
if (!part) {
kDebug() << "Doc can't be openend" << error;
return false;
}
d->document = qobject_cast<KPrDocument*> (part->document());
d->document->openUrl (KUrl (uri));
KoCanvasBase* paCanvas = dynamic_cast<KoCanvasBase*>(part->canvasItem(d->document));
KoPACanvasItem* paCanvasItem = dynamic_cast<KoPACanvasItem*> (paCanvas);
if (!paCanvasItem) {
kDebug() << "Failed to fetch a canvas item";
return false;
}
if (paCanvasItem) {
d->paView = new CAPAView (documentController()->canvasController(), dynamic_cast<KoPACanvasBase*> (paCanvas),
d->document);
paCanvasItem->setView (d->paView);
documentController()->canvasController()->setZoomHandler (static_cast<KoZoomHandler*> (paCanvasItem->viewConverter()));
d->paView->connectToZoomController();
// update the canvas whenever we scroll, the canvas controller must emit this signal on scrolling/panning
connect (documentController()->canvasController()->canvasControllerProxyObject(),
SIGNAL(moveDocumentOffset(QPoint)), paCanvasItem, SLOT(slotSetDocumentOffset(QPoint)));
// whenever the size of the document viewed in the canvas changes, inform the zoom controller
connect (paCanvasItem, SIGNAL(documentSize(QSize)), this, SLOT(tellZoomControllerToSetDocumentSize(QSize)));
paCanvasItem->update();
}
setCanvas (paCanvas);
KoToolManager::instance()->addController (documentController()->canvasController());
connect(documentController()->canvasController(), SIGNAL(needsCanvasResize(QSizeF)), SLOT(resizeCanvas(QSizeF)));
connect (documentController()->canvasController(), SIGNAL(needCanvasUpdate()), SLOT(updateCanvas()));
d->paDocumentModel = new CAPADocumentModel(this, d->document);
emit totalNumberOfSlidesChanged();
QTimer::singleShot(0, this, SLOT(nextSlide()));
return true;
}
void
cs_callback(GapIO *io, int contig, void *fdata, reg_data *jdata) {
char cmd[1024];
obj_cs *cs = (obj_cs *)fdata;
switch(jdata->job) {
case REG_BUFFER_START:
{
#ifdef DEBUG
printf("REG_BUFFER_START count %d \n", cs->buffer_count);
#endif
cs->buffer_count++;
cs->do_update = REG_BUFFER_START;
return;
}
case REG_BUFFER_END:
{
#ifdef DEBUG
printf("REG_BUFFER_END count %d \n", cs->buffer_count);
#endif
cs->buffer_count--;
if (cs->buffer_count <= 0) {
cs->buffer_count = 0;
if (cs->do_update & REG_LENGTH) {
} else if (cs->do_update & REG_ANNO) {
Tcl_VarEval(GetInterp(), cs->hori, " delete tag", NULL);
display_cs_tags(GetInterp(), io, cs);
scaleSingleCanvas(GetInterp(), cs->world, cs->canvas,
cs->hori, 'x', "tag");
} else if (cs->do_update & REG_ORDER) {
update_contig_selector(GetInterp(), io, cs);
if (cs->vert[0] != '\0') {
update_contig_comparator(GetInterp(), io, cs);
}
}
cs->do_update = 0;
}
return;
}
case REG_QUERY_NAME:
{
sprintf(jdata->name.line, "Contig selector");
return;
}
case REG_GET_OPS:
{
/* jdata->get_ops.ops = "Information\0Configure\0"; */
return;
}
case REG_ANNO:
{
#ifdef DEBUG
printf("contig selector REG_ANNO\n");
#endif
if (!cs->do_update) {
Tcl_VarEval(GetInterp(), cs->hori, " delete tag", NULL);
display_cs_tags(GetInterp(), io, cs);
scaleSingleCanvas(GetInterp(), cs->world, cs->canvas,
cs->hori, 'x', "tag");
} else {
cs->do_update |= REG_ANNO;
}
return;
}
case REG_ORDER:
{
#ifdef DEBUG
printf("contig selector REG_ORDER %d\n", cs->buffer_count);
#endif
if (!cs->do_update) {
update_contig_selector(GetInterp(), io, cs);
if (cs->vert[0] != '\0') {
update_contig_comparator(GetInterp(), io, cs);
}
} else {
cs->do_update |= REG_ORDER;
}
break;
}
case REG_QUIT:
{
cs_shutdown(io, cs);
return;
}
case REG_GENERIC:
switch(jdata->generic.task) {
case TASK_WINDOW_ADD:
{
win *winfo = (win *)jdata->generic.data;
addWindow(cs->win_list, &cs->num_wins, winfo->window,
winfo->scroll, winfo->id);
break;
}
case TASK_WINDOW_DELETE:
{
char *window = (char *)jdata->generic.data;
deleteWindow(cs->win_list, &cs->num_wins, window);
break;
}
case TASK_CANVAS_SCROLLX:
{
char *scroll = (char *)jdata->generic.data;
canvasScrollX(GetInterp(), cs->window, cs->win_list,
cs->num_wins, cs->world->visible, cs->canvas,
scroll);
break;
}
case TASK_CANVAS_SCROLLY:
{
char *scroll = (char *)jdata->generic.data;
canvasScrollY(GetInterp(), cs->window, cs->win_list,
cs->num_wins, cs->world->visible, cs->canvas,
scroll);
break;
}
case TASK_CANVAS_RESIZE:
{
char scroll_args[20];
/* resize template display window */
resizeCanvas(GetInterp(), cs->window, cs->win_list,
cs->num_wins, cs->world->visible,
cs->world->total, cs->canvas);
sprintf(scroll_args, "scroll 0 units");
canvasScrollX(GetInterp(), cs->window, cs->win_list,
cs->num_wins, cs->world->visible, cs->canvas,
scroll_args);
break;
}
case TASK_CANVAS_ZOOMBACK:
{
if (lengthZoom(cs->zoom) <= 2) {
freeZoom(&cs->zoom);
pushZoom(&cs->zoom, cs->world->total);
}
canvasZoomback(GetInterp(), cs->canvas, cs->window, cs->world,
cs->win_list, cs->num_wins, &cs->zoom);
break;
}
case TASK_CANVAS_ZOOM:
{
s_zoom *szoom = (s_zoom *)jdata->generic.data;
canvasZoom(GetInterp(), cs->canvas, cs->window, cs->world,
cs->win_list, cs->num_wins, &cs->zoom, szoom->zoom,
szoom->scroll);
break;
}
case TASK_CANVAS_CURSOR_X:
{
char *label;
int *cx = (int *)jdata->generic.data;
double local_pos;
double wx, wy;
CanvasToWorld(cs->canvas, *cx, 0, &wx, &wy);
label = get_default_string(GetInterp(), gap_defs,
"CONTIG_SEL.CURSOR1_X");
canvasCursorX(GetInterp(), cs->canvas, cs->frame, label,
cs->cursor.colour, cs->cursor.width, *cx, wx,
cs->win_list, cs->num_wins);
/* fill in local position of cursor in label box */
local_pos = CSLocalCursor(io, wx);
label = get_default_string(GetInterp(), gap_defs,
"CONTIG_SEL.CURSOR2_X");
sprintf(cmd, "%s%s configure -text %d\n", cs->frame, label,
(int)local_pos);
Tcl_Eval(GetInterp(), cmd);
break;
}
case TASK_CANVAS_CURSOR_Y:
{
char *label;
int *cy = (int *)jdata->generic.data;
double local_pos;
double wx, wy;
char cmd[1024];
double cx1, cy1;
CanvasToWorld(cs->canvas, 0, *cy, &wx, &wy);
WorldToCanvas(cs->canvas, wy, 0, &cx1, &cy1);
label = get_default_string(GetInterp(), gap_defs,
"CONTIG_SEL.CURSOR1_Y");
canvasCursorY(GetInterp(), cs->canvas, cs->frame, label,
cs->cursor.colour, cs->cursor.width, *cy, wy,
cs->win_list, cs->num_wins);
sprintf(cmd, "DrawCanvasCursorX1 %s %s %.20f %s %d\n",
cs->frame, cs->hori, cx1, cs->cursor.colour,
cs->cursor.width);
if (TCL_ERROR == Tcl_Eval(GetInterp(), cmd))
printf("%s\n", GetInterpResult());
/* fill in local position of cursor in label box */
local_pos = CSLocalCursor(io, wy);
label = get_default_string(GetInterp(), gap_defs,
"CONTIG_SEL.CURSOR2_Y");
sprintf(cmd, "%s%s configure -text %d\n", cs->frame, label,
(int)local_pos);
Tcl_Eval(GetInterp(), cmd);
break;
}
case TASK_CANVAS_CURSOR_DELETE:
{
int i;
for (i = 0; i < cs->num_wins; i++) {
Tcl_VarEval(GetInterp(), cs->win_list[i]->window,
" delete cursor_x cursor_x1 cursor_y", NULL);
}
break;
}
case TASK_CS_REDRAW:
{
/* HACK - never used */
int i, id = register_id();
for (i = 1; i <= NumContigs(io); i++) {
contig_deregister(io, i, cs_callback, fdata);
contig_register(io, i, cs_callback, fdata, id,
REG_REQUIRED |
REG_DATA_CHANGE |
REG_OPS |
REG_NUMBER_CHANGE |
REG_ANNO |
REG_GENERIC |
REG_FLAG_INVIS |
REG_BUFFER,
REG_TYPE_CONTIGSEL);
}
break;
}
break;
}
break;
case REG_JOIN_TO:
case REG_LENGTH:
case REG_DELETE:
case REG_COMPLEMENT:
case REG_NUMBER_CHANGE:
#ifdef DEBUG
printf("contig selector REG_REDRAW %d\n", cs->buffer_count);
#endif
update_contig_selector(GetInterp(), io, cs);
if (cs->vert[0] != '\0') {
update_contig_comparator(GetInterp(), io, cs);
}
/* update tcl globals, CurContig, LREG and RREG */
sprintf(cmd, "ContigParams %d", *handle_io(io));
Tcl_Eval(GetInterp(), cmd);
#ifdef HACK
printf("COM %s \n", cs->com);
if (cs->buffer_count) {
cs->do_update = 1;
} else {
Tcl_Eval(cs->interp, cs->com);
}
#endif
break;
}
}
void CanvasRenderer::sizePropChanged() {
resizeCanvas(canvasSize_.get());
}
bool CASpreadsheetHandler::openDocument (const QString& uri)
{
QString error;
QString mimetype = KMimeType::findByPath (uri)->name();
KoPart *part = KMimeTypeTrader::createInstanceFromQuery<KoPart>(mimetype,
QLatin1String("Calligra/Part"), 0, QString(), QVariantList(), &error);
if (!part) {
kDebug() << "Doc can't be openend" << error;
return false;
}
d->document = static_cast<Calligra::Sheets::Doc*> (part->document());
d->document->openUrl (KUrl (uri));
setCanvas (dynamic_cast<KoCanvasBase*>(part->canvasItem(d->document)));
KoToolManager::instance()->addController (documentController()->canvasController());
d->canvasItem = dynamic_cast<Calligra::Sheets::CanvasItem*> (canvas());
if (!d->canvasItem) {
kDebug() << "Failed to fetch a canvas item";
return false;
}
KoZoomHandler* zoomHandler = new KoZoomHandler();
documentController()->canvasController()->setZoomHandler (zoomHandler);
KoZoomController* zoomController = documentController()->canvasController()->zoomController();
zoomController->setZoom (KoZoomMode::ZOOM_CONSTANT, 1.0);
documentController()->canvasController()->setCanvasMode (KoCanvasController::Spreadsheet);
if (d->canvasItem) {
// update the canvas whenever we scroll, the canvas controller must emit this signal on scrolling/panning
connect (documentController()->canvasController()->canvasControllerProxyObject(),
SIGNAL(moveDocumentOffset(QPoint)), d->canvasItem, SLOT(setDocumentOffset(QPoint)));
// whenever the size of the document viewed in the canvas changes, inform the zoom controller
connect (d->canvasItem, SIGNAL(documentSizeChanged(QSize)), this, SLOT(tellZoomControllerToSetDocumentSize(QSize)));
d->canvasItem->update();
}
connect (documentController()->canvasController(), SIGNAL(needsCanvasResize(QSizeF)), SLOT(resizeCanvas(QSizeF)));
connect (documentController()->canvasController(), SIGNAL(needCanvasUpdate()), SLOT(updateCanvas()));
updateCanvas();
documentController()->canvasController()->zoomToFit();
emit sheetCountChanged();
return true;
}
